fix(cloud-task): resume a terminal cloud run with the selected question answer

When a terminal cloud run has a pending AskUserQuestion request, clicking the recovered card cannot proxy a permission_response to the dead sandbox. Route selected question answers through the terminal resume path as the next user message, refresh stale run status before responding, and recover pending question cards from persisted session logs after app restart.

Keep resumed single-answer prompts user-facing by sending only the selected answer, while still dropping plain approvals on dead runs instead of spinning a pointless resume.

Generated-By: PostHog Code

Author: tatoalo

packages/core/src/sessions/derivePendingPermissionRequests.test.ts

@@ -6,6 +6,30 @@ import {
 } from "./sessionService";
 
 describe("derivePendingPermissionRequests", () => {
+  const sdkSession = (taskRunId: string): StoredLogEntry => ({
+    type: "notification",
+    notification: {
+      method: "_posthog/sdk_session",
+      params: { taskRunId, sessionId: "session-1", adapter: "claude" },
+    },
+  });
+  const runStarted = (taskRunId: string): StoredLogEntry => ({
+    type: "notification",
+    notification: {
+      method: "_posthog/run_started",
+      params: { runId: taskRunId, taskId: "task-1" },
+    },
+  });
+  const prompt = (content: string): StoredLogEntry => ({
+    type: "notification",
+    notification: {
+      method: "session/prompt",
+      params: {
+        sessionId: "session-1",
+        prompt: [{ type: "text", text: content }],
+      },
+    },
+  });
   const request = (requestId: string, toolCallId: string): StoredLogEntry => ({
     type: "notification",
     notification: {
@@ -65,6 +89,33 @@ describe("derivePendingPermissionRequests", () => {
 
     expect(pending).toEqual([]);
   });
+
+  it("ignores predecessor-run questions when deriving pending requests for a resumed run", () => {
+    const pending = derivePendingPermissionRequests(
+      [
+        sdkSession("run-before"),
+        runStarted("run-before"),
+        request("r1", "t1"),
+        sdkSession("run-after"),
+        runStarted("run-after"),
+        prompt(
+          "This is the user's selected answer to the AskUserQuestion prompt that was pending before this cloud run resumed.",
+        ),
+      ],
+      { taskRunId: "run-after" },
+    );
+
+    expect(pending).toEqual([]);
+  });
+
+  it("keeps current-run questions when scoped derivation matches the run", () => {
+    const pending = derivePendingPermissionRequests(
+      [sdkSession("run-1"), runStarted("run-1"), request("r1", "t1")],
+      { taskRunId: "run-1" },
+    );
+
+    expect(pending.map((p) => p.requestId)).toEqual(["r1"]);
+  });
 });
 
 describe("isPermissionRequestAlreadySurfaced", () => {

packages/core/src/sessions/permissionResponse.test.ts

@@ -1,6 +1,7 @@
 import type { PermissionRequest } from "@posthog/shared";
 import { describe, expect, it } from "vitest";
 import {
+  formatPermissionAnswerPrompt,
   isOtherPermissionOption,
   planPermissionResponse,
 } from "./permissionResponse";
@@ -78,3 +79,71 @@ describe("planPermissionResponse", () => {
     expect(plan.resendPromptText).toBeNull();
   });
 });
+
+describe("formatPermissionAnswerPrompt", () => {
+  const questionPermission = (questions: Array<{ question: string }>) =>
+    ({
+      taskRunId: "run-1",
+      receivedAt: 0,
+      toolCall: {
+        toolCallId: "tool-1",
+        _meta: { codeToolKind: "question", questions },
+      },
+      options: [
+        { optionId: "option_0", name: "MIT", kind: "allow_once" },
+        { optionId: "option_1", name: "Apache 2.0", kind: "allow_once" },
+      ],
+    }) as unknown as PermissionRequest;
+
+  it("quotes each question above its answer", () => {
+    const prompt = formatPermissionAnswerPrompt(
+      questionPermission([{ question: "Which license should I use?" }]),
+      "option_0",
+      undefined,
+      { "Which license should I use?": "MIT" },
+    );
+    expect(prompt).toBe("MIT");
+  });
+
+  it("carries every entry of a multi-question answers map", () => {
+    const prompt = formatPermissionAnswerPrompt(
+      questionPermission([{ question: "Q1?" }, { question: "Q2?" }]),
+      "option_0",
+      undefined,
+      { "Q1?": "A1", "Q2?": "A2" },
+    );
+    expect(prompt).toBe("1. A1\n2. A2");
+  });
+
+  it("falls back to the picked option label when no answers map is sent", () => {
+    const prompt = formatPermissionAnswerPrompt(
+      questionPermission([{ question: "Which license should I use?" }]),
+      "option_1",
+    );
+    expect(prompt).toBe("Apache 2.0");
+  });
+
+  it("uses free-text custom input for a question", () => {
+    const prompt = formatPermissionAnswerPrompt(
+      questionPermission([{ question: "Which license should I use?" }]),
+      "_other",
+      "BSD, actually",
+    );
+    expect(prompt).toBe("BSD, actually");
+  });
+
+  it.each([
+    ["plain approval", "allow", undefined],
+    ["plain rejection with feedback", "reject", "not like this"],
+  ])(
+    "returns null for %s so no resume run is spun",
+    (_caseName, optionId, customInput) => {
+      const approval = makePermission([
+        { optionId: "allow", kind: "allow_once" },
+      ]);
+      expect(
+        formatPermissionAnswerPrompt(approval, optionId, customInput),
+      ).toBeNull();
+    },
+  );
+});

packages/core/src/sessions/permissionResponse.ts

@@ -52,3 +52,76 @@ export function planPermissionResponse(
     resendPromptText: null,
   };
 }
+
+interface QuestionMeta {
+  codeToolKind?: unknown;
+  questions?: unknown;
+}
+
+function questionMeta(
+  permission: PermissionRequest | undefined,
+): QuestionMeta | null {
+  const meta = permission?.toolCall?._meta;
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+    return null;
+  }
+  return meta as QuestionMeta;
+}
+
+export function isQuestionPermission(
+  permission: PermissionRequest | undefined,
+): boolean {
+  return questionMeta(permission)?.codeToolKind === "question";
+}
+
+/**
+ * Builds the follow-up prompt that carries a question's selected answer into a
+ * resumed run. Once a cloud run has terminalized, its sandbox and the pending
+ * permission promise inside it are gone, so a permission_response command has
+ * nothing left to resolve. The answer travels as a fresh user message on a
+ * resume run instead.
+ * Returns null when there is nothing meaningful to carry forward (a plain
+ * approval), so callers can drop the response rather than spin a pointless run.
+ */
+export function formatPermissionAnswerPrompt(
+  permission: PermissionRequest | undefined,
+  optionId: string,
+  customInput?: string,
+  answers?: Record<string, string>,
+): string | null {
+  const selectedAnswers: string[] = [];
+  for (const [question, answer] of Object.entries(answers ?? {})) {
+    if (question.trim() && answer.trim()) {
+      selectedAnswers.push(answer.trim());
+    }
+  }
+
+  if (selectedAnswers.length === 0) {
+    if (!isQuestionPermission(permission)) {
+      return null;
+    }
+    // A question answered without an answers map: free text, or a bare option pick.
+    const answerText =
+      customInput?.trim() ||
+      permission?.options
+        .find((option) => option.optionId === optionId)
+        ?.name?.trim();
+    if (!answerText) {
+      return null;
+    }
+    selectedAnswers.push(answerText);
+  } else {
+    const extraInput = customInput?.trim();
+    if (extraInput && !selectedAnswers.includes(extraInput)) {
+      selectedAnswers.push(extraInput);
+    }
+  }
+
+  if (selectedAnswers.length === 1) {
+    return selectedAnswers[0] ?? null;
+  }
+
+  return selectedAnswers
+    .map((answer, index) => `${index + 1}. ${answer}`)
+    .join("\n");
+}