@posthog/agent 2.3.302 → 2.3.305

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.302",
+  "version": "2.3.305",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -86,8 +86,8 @@
     "tsx": "^4.20.6",
     "typescript": "^5.5.0",
     "vitest": "^2.1.8",
-    "@posthog/git": "1.0.0",
-    "@posthog/shared": "1.0.0"
+    "@posthog/shared": "1.0.0",
+    "@posthog/git": "1.0.0"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "0.16.1",

package/src/adapters/codex/codex-agent.test.ts

@@ -107,6 +107,48 @@ describe("CodexAcpAgent", () => {
     ).toBe("read-only");
   });
 
+  it("propagates taskRunId and fires SDK_SESSION when loading a cloud session", async () => {
+    const { agent, client } = createAgent();
+    mockCodexConnection.loadSession.mockResolvedValue({
+      modes: { currentModeId: "auto", availableModes: [] },
+      configOptions: [],
+    } satisfies Partial<LoadSessionResponse>);
+
+    await agent.loadSession({
+      sessionId: "session-1",
+      cwd: process.cwd(),
+      _meta: { taskRunId: "run-1", taskId: "task-1" },
+    } as never);
+
+    expect(
+      (agent as unknown as { sessionState: { taskRunId?: string } })
+        .sessionState.taskRunId,
+    ).toBe("run-1");
+    expect(client.extNotification).toHaveBeenCalledWith(
+      "_posthog/sdk_session",
+      {
+        taskRunId: "run-1",
+        sessionId: "session-1",
+        adapter: "codex",
+      },
+    );
+  });
+
+  it("does not emit SDK_SESSION on loadSession when taskRunId is absent", async () => {
+    const { agent, client } = createAgent();
+    mockCodexConnection.loadSession.mockResolvedValue({
+      modes: { currentModeId: "auto", availableModes: [] },
+      configOptions: [],
+    } satisfies Partial<LoadSessionResponse>);
+
+    await agent.loadSession({
+      sessionId: "session-1",
+      cwd: process.cwd(),
+    } as never);
+
+    expect(client.extNotification).not.toHaveBeenCalled();
+  });
+
   it("preserves the live session mode when loading an existing session", async () => {
     const { agent } = createAgent();
     mockCodexConnection.loadSession.mockResolvedValue({
@@ -127,6 +169,46 @@ describe("CodexAcpAgent", () => {
     ).toBe("read-only");
   });
 
+  it("prepends _meta.prContext to the forwarded prompt but not to the broadcast", async () => {
+    const { agent, client } = createAgent();
+    mockCodexConnection.newSession.mockResolvedValue({
+      sessionId: "session-1",
+      modes: { currentModeId: "auto", availableModes: [] },
+      configOptions: [],
+    } satisfies Partial<NewSessionResponse>);
+    await agent.newSession({
+      cwd: process.cwd(),
+    } as never);
+
+    mockCodexConnection.prompt.mockResolvedValue({ stopReason: "end_turn" });
+
+    await agent.prompt({
+      sessionId: "session-1",
+      prompt: [{ type: "text", text: "ship the fix" }],
+      _meta: { prContext: "PR #123 is open; review before editing." },
+    } as never);
+
+    // codex-acp receives the PR context prepended as a text block.
+    expect(mockCodexConnection.prompt).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: [
+          { type: "text", text: "PR #123 is open; review before editing." },
+          { type: "text", text: "ship the fix" },
+        ],
+      }),
+    );
+    // The broadcast shows only the real user turn — the prContext prefix
+    // is internal routing and should not render as a user message.
+    expect(client.sessionUpdate).toHaveBeenCalledTimes(1);
+    expect(client.sessionUpdate).toHaveBeenCalledWith({
+      sessionId: "session-1",
+      update: {
+        sessionUpdate: "user_message_chunk",
+        content: { type: "text", text: "ship the fix" },
+      },
+    });
+  });
+
   it("broadcasts user prompt as user_message_chunk before delegating to codex-acp", async () => {
     const { agent, client } = createAgent();
     // Seed an active session so prompt() has the state it expects.

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

@@ -93,6 +93,24 @@ function toCodexPermissionMode(mode?: string): PermissionMode {
   return "auto";
 }
 
+/**
+ * Prepend `_meta.prContext` (set by the agent-server on Slack-originated
+ * follow-up runs) to the prompt as a text block, mirroring Claude's
+ * `promptToClaude` behavior. Without this, codex cloud runs lose the
+ * PR-review context that follow-up flows rely on.
+ */
+function prependPrContext(params: PromptRequest): PromptRequest {
+  const prContext = (params._meta as Record<string, unknown> | undefined)
+    ?.prContext;
+  if (typeof prContext !== "string" || prContext.length === 0) {
+    return params;
+  }
+  return {
+    ...params,
+    prompt: [{ type: "text", text: prContext }, ...params.prompt],
+  };
+}
+
 const CODEX_NATIVE_MODE: Record<CodeExecutionMode, CodexNativeMode> = {
   default: "auto",
   acceptEdits: "auto",
@@ -249,13 +267,27 @@ export class CodexAcpAgent extends BaseAcpAgent {
       meta?.permissionMode,
     );
 
+    // Carry taskRunId/taskId across load so prompt() still emits cloud
+    // notifications (TURN_COMPLETE, USAGE_UPDATE) after a reload. newSession
+    // and unstable_resumeSession both do this; loadSession historically did
+    // not, which silently broke task-completion tracking on re-attach.
     this.sessionState = createSessionState(params.sessionId, params.cwd, {
+      taskRunId: meta?.taskRunId,
+      taskId: meta?.taskId ?? meta?.persistence?.taskId,
       modeId: response.modes?.currentModeId ?? "auto",
       permissionMode: currentPermissionMode,
     });
     this.sessionId = params.sessionId;
     this.sessionState.configOptions = response.configOptions ?? [];
 
+    if (meta?.taskRunId) {
+      await this.client.extNotification(POSTHOG_NOTIFICATIONS.SDK_SESSION, {
+        taskRunId: meta.taskRunId,
+        sessionId: params.sessionId,
+        adapter: "codex",
+      });
+    }
+
     return response;
   }
 
@@ -373,9 +405,13 @@ export class CodexAcpAgent extends BaseAcpAgent {
     // channel, so without this broadcast the tapped stream (persisted to S3
     // and rendered by the PostHog web UI) never sees a user turn and only
     // the assistant reply shows up. Mirrors ClaudeAcpAgent.broadcastUserMessage.
+    // The original params (no _meta.prContext prefix) is broadcast so the
+    // injected PR context is not rendered as a user message.
     await this.broadcastUserMessage(params);
 
-    const response = await this.codexConnection.prompt(params);
+    const response = await this.codexConnection.prompt(
+      prependPrContext(params),
+    );
 
     // Usage is already accumulated via sessionUpdate notifications in
     // codex-client.ts. Do NOT also add response.usage here or tokens