@posthog/agent 2.3.657 → 2.3.663

package/dist/types.d.ts

@@ -91,6 +91,8 @@ interface TaskExecutionOptions {
     processCallbacks?: ProcessSpawnedCallback;
     /** Callback invoked when the agent calls the create_output tool for structured output */
     onStructuredOutput?: (output: Record<string, unknown>) => Promise<void>;
+    /** Additional directories the agent process can access beyond cwd. */
+    additionalDirectories?: string[];
 }
 type LogLevel = "debug" | "info" | "warn" | "error";
 type OnLogCallback = (level: LogLevel, scope: string, message: string, data?: unknown) => void;

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type {\n  GitHandoffCheckpoint,\n  HandoffLocalGitState as GitHandoffLocalGitState,\n} from \"@posthog/git/handoff\";\n\n/**\n * Stored custom notification following ACP extensibility model.\n * Custom notifications use underscore-prefixed methods (e.g., `_posthog/phase_start`).\n * See: https://agentclientprotocol.com/docs/extensibility\n */\nexport interface StoredNotification {\n  type: \"notification\";\n  /** When this notification was stored */\n  timestamp: string;\n  /** JSON-RPC 2.0 notification (no id field = notification, not request) */\n  notification: {\n    jsonrpc: \"2.0\";\n    method: string;\n    params?: Record<string, unknown>;\n  };\n}\n\n/**\n * Type alias for stored log entries.\n */\nexport type StoredEntry = StoredNotification;\n\n// PostHog Task model (matches PostHog Code's OpenAPI schema)\nexport interface Task {\n  id: string;\n  task_number?: number;\n  slug?: string;\n  title: string;\n  description: string;\n  origin_product:\n    | \"error_tracking\"\n    | \"eval_clusters\"\n    | \"user_created\"\n    | \"support_queue\"\n    | \"session_summaries\"\n    | \"signal_report\";\n  github_integration?: number | null;\n  repository: string; // Format: \"organization/repository\" (e.g., \"posthog/posthog-js\")\n  json_schema?: Record<string, unknown> | null; // JSON schema for task output validation\n  internal?: boolean;\n  created_at: string;\n  updated_at: string;\n  created_by?: {\n    id: number;\n    uuid: string;\n    distinct_id: string;\n    first_name: string;\n    email: string;\n  };\n  latest_run?: TaskRun;\n}\n\n// Log entry structure for TaskRun.log\n\nexport type ArtifactType =\n  | \"plan\"\n  | \"context\"\n  | \"reference\"\n  | \"output\"\n  | \"artifact\"\n  | \"user_attachment\";\n\nexport interface TaskRunArtifact {\n  id?: string;\n  name: string;\n  type: ArtifactType;\n  source?: string;\n  size?: number;\n  content_type?: string;\n  storage_path?: string;\n  uploaded_at?: string;\n}\n\nexport type TaskRunStatus =\n  | \"not_started\"\n  | \"queued\"\n  | \"in_progress\"\n  | \"completed\"\n  | \"failed\"\n  | \"cancelled\";\n\nexport type TaskRunEnvironment = \"local\" | \"cloud\";\n\n// TaskRun model - represents individual execution runs of tasks\nexport interface TaskRun {\n  id: string;\n  task: string; // Task ID\n  team: number;\n  branch: string | null;\n  stage: string | null; // Current stage (e.g., 'research', 'plan', 'build')\n  environment: TaskRunEnvironment;\n  status: TaskRunStatus;\n  log_url: string;\n  error_message: string | null;\n  output: Record<string, unknown> | null; // Structured output (PR URL, commit SHA, etc.)\n  state: Record<string, unknown>; // Intermediate run state (defaults to {}, never null)\n  artifacts?: TaskRunArtifact[];\n  created_at: string;\n  updated_at: string;\n  completed_at: string | null;\n}\n\nexport interface ProcessSpawnedCallback {\n  onProcessSpawned?: (info: {\n    pid: number;\n    command: string;\n    sessionId?: string;\n  }) => void;\n  onProcessExited?: (pid: number) => void;\n  onMcpServersReady?: (serverNames: string[]) => void;\n}\n\nexport interface TaskExecutionOptions {\n  repositoryPath?: string;\n  adapter?: \"claude\" | \"codex\";\n  model?: string;\n  gatewayUrl?: string;\n  codexBinaryPath?: string;\n  instructions?: string;\n  processCallbacks?: ProcessSpawnedCallback;\n  /** Callback invoked when the agent calls the create_output tool for structured output */\n  onStructuredOutput?: (output: Record<string, unknown>) => Promise<void>;\n}\n\nexport type LogLevel = \"debug\" | \"info\" | \"warn\" | \"error\";\n\nexport type OnLogCallback = (\n  level: LogLevel,\n  scope: string,\n  message: string,\n  data?: unknown,\n) => void;\n\nexport interface PostHogAPIConfig {\n  apiUrl: string;\n  getApiKey: () => string | Promise<string>;\n  refreshApiKey?: () => string | Promise<string>;\n  projectId: number;\n  userAgent?: string;\n}\n\nexport interface OtelTransportConfig {\n  /** PostHog ingest host, e.g., \"https://us.i.posthog.com\" */\n  host: string;\n  /** Project API key */\n  apiKey: string;\n  /** Override the logs endpoint path (default: /i/v1/logs) */\n  logsPath?: string;\n}\n\nexport interface AgentConfig {\n  posthog?: PostHogAPIConfig;\n  /** OTEL transport config for shipping logs to PostHog Logs */\n  otelTransport?: OtelTransportConfig;\n  /** Skip session log persistence (e.g. for preview sessions with no real task) */\n  skipLogPersistence?: boolean;\n  /** Local cache path for instant log loading (e.g., ~/.posthog-code) */\n  localCachePath?: string;\n  /**\n   * Annotate files the agent reads with PostHog enrichment (event volume,\n   * flag rollout/staleness, experiment links). Defaults to enabled when\n   * `posthog` config is present; set `{ enabled: false }` to opt out.\n   */\n  enricher?: { enabled?: boolean };\n  debug?: boolean;\n  onLog?: OnLogCallback;\n}\n\n// Device info for tracking where work happens\nexport interface DeviceInfo {\n  type: \"local\" | \"cloud\";\n  name?: string;\n}\n\n// Agent execution mode - for tracking interactive vs background runs, when backgrounded an agent will continue working without asking questions\nexport type AgentMode = \"interactive\" | \"background\";\n\n// Git file status codes\nexport type FileStatus = \"A\" | \"M\" | \"D\";\n\nexport interface FileChange {\n  path: string;\n  status: FileStatus;\n}\n\nexport type HandoffLocalGitState = GitHandoffLocalGitState;\n\nexport interface GitCheckpoint extends GitHandoffCheckpoint {\n  artifactPath?: string;\n  indexArtifactPath?: string;\n}\n\nexport interface GitCheckpointEvent extends GitCheckpoint {\n  device?: DeviceInfo;\n}\n\n/**\n * Keeps the emitted `@posthog/agent/types` entrypoint as a runtime ESM module.\n *\n * `export {}` is stripped by tsup in this package, which leaves `dist/types.js`\n * empty and breaks downstream type resolution for the exported subpath.\n */\nexport const AGENT_TYPES_MODULE = true;\n"],"mappings":";AA+MO,IAAM,qBAAqB;","names":[]}
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type {\n  GitHandoffCheckpoint,\n  HandoffLocalGitState as GitHandoffLocalGitState,\n} from \"@posthog/git/handoff\";\n\n/**\n * Stored custom notification following ACP extensibility model.\n * Custom notifications use underscore-prefixed methods (e.g., `_posthog/phase_start`).\n * See: https://agentclientprotocol.com/docs/extensibility\n */\nexport interface StoredNotification {\n  type: \"notification\";\n  /** When this notification was stored */\n  timestamp: string;\n  /** JSON-RPC 2.0 notification (no id field = notification, not request) */\n  notification: {\n    jsonrpc: \"2.0\";\n    method: string;\n    params?: Record<string, unknown>;\n  };\n}\n\n/**\n * Type alias for stored log entries.\n */\nexport type StoredEntry = StoredNotification;\n\n// PostHog Task model (matches PostHog Code's OpenAPI schema)\nexport interface Task {\n  id: string;\n  task_number?: number;\n  slug?: string;\n  title: string;\n  description: string;\n  origin_product:\n    | \"error_tracking\"\n    | \"eval_clusters\"\n    | \"user_created\"\n    | \"support_queue\"\n    | \"session_summaries\"\n    | \"signal_report\";\n  github_integration?: number | null;\n  repository: string; // Format: \"organization/repository\" (e.g., \"posthog/posthog-js\")\n  json_schema?: Record<string, unknown> | null; // JSON schema for task output validation\n  internal?: boolean;\n  created_at: string;\n  updated_at: string;\n  created_by?: {\n    id: number;\n    uuid: string;\n    distinct_id: string;\n    first_name: string;\n    email: string;\n  };\n  latest_run?: TaskRun;\n}\n\n// Log entry structure for TaskRun.log\n\nexport type ArtifactType =\n  | \"plan\"\n  | \"context\"\n  | \"reference\"\n  | \"output\"\n  | \"artifact\"\n  | \"user_attachment\";\n\nexport interface TaskRunArtifact {\n  id?: string;\n  name: string;\n  type: ArtifactType;\n  source?: string;\n  size?: number;\n  content_type?: string;\n  storage_path?: string;\n  uploaded_at?: string;\n}\n\nexport type TaskRunStatus =\n  | \"not_started\"\n  | \"queued\"\n  | \"in_progress\"\n  | \"completed\"\n  | \"failed\"\n  | \"cancelled\";\n\nexport type TaskRunEnvironment = \"local\" | \"cloud\";\n\n// TaskRun model - represents individual execution runs of tasks\nexport interface TaskRun {\n  id: string;\n  task: string; // Task ID\n  team: number;\n  branch: string | null;\n  stage: string | null; // Current stage (e.g., 'research', 'plan', 'build')\n  environment: TaskRunEnvironment;\n  status: TaskRunStatus;\n  log_url: string;\n  error_message: string | null;\n  output: Record<string, unknown> | null; // Structured output (PR URL, commit SHA, etc.)\n  state: Record<string, unknown>; // Intermediate run state (defaults to {}, never null)\n  artifacts?: TaskRunArtifact[];\n  created_at: string;\n  updated_at: string;\n  completed_at: string | null;\n}\n\nexport interface ProcessSpawnedCallback {\n  onProcessSpawned?: (info: {\n    pid: number;\n    command: string;\n    sessionId?: string;\n  }) => void;\n  onProcessExited?: (pid: number) => void;\n  onMcpServersReady?: (serverNames: string[]) => void;\n}\n\nexport interface TaskExecutionOptions {\n  repositoryPath?: string;\n  adapter?: \"claude\" | \"codex\";\n  model?: string;\n  gatewayUrl?: string;\n  codexBinaryPath?: string;\n  instructions?: string;\n  processCallbacks?: ProcessSpawnedCallback;\n  /** Callback invoked when the agent calls the create_output tool for structured output */\n  onStructuredOutput?: (output: Record<string, unknown>) => Promise<void>;\n  /** Additional directories the agent process can access beyond cwd. */\n  additionalDirectories?: string[];\n}\n\nexport type LogLevel = \"debug\" | \"info\" | \"warn\" | \"error\";\n\nexport type OnLogCallback = (\n  level: LogLevel,\n  scope: string,\n  message: string,\n  data?: unknown,\n) => void;\n\nexport interface PostHogAPIConfig {\n  apiUrl: string;\n  getApiKey: () => string | Promise<string>;\n  refreshApiKey?: () => string | Promise<string>;\n  projectId: number;\n  userAgent?: string;\n}\n\nexport interface OtelTransportConfig {\n  /** PostHog ingest host, e.g., \"https://us.i.posthog.com\" */\n  host: string;\n  /** Project API key */\n  apiKey: string;\n  /** Override the logs endpoint path (default: /i/v1/logs) */\n  logsPath?: string;\n}\n\nexport interface AgentConfig {\n  posthog?: PostHogAPIConfig;\n  /** OTEL transport config for shipping logs to PostHog Logs */\n  otelTransport?: OtelTransportConfig;\n  /** Skip session log persistence (e.g. for preview sessions with no real task) */\n  skipLogPersistence?: boolean;\n  /** Local cache path for instant log loading (e.g., ~/.posthog-code) */\n  localCachePath?: string;\n  /**\n   * Annotate files the agent reads with PostHog enrichment (event volume,\n   * flag rollout/staleness, experiment links). Defaults to enabled when\n   * `posthog` config is present; set `{ enabled: false }` to opt out.\n   */\n  enricher?: { enabled?: boolean };\n  debug?: boolean;\n  onLog?: OnLogCallback;\n}\n\n// Device info for tracking where work happens\nexport interface DeviceInfo {\n  type: \"local\" | \"cloud\";\n  name?: string;\n}\n\n// Agent execution mode - for tracking interactive vs background runs, when backgrounded an agent will continue working without asking questions\nexport type AgentMode = \"interactive\" | \"background\";\n\n// Git file status codes\nexport type FileStatus = \"A\" | \"M\" | \"D\";\n\nexport interface FileChange {\n  path: string;\n  status: FileStatus;\n}\n\nexport type HandoffLocalGitState = GitHandoffLocalGitState;\n\nexport interface GitCheckpoint extends GitHandoffCheckpoint {\n  artifactPath?: string;\n  indexArtifactPath?: string;\n}\n\nexport interface GitCheckpointEvent extends GitCheckpoint {\n  device?: DeviceInfo;\n}\n\n/**\n * Keeps the emitted `@posthog/agent/types` entrypoint as a runtime ESM module.\n *\n * `export {}` is stripped by tsup in this package, which leaves `dist/types.js`\n * empty and breaks downstream type resolution for the exported subpath.\n */\nexport const AGENT_TYPES_MODULE = true;\n"],"mappings":";AAiNO,IAAM,qBAAqB;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.657",
+  "version": "2.3.663",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {

package/src/adapters/codex/spawn.ts

@@ -17,6 +17,8 @@ export interface CodexProcessOptions {
   logger?: Logger;
   processCallbacks?: ProcessSpawnedCallback;
   settings?: CodexSettings;
+  /** Additional writable roots passed to Codex's workspace-write sandbox. */
+  additionalDirectories?: string[];
 }
 
 export interface CodexProcess {
@@ -57,6 +59,13 @@ function buildConfigArgs(options: CodexProcessOptions): string[] {
     args.push("-c", `model_reasoning_effort="${options.reasoningEffort}"`);
   }
 
+  if (options.additionalDirectories?.length) {
+    const escaped = options.additionalDirectories
+      .map((p) => `"${p.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`)
+      .join(",");
+    args.push("-c", `sandbox_workspace_write.writable_roots=[${escaped}]`);
+  }
+
   if (options.instructions) {
     const escaped = options.instructions
       .replace(/\\/g, "\\\\")

package/src/agent.ts

@@ -136,6 +136,7 @@ export class Agent {
               binaryPath: options.codexBinaryPath,
               model: sanitizedModel,
               instructions: options.instructions,
+              additionalDirectories: options.additionalDirectories,
             }
           : undefined,
     });

package/src/server/agent-server.test.ts

@@ -203,6 +203,247 @@ describe("AgentServer HTTP Mode", () => {
   });
 
   describe("turn completion", () => {
+    function stubSessionCleanup(testServer: unknown): {
+      cleanupSession: (options?: {
+        completeEventStream?: boolean;
+      }) => Promise<void>;
+      eventStreamSender: {
+        enqueue: ReturnType<typeof vi.fn>;
+        stop: ReturnType<typeof vi.fn>;
+      };
+    } {
+      const cleanupServer = testServer as {
+        session: unknown;
+        eventStreamSender: {
+          enqueue: ReturnType<typeof vi.fn>;
+          stop: ReturnType<typeof vi.fn>;
+        };
+        captureCheckpointState: ReturnType<typeof vi.fn>;
+        cleanupSession: (options?: {
+          completeEventStream?: boolean;
+        }) => Promise<void>;
+      };
+      cleanupServer.captureCheckpointState = vi.fn(async () => {});
+      cleanupServer.eventStreamSender = {
+        enqueue: vi.fn(),
+        stop: vi.fn(async () => {}),
+      };
+      cleanupServer.session = {
+        payload: { run_id: "run-1" },
+        pendingHandoffGitState: undefined,
+        logWriter: { flush: vi.fn(async () => {}) },
+        acpConnection: { cleanup: vi.fn(async () => {}) },
+        sseController: { close: vi.fn() },
+      };
+      return cleanupServer;
+    }
+
+    it("keeps event ingest open for non-terminal session cleanup", async () => {
+      const testServer = stubSessionCleanup(createServer());
+
+      await testServer.cleanupSession();
+
+      expect(testServer.eventStreamSender.enqueue).not.toHaveBeenCalled();
+      expect(testServer.eventStreamSender.stop).not.toHaveBeenCalled();
+    });
+
+    it("stops event ingest for terminal session cleanup without fake task completion", async () => {
+      const testServer = stubSessionCleanup(createServer());
+
+      await testServer.cleanupSession({ completeEventStream: true });
+
+      expect(testServer.eventStreamSender.enqueue).not.toHaveBeenCalled();
+      expect(testServer.eventStreamSender.stop).toHaveBeenCalledOnce();
+    });
+
+    it("writes terminal failure status before completing event ingest", async () => {
+      const order: string[] = [];
+      const testServer = new AgentServer({
+        port,
+        jwtPublicKey: TEST_PUBLIC_KEY,
+        repositoryPath: repo.path,
+        apiUrl: "http://localhost:8000",
+        apiKey: "test-api-key",
+        projectId: 1,
+        mode: "interactive",
+        taskId: "test-task-id",
+        runId: "test-run-id",
+      }) as unknown as {
+        eventStreamSender: {
+          enqueue: (event: Record<string, unknown>) => void;
+          stop: () => Promise<void>;
+        };
+        posthogAPI: {
+          updateTaskRun: (
+            taskId: string,
+            runId: string,
+            payload: Record<string, unknown>,
+          ) => Promise<unknown>;
+        };
+        signalTaskComplete(
+          payload: JwtPayload,
+          stopReason: string,
+          errorMessage?: string,
+        ): Promise<void>;
+      };
+      testServer.eventStreamSender = {
+        enqueue: vi.fn(() => {
+          order.push("enqueue");
+        }),
+        stop: vi.fn(async () => {
+          order.push("stop");
+        }),
+      };
+      testServer.posthogAPI = {
+        updateTaskRun: vi.fn(async () => {
+          order.push("update");
+          return {};
+        }),
+      };
+
+      await testServer.signalTaskComplete(
+        {
+          run_id: "run-1",
+          task_id: "task-1",
+          team_id: 1,
+          user_id: 1,
+          distinct_id: "distinct-id",
+          mode: "interactive",
+        },
+        "error",
+        "boom",
+      );
+
+      expect(order).toEqual(["enqueue", "update", "stop"]);
+      expect(testServer.eventStreamSender.enqueue).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "notification",
+          notification: expect.objectContaining({
+            method: "_posthog/error",
+            params: expect.objectContaining({ error: "boom" }),
+          }),
+        }),
+      );
+      expect(testServer.posthogAPI.updateTaskRun).toHaveBeenCalledWith(
+        "task-1",
+        "run-1",
+        {
+          status: "failed",
+          error_message: "boom",
+        },
+      );
+    });
+
+    it("still stops event ingest when terminal failure status update fails", async () => {
+      const testServer = new AgentServer({
+        port,
+        jwtPublicKey: TEST_PUBLIC_KEY,
+        repositoryPath: repo.path,
+        apiUrl: "http://localhost:8000",
+        apiKey: "test-api-key",
+        projectId: 1,
+        mode: "interactive",
+        taskId: "test-task-id",
+        runId: "test-run-id",
+      }) as unknown as {
+        eventStreamSender: {
+          enqueue: (event: Record<string, unknown>) => void;
+          stop: () => Promise<void>;
+        };
+        posthogAPI: {
+          updateTaskRun: (
+            taskId: string,
+            runId: string,
+            payload: Record<string, unknown>,
+          ) => Promise<unknown>;
+        };
+        signalTaskComplete(
+          payload: JwtPayload,
+          stopReason: string,
+          errorMessage?: string,
+        ): Promise<void>;
+      };
+      testServer.eventStreamSender = {
+        enqueue: vi.fn(),
+        stop: vi.fn(async () => {}),
+      };
+      testServer.posthogAPI = {
+        updateTaskRun: vi.fn(async () => {
+          throw new Error("update failed");
+        }),
+      };
+
+      await testServer.signalTaskComplete(
+        {
+          run_id: "run-1",
+          task_id: "task-1",
+          team_id: 1,
+          user_id: 1,
+          distinct_id: "distinct-id",
+          mode: "interactive",
+        },
+        "error",
+        "boom",
+      );
+
+      expect(testServer.eventStreamSender.enqueue).toHaveBeenCalledOnce();
+      expect(testServer.posthogAPI.updateTaskRun).toHaveBeenCalledOnce();
+      expect(testServer.eventStreamSender.stop).toHaveBeenCalledOnce();
+    });
+
+    it("leaves event ingest open for non-error stop reasons", async () => {
+      const testServer = new AgentServer({
+        port,
+        jwtPublicKey: TEST_PUBLIC_KEY,
+        repositoryPath: repo.path,
+        apiUrl: "http://localhost:8000",
+        apiKey: "test-api-key",
+        projectId: 1,
+        mode: "interactive",
+        taskId: "test-task-id",
+        runId: "test-run-id",
+      }) as unknown as {
+        eventStreamSender: {
+          enqueue: (event: Record<string, unknown>) => void;
+          stop: () => Promise<void>;
+        };
+        posthogAPI: {
+          updateTaskRun: (
+            taskId: string,
+            runId: string,
+            payload: Record<string, unknown>,
+          ) => Promise<unknown>;
+        };
+        signalTaskComplete(
+          payload: JwtPayload,
+          stopReason: string,
+        ): Promise<void>;
+      };
+      testServer.eventStreamSender = {
+        enqueue: vi.fn(),
+        stop: vi.fn(async () => {}),
+      };
+      testServer.posthogAPI = {
+        updateTaskRun: vi.fn(async () => ({})),
+      };
+
+      await testServer.signalTaskComplete(
+        {
+          run_id: "run-1",
+          task_id: "task-1",
+          team_id: 1,
+          user_id: 1,
+          distinct_id: "distinct-id",
+          mode: "interactive",
+        },
+        "end_turn",
+      );
+
+      expect(testServer.eventStreamSender.enqueue).not.toHaveBeenCalled();
+      expect(testServer.eventStreamSender.stop).not.toHaveBeenCalled();
+      expect(testServer.posthogAPI.updateTaskRun).not.toHaveBeenCalled();
+    });
+
     it("persists structured turn completion notifications", () => {
       const appendRawLine = vi.fn();
       const testServer = new AgentServer({

package/src/server/agent-server.ts

@@ -59,6 +59,7 @@ import {
   normalizeCloudPromptContent,
   promptBlocksToText,
 } from "./cloud-prompt";
+import { TaskRunEventStreamSender } from "./event-stream-sender";
 import { type JwtPayload, JwtValidationError, validateJwt } from "./jwt";
 import {
   handoffLocalGitStateSchema,
@@ -233,6 +234,7 @@ export class AgentServer {
   private session: ActiveSession | null = null;
   private app: Hono;
   private posthogAPI: PostHogAPIClient;
+  private eventStreamSender: TaskRunEventStreamSender | null = null;
   private questionRelayedToSlack = false;
   private detectedPrUrl: string | null = null;
   private lastReportedBranch: string | null = null;
@@ -297,6 +299,17 @@ export class AgentServer {
       getApiKey: () => config.apiKey,
       userAgent: `posthog/cloud.hog.dev; version: ${config.version ?? packageJson.version}`,
     });
+    if (config.eventIngestToken) {
+      this.eventStreamSender = new TaskRunEventStreamSender({
+        apiUrl: config.apiUrl,
+        projectId: config.projectId,
+        taskId: config.taskId,
+        runId: config.runId,
+        token: config.eventIngestToken,
+        logger: this.logger.child("EventIngest"),
+        streamWindowMs: config.eventIngestStreamWindowMs,
+      });
+    }
     this.app = this.createApp();
   }
 
@@ -560,7 +573,9 @@ export class AgentServer {
     this.logger.debug("Stopping agent server...");
 
     if (this.session) {
-      await this.cleanupSession();
+      await this.cleanupSession({ completeEventStream: true });
+    } else {
+      await this.eventStreamSender?.stop();
     }
 
     if (this.server) {
@@ -1798,6 +1813,12 @@ ${signedCommitInstructions}
 
     const status = "failed";
 
+    this.enqueueTaskTerminalEvent(POSTHOG_NOTIFICATIONS.ERROR, {
+      source: "agent_server",
+      stopReason,
+      error: errorMessage ?? "Agent error",
+    });
+
     try {
       await this.posthogAPI.updateTaskRun(payload.task_id, payload.run_id, {
         status,
@@ -1806,9 +1827,28 @@ ${signedCommitInstructions}
       this.logger.debug("Task completion signaled", { status, stopReason });
     } catch (error) {
       this.logger.error("Failed to signal task completion", error);
+    } finally {
+      await this.eventStreamSender?.stop();
     }
   }
 
+  private enqueueTaskTerminalEvent(
+    method:
+      | typeof POSTHOG_NOTIFICATIONS.TASK_COMPLETE
+      | typeof POSTHOG_NOTIFICATIONS.ERROR,
+    params: Record<string, unknown>,
+  ): void {
+    this.eventStreamSender?.enqueue({
+      type: "notification",
+      timestamp: new Date().toISOString(),
+      notification: {
+        jsonrpc: "2.0",
+        method,
+        params,
+      },
+    });
+  }
+
   private configureEnvironment({
     isInternal = false,
     originProduct,
@@ -2224,7 +2264,11 @@ ${signedCommitInstructions}
     }
   }
 
-  private async cleanupSession(): Promise<void> {
+  private async cleanupSession({
+    completeEventStream = false,
+  }: {
+    completeEventStream?: boolean;
+  } = {}): Promise<void> {
     if (!this.session) return;
 
     this.logger.debug("Cleaning up session");
@@ -2263,6 +2307,10 @@ ${signedCommitInstructions}
       this.session.sseController.close();
     }
 
+    if (completeEventStream) {
+      await this.eventStreamSender?.stop();
+    }
+
     this.pendingEvents = [];
     this.lastReportedBranch = null;
     this.session = null;
@@ -2346,9 +2394,13 @@ ${signedCommitInstructions}
   }
 
   private broadcastEvent(event: Record<string, unknown>): void {
+    if (!this.session) return;
+
+    this.eventStreamSender?.enqueue(event);
+
     if (this.session?.sseController) {
       this.sendSseEvent(this.session.sseController, event);
-    } else if (this.session) {
+    } else {
       // Buffer events during initialization (sseController not yet attached)
       this.pendingEvents.push(event);
     }

package/src/server/bin.ts

@@ -32,6 +32,15 @@ const envSchema = z.object({
   POSTHOG_CODE_REASONING_EFFORT: z
     .enum(["low", "medium", "high", "xhigh", "max"])
     .optional(),
+  POSTHOG_TASK_RUN_EVENT_INGEST_TOKEN: z.string().min(1).optional(),
+  POSTHOG_TASK_RUN_EVENT_INGEST_STREAM_WINDOW_MS: z
+    .string()
+    .regex(
+      /^[1-9]\d*$/,
+      "POSTHOG_TASK_RUN_EVENT_INGEST_STREAM_WINDOW_MS must be a positive integer",
+    )
+    .transform((value) => parseInt(value, 10))
+    .optional(),
 });
 
 const program = new Command();
@@ -148,6 +157,9 @@ program
     const server = new AgentServer({
       port: parseInt(options.port, 10),
       jwtPublicKey: env.JWT_PUBLIC_KEY,
+      eventIngestToken: env.POSTHOG_TASK_RUN_EVENT_INGEST_TOKEN,
+      eventIngestStreamWindowMs:
+        env.POSTHOG_TASK_RUN_EVENT_INGEST_STREAM_WINDOW_MS,
       repositoryPath: options.repositoryPath,
       apiUrl: env.POSTHOG_API_URL,
       apiKey: env.POSTHOG_PERSONAL_API_KEY,

package/src/server/event-stream-sender.test.ts

@@ -67,6 +67,46 @@ function responseForBody(body: string, lastAcceptedSeq = 0): Response {
   });
 }
 
+type StreamingRequestInit = RequestInit & { duplex: "half" };
+
+function createFetchStreamingUpload({
+  url,
+  headers,
+  abortController,
+}: {
+  url: string;
+  headers: Record<string, string>;
+  abortController: AbortController;
+}) {
+  const bodyStream = new TransformStream<Uint8Array, Uint8Array>();
+  const writer = bodyStream.writable.getWriter();
+  const requestInit: StreamingRequestInit = {
+    method: "POST",
+    headers,
+    body: bodyStream.readable as BodyInit,
+    signal: abortController.signal,
+    duplex: "half",
+  };
+
+  return {
+    write(chunk: Uint8Array): Promise<void> {
+      return writer.write(chunk);
+    },
+    close(): Promise<void> {
+      return writer.close();
+    },
+    async abort(): Promise<void> {
+      abortController.abort();
+      try {
+        await writer.abort();
+      } catch {
+        // The fetch mock may have already closed the body reader.
+      }
+    },
+    responsePromise: fetch(url, requestInit),
+  };
+}
+
 function createSender(
   options: Partial<
     ConstructorParameters<typeof TaskRunEventStreamSender>[0]
@@ -79,6 +119,7 @@ function createSender(
     runId: "run-1",
     token: "ingest-token",
     logger: new Logger({ debug: false }),
+    createStreamingUpload: createFetchStreamingUpload,
     ...options,
   });
 }
@@ -198,6 +239,39 @@ describe("TaskRunEventStreamSender", () => {
     ]);
   });
 
+  it("closes an idle active ingest request after the stream window elapses", async () => {
+    const requestBodies: string[] = [];
+    let activeStreamClosed = false;
+    const fetchMock = vi.fn(
+      async (_url: string | URL | Request, init?: RequestInit) => {
+        if (!init?.body || typeof init.body === "string") {
+          return responseForBody(await readRequestBody(init));
+        }
+
+        const body = await readRequestBody(init);
+        activeStreamClosed = true;
+        requestBodies.push(body);
+        return responseForBody(body);
+      },
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    const sender = createSender({ flushDelayMs: 0, streamWindowMs: 5 });
+
+    sender.enqueue({ type: "notification", notification: { method: "first" } });
+    await waitFor(() => fetchMock.mock.calls.length === 2);
+    expect(activeStreamClosed).toBe(false);
+
+    await waitFor(() => activeStreamClosed, 200);
+    expect(eventSequences(requestBodies[0])).toEqual([1]);
+    expect(completionSequences(requestBodies[0])).toEqual([]);
+
+    await sender.stop();
+
+    expect(eventSequences(requestBodies[1])).toEqual([]);
+    expect(completionSequences(requestBodies[1])).toEqual([1]);
+  });
+
   it("aborts a stuck ingest response after closing the request body", async () => {
     let aborted = false;
     const fetchMock = vi.fn(