From a21e6293c0bc9ab26c9fc55a3aa464795d02cf43 Mon Sep 17 00:00:00 2001
From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Sat, 1 Aug 2026 14:07:46 +0000
Subject: [PATCH 1/5] feat: add desktop channel question cards

Signed-off-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-Authored-By: Oscar Le <oscar.lehuu@gmail.com>
---
 desktop/src-tauri/src/commands/mod.rs         |   2 +
 desktop/src-tauri/src/commands/user_input.rs  |  28 +++
 desktop/src-tauri/src/lib.rs                  |   1 +
 .../channels/hooks/useChannelUserInput.ts     | 145 ++++++++++++
 .../features/channels/lib/userInput.test.mjs  |  99 ++++++++
 .../src/features/channels/lib/userInput.ts    | 124 ++++++++++
 .../src/features/channels/ui/ChannelPane.tsx  |  13 ++
 .../channels/ui/ChannelUserInputCard.tsx      | 221 ++++++++++++++++++
 .../channels/ui/ChannelUserInputStack.tsx     |  47 ++++
 desktop/src/shared/api/relayChannelFilters.ts |  16 ++
 desktop/src/shared/api/tauriUserInput.ts      |  13 ++
 desktop/src/shared/constants/kinds.ts         |   2 +
 desktop/src/testing/e2eBridge.ts              |  34 +++
 desktop/tests/e2e/channels.spec.ts            |  82 +++++++
 14 files changed, 827 insertions(+)
 create mode 100644 desktop/src-tauri/src/commands/user_input.rs
 create mode 100644 desktop/src/features/channels/hooks/useChannelUserInput.ts
 create mode 100644 desktop/src/features/channels/lib/userInput.test.mjs
 create mode 100644 desktop/src/features/channels/lib/userInput.ts
 create mode 100644 desktop/src/features/channels/ui/ChannelUserInputCard.tsx
 create mode 100644 desktop/src/features/channels/ui/ChannelUserInputStack.tsx
 create mode 100644 desktop/src/shared/api/tauriUserInput.ts

diff --git a/desktop/src-tauri/src/commands/mod.rs b/desktop/src-tauri/src/commands/mod.rs
index d9c766b26c5..cb7296aadff 100644
--- a/desktop/src-tauri/src/commands/mod.rs
+++ b/desktop/src-tauri/src/commands/mod.rs
@@ -61,6 +61,7 @@ mod thread_workspace_git;
 #[cfg(test)]
 mod thread_workspace_tests;
 mod updater;
+mod user_input;
 mod window_chrome;
 mod window_vibrancy;
 mod workflows;
@@ -114,6 +115,7 @@ pub use teams::*;
 pub use thread_github::*;
 pub use thread_workspace::*;
 pub use updater::*;
+pub use user_input::*;
 pub use window_chrome::*;
 pub use window_vibrancy::*;
 pub use workflows::*;
diff --git a/desktop/src-tauri/src/commands/user_input.rs b/desktop/src-tauri/src/commands/user_input.rs
new file mode 100644
index 00000000000..1a633007569
--- /dev/null
+++ b/desktop/src-tauri/src/commands/user_input.rs
@@ -0,0 +1,28 @@
+use tauri::State;
+
+use crate::{
+    app_state::AppState,
+    relay::{submit_event, SubmitEventResponse},
+};
+
+/// Publish an owner-authored answer to a durable agent question.
+#[tauri::command]
+pub async fn send_channel_user_input_answer(
+    channel_id: String,
+    request_event_id: String,
+    answers: serde_json::Value,
+    state: State<'_, AppState>,
+) -> Result<SubmitEventResponse, String> {
+    let channel_uuid = uuid::Uuid::parse_str(&channel_id)
+        .map_err(|_| format!("invalid channel UUID: {channel_id}"))?;
+    if !answers.is_object() {
+        return Err("answers must be a JSON object".to_string());
+    }
+    let builder = buzz_sdk_pkg::build_agent_user_input_answer(
+        channel_uuid,
+        &request_event_id,
+        &answers.to_string(),
+    )
+    .map_err(|error| error.to_string())?;
+    submit_event(builder, &state).await
+}
diff --git a/desktop/src-tauri/src/lib.rs b/desktop/src-tauri/src/lib.rs
index 6ad9f30e175..5f456b55d3b 100644
--- a/desktop/src-tauri/src/lib.rs
+++ b/desktop/src-tauri/src/lib.rs
@@ -724,6 +724,7 @@ pub fn run() {
             get_feed,
             search_messages,
             send_channel_message,
+            send_channel_user_input_answer,
             send_managed_agent_channel_message,
             has_managed_agent_channel_message_marker,
             get_forum_posts,
diff --git a/desktop/src/features/channels/hooks/useChannelUserInput.ts b/desktop/src/features/channels/hooks/useChannelUserInput.ts
new file mode 100644
index 00000000000..7457c654a8f
--- /dev/null
+++ b/desktop/src/features/channels/hooks/useChannelUserInput.ts
@@ -0,0 +1,145 @@
+import * as React from "react";
+import { useIdentityQuery } from "@/shared/api/hooks";
+import { relayClient } from "@/shared/api/relayClient";
+import { buildChannelUserInputFilter } from "@/shared/api/relayChannelFilters";
+import type { RelayEvent } from "@/shared/api/types";
+import { sendChannelUserInputAnswer } from "@/shared/api/tauriUserInput";
+import {
+  buildSkippedAnswers,
+  buildUserInputAnswers,
+  derivePendingUserInputs,
+  type UserInputAnswers,
+  type UserInputEvent,
+} from "@/features/channels/lib/userInput";
+
+const RETAINED_EVENTS = 200;
+
+export function useChannelUserInput(channelId: string | null) {
+  const identityQuery = useIdentityQuery();
+  const currentPubkey = identityQuery.data?.pubkey ?? "";
+  const [events, setEvents] = React.useState<RelayEvent[]>([]);
+  const [optimisticallyResolved, setOptimisticallyResolved] = React.useState(
+    () => new Set<string>(),
+  );
+  const [sendingRequestId, setSendingRequestId] = React.useState<string | null>(
+    null,
+  );
+  const [sentRequestIds, setSentRequestIds] = React.useState(
+    () => new Set<string>(),
+  );
+
+  React.useEffect(() => {
+    setEvents([]);
+    setOptimisticallyResolved(new Set());
+    setSentRequestIds(new Set());
+    if (!channelId) return;
+
+    let cancelled = false;
+    const filter = buildChannelUserInputFilter(channelId, RETAINED_EVENTS);
+    const onEvent = (event: RelayEvent) => {
+      if (cancelled) return;
+      setEvents((current) => {
+        if (current.some((existing) => existing.id === event.id))
+          return current;
+        return [event, ...current].slice(0, RETAINED_EVENTS);
+      });
+    };
+
+    const load = async () => {
+      try {
+        const dispose = await relayClient.subscribeLive(filter, onEvent);
+        if (cancelled) {
+          await dispose();
+          return;
+        }
+        const history = await relayClient.fetchEvents(filter);
+        if (!cancelled) {
+          setEvents((current) => {
+            const byId = new Map(current.map((event) => [event.id, event]));
+            for (const event of history) byId.set(event.id, event);
+            return [...byId.values()]
+              .sort((left, right) => right.created_at - left.created_at)
+              .slice(0, RETAINED_EVENTS);
+          });
+        }
+        return dispose;
+      } catch (error) {
+        console.error("Failed to load agent questions", error);
+      }
+    };
+
+    let dispose: (() => Promise<void>) | undefined;
+    void load().then((cleanup) => {
+      dispose = cleanup;
+      if (cancelled) void cleanup?.();
+    });
+    return () => {
+      cancelled = true;
+      void dispose?.();
+    };
+  }, [channelId]);
+
+  const pending = React.useMemo(
+    () =>
+      derivePendingUserInputs(events, currentPubkey, optimisticallyResolved),
+    [currentPubkey, events, optimisticallyResolved],
+  );
+  const sent = React.useMemo(() => {
+    const active = new Set(
+      derivePendingUserInputs(events, currentPubkey).map(
+        ({ event }) => event.id,
+      ),
+    );
+    return derivePendingUserInputs(events, currentPubkey, new Set())
+      .filter(
+        ({ event }) => sentRequestIds.has(event.id) && active.has(event.id),
+      )
+      .map((request) => request);
+  }, [currentPubkey, events, sentRequestIds]);
+
+  const answer = React.useCallback(
+    async (request: UserInputEvent, answers: UserInputAnswers) => {
+      setSendingRequestId(request.event.id);
+      try {
+        await sendChannelUserInputAnswer(
+          channelId ?? request.request.channel_id,
+          request.event.id,
+          buildUserInputAnswers(answers),
+        );
+        setOptimisticallyResolved((current) => {
+          const next = new Set(current);
+          next.add(request.event.id);
+          return next;
+        });
+        setSentRequestIds((current) => {
+          const next = new Set(current);
+          next.add(request.event.id);
+          return next;
+        });
+      } finally {
+        setSendingRequestId(null);
+      }
+    },
+    [channelId],
+  );
+
+  const skip = React.useCallback(
+    (request: UserInputEvent) =>
+      answer(
+        request,
+        buildSkippedAnswers(request.request.questions.map((q) => q.id)),
+      ),
+    [answer],
+  );
+
+  return {
+    pending,
+    sent,
+    currentPubkey,
+    sendingRequestId,
+    sentRequestIds,
+    answer,
+    skip,
+    isLoading: Boolean(channelId) && identityQuery.isLoading,
+  };
+}
diff --git a/desktop/src/features/channels/lib/userInput.test.mjs b/desktop/src/features/channels/lib/userInput.test.mjs
new file mode 100644
index 00000000000..3044d92f24d
--- /dev/null
+++ b/desktop/src/features/channels/lib/userInput.test.mjs
@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  buildSkippedAnswers,
+  buildUserInputAnswers,
+  derivePendingUserInputs,
+} from "./userInput.ts";
+
+const request = (id, created_at = 10) => ({
+  id,
+  pubkey: "agent",
+  created_at,
+  kind: 46040,
+  tags: [],
+  content: JSON.stringify({
+    request_id: id,
+    session_id: "session",
+    turn_id: "turn",
+    channel_id: "channel",
+    engine: "claude",
+    message: "Choose",
+    questions: [
+      {
+        id: "q0",
+        header: "Environment",
+        question: "Where?",
+        options: [],
+      },
+    ],
+  }),
+  sig: "",
+});
+
+const answer = (id, pubkey = "owner") => ({
+  id: `answer-${id}-${pubkey}`,
+  pubkey,
+  created_at: 20,
+  kind: 46041,
+  tags: [
+    ["h", "channel"],
+    ["e", id],
+  ],
+  content: JSON.stringify({ q0: "production" }),
+  sig: "",
+});
+
+test("accepted answer resolves request", () => {
+  assert.equal(
+    derivePendingUserInputs(
+      [request("request-1"), answer("request-1")],
+      "owner",
+    ).length,
+    0,
+  );
+});
+
+test("foreign-author answer does not resolve request", () => {
+  assert.equal(
+    derivePendingUserInputs(
+      [request("request-1"), answer("request-1", "stranger")],
+      "owner",
+    ).length,
+    1,
+  );
+});
+
+test("duplicate events are deduplicated", () => {
+  assert.equal(
+    derivePendingUserInputs(
+      [request("request-1"), request("request-1")],
+      "owner",
+    ).length,
+    1,
+  );
+});
+
+test("optimistic resolution hides the card", () => {
+  assert.equal(
+    derivePendingUserInputs(
+      [request("request-1")],
+      "owner",
+      new Set(["request-1"]),
+    ).length,
+    0,
+  );
+});
+
+test("answer payloads preserve all wire shapes", () => {
+  assert.equal(
+    buildUserInputAnswers({
+      q0: "production",
+      q1: ["lint", "tests"],
+      q2: { selected: "yes", choice_notes: { yes: "because" } },
+      q3: null,
+    }),
+    '{"q0":"production","q1":["lint","tests"],"q2":{"selected":"yes","choice_notes":{"yes":"because"}},"q3":null}',
+  );
+  assert.deepEqual(buildSkippedAnswers(["q0", "q1"]), { q0: null, q1: null });
+});
diff --git a/desktop/src/features/channels/lib/userInput.ts b/desktop/src/features/channels/lib/userInput.ts
new file mode 100644
index 00000000000..8f0b8e05d5c
--- /dev/null
+++ b/desktop/src/features/channels/lib/userInput.ts
@@ -0,0 +1,124 @@
+import {
+  KIND_AGENT_USER_INPUT_ANSWER,
+  KIND_AGENT_USER_INPUT_REQUESTED,
+} from "@/shared/constants/kinds";
+import type { RelayEvent } from "@/shared/api/types";
+
+export type UserInputOption = {
+  value: string;
+  label: string;
+  description: string;
+};
+
+export type UserInputQuestion = {
+  id: string;
+  header: string;
+  question: string;
+  options: UserInputOption[];
+  multi_select?: boolean;
+  allow_custom_answer?: boolean;
+  allow_notes?: boolean;
+};
+
+export type UserInputRequest = {
+  request_id: string;
+  session_id: string;
+  turn_id: string;
+  channel_id: string;
+  tool_call_id?: string | null;
+  engine: "claude" | "codex" | string;
+  message?: string | null;
+  questions: UserInputQuestion[];
+};
+
+export type UserInputEvent = {
+  event: RelayEvent;
+  request: UserInputRequest;
+};
+
+export type UserInputAnswerValue =
+  | string
+  | string[]
+  | { selected: string | string[]; choice_notes?: Record<string, string> }
+  | null;
+
+export type UserInputAnswers = Record<string, UserInputAnswerValue>;
+
+export function parseUserInputRequest(
+  event: RelayEvent,
+): UserInputRequest | null {
+  if (event.kind !== KIND_AGENT_USER_INPUT_REQUESTED) return null;
+  try {
+    const value = JSON.parse(event.content) as UserInputRequest;
+    if (
+      !value ||
+      typeof value !== "object" ||
+      typeof value.request_id !== "string" ||
+      !Array.isArray(value.questions)
+    ) {
+      return null;
+    }
+    return value;
+  } catch {
+    return null;
+  }
+}
+
+export function getAnswerRequestId(event: RelayEvent): string | null {
+  if (event.kind !== KIND_AGENT_USER_INPUT_ANSWER) return null;
+  const tag = event.tags.find(([name]) => name === "e");
+  return tag?.[1] ?? null;
+}
+
+export function dedupeUserInputEvents(
+  events: RelayEvent[],
+  limit = 200,
+): RelayEvent[] {
+  const byId = new Map<string, RelayEvent>();
+  for (const event of events) {
+    if (!byId.has(event.id)) byId.set(event.id, event);
+  }
+  return [...byId.values()]
+    .sort((left, right) => right.created_at - left.created_at)
+    .slice(0, limit);
+}
+
+export function derivePendingUserInputs(
+  events: RelayEvent[],
+  currentPubkey: string,
+  optimisticallyResolvedIds: ReadonlySet<string> = new Set(),
+): UserInputEvent[] {
+  const deduped = dedupeUserInputEvents(events);
+  const answered = new Set(
+    deduped
+      .filter(
+        (event) =>
+          event.kind === KIND_AGENT_USER_INPUT_ANSWER &&
+          event.pubkey === currentPubkey,
+      )
+      .map(getAnswerRequestId)
+      .filter((id): id is string => id !== null),
+  );
+  return deduped
+    .filter((event) => event.kind === KIND_AGENT_USER_INPUT_REQUESTED)
+    .map((event) => {
+      const request = parseUserInputRequest(event);
+      return request ? { event, request } : null;
+    })
+    .filter((item): item is UserInputEvent => item !== null)
+    .filter(
+      ({ event }) =>
+        !answered.has(event.id) && !optimisticallyResolvedIds.has(event.id),
+    )
+    .sort((left, right) => right.event.created_at - left.event.created_at);
+}
+
+export function buildUserInputAnswers(
+  values: Record<string, UserInputAnswerValue>,
+): string {
+  return JSON.stringify(values);
+}
+
+export function buildSkippedAnswers(questionIds: string[]): UserInputAnswers {
+  return Object.fromEntries(questionIds.map((id) => [id, null]));
+}
diff --git a/desktop/src/features/channels/ui/ChannelPane.tsx b/desktop/src/features/channels/ui/ChannelPane.tsx
index 13f0acd0c0a..ed78fc9fe71 100644
--- a/desktop/src/features/channels/ui/ChannelPane.tsx
+++ b/desktop/src/features/channels/ui/ChannelPane.tsx
@@ -38,6 +38,8 @@ import { useFocusDrawerPresence } from "@/features/channels/ui/useFocusDrawerPre
 import { useChannelWorkingAgentPubkeys } from "@/features/agents/agentWorkingSignal";
 import { BotActivityComposerAction } from "@/features/channels/ui/BotActivityBar";
 import { ChannelComposerActivityAccessory } from "@/features/channels/ui/ChannelComposerActivityAccessory";
+import { ChannelUserInputStack } from "@/features/channels/ui/ChannelUserInputStack";
+import { useChannelUserInput } from "@/features/channels/hooks/useChannelUserInput";
 import { useThreadComposerBotActivity } from "@/features/channels/ui/useThreadComposerBotActivity";
 import {
   containsWelcomePersonaMention,
@@ -182,6 +184,7 @@ export const ChannelPane = React.memo(function ChannelPane({
     !activeChannel.archivedAt;
   const hasMainComposerOverlay = !isNonMemberView;
   const activeChannelId = activeChannel?.id ?? null;
+  const userInput = useChannelUserInput(activeChannelId);
   const activeChannelIdRef = React.useRef(activeChannelId);
   const channelPaneMountedRef = React.useRef(false);
   activeChannelIdRef.current = activeChannelId;
@@ -740,6 +743,16 @@ export const ChannelPane = React.memo(function ChannelPane({
                   </div>
                 ) : null}
                 <ComposerDockBackdrop gutterClassName="inset-x-5" />
+                {userInput.pending.length > 0 || userInput.sent.length > 0 ? (
+                  <ChannelUserInputStack
+                    currentPubkey={currentPubkey ?? ""}
+                    pending={userInput.pending}
+                    profiles={profiles}
+                    sent={userInput.sent}
+                    onSkip={userInput.skip}
+                    onSubmit={userInput.answer}
+                  />
+                ) : null}
                 <MessageComposer
                   channelId={activeChannel?.id ?? null}
                   channelName={activeChannel?.name ?? "channel"}
diff --git a/desktop/src/features/channels/ui/ChannelUserInputCard.tsx b/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
new file mode 100644
index 00000000000..71f0e65f2b5
--- /dev/null
+++ b/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
@@ -0,0 +1,221 @@
+import * as React from "react";
+import { Button } from "@/shared/ui/button";
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+} from "@/shared/ui/card";
+import { Textarea } from "@/shared/ui/textarea";
+import { cn } from "@/shared/lib/cn";
+import type {
+  UserInputAnswerValue,
+  UserInputEvent,
+} from "@/features/channels/lib/userInput";
+
+type Props = {
+  item: UserInputEvent;
+  currentPubkey: string;
+  profiles?: Record<string, { ownerPubkey: string | null }>;
+  sent?: boolean;
+  onSubmit: (
+    item: UserInputEvent,
+    answers: Record<string, UserInputAnswerValue>,
+  ) => Promise<void>;
+  onSkip: (item: UserInputEvent) => Promise<void>;
+};
+
+type QuestionState = {
+  selected: string[];
+  custom: string;
+  notes: Record<string, string>;
+};
+
+export function ChannelUserInputCard({
+  item,
+  currentPubkey,
+  profiles,
+  sent = false,
+  onSubmit,
+  onSkip,
+}: Props) {
+  const [state, setState] = React.useState<Record<string, QuestionState>>({});
+  const ownerPubkey = profiles?.[item.event.pubkey]?.ownerPubkey ?? null;
+  const readOnly = ownerPubkey !== null && ownerPubkey !== currentPubkey;
+  const hasAnswer = item.request.questions.every((question) => {
+    const value = state[question.id];
+    return Boolean(value?.custom.trim() || value?.selected.length);
+  });
+
+  const update = (id: string, patch: Partial<QuestionState>) => {
+    setState((current) => ({
+      ...current,
+      [id]: {
+        ...(current[id] ?? { selected: [], custom: "", notes: {} }),
+        ...patch,
+      },
+    }));
+  };
+
+  const submit = async () => {
+    const answers: Record<string, UserInputAnswerValue> = {};
+    for (const question of item.request.questions) {
+      const value = state[question.id] ?? {
+        selected: [],
+        custom: "",
+        notes: {},
+      };
+      if (value.custom.trim()) {
+        answers[question.id] = value.custom.trim();
+      } else if (question.allow_notes && Object.keys(value.notes).length > 0) {
+        answers[question.id] = {
+          selected: question.multi_select ? value.selected : value.selected[0],
+          choice_notes: value.notes,
+        };
+      } else {
+        answers[question.id] = question.multi_select
+          ? value.selected
+          : value.selected[0];
+      }
+    }
+    await onSubmit(item, answers);
+  };
+
+  return (
+    <Card
+      className="max-h-[min(42vh,28rem)] overflow-y-auto border-primary/30 shadow-lg"
+      data-testid={`channel-user-input-card-${item.event.id}`}
+    >
+      <CardHeader className="pb-3">
+        <CardTitle className="text-base">
+          {sent ? "Answer sent" : "Agent question"}
+        </CardTitle>
+        {item.request.message ? (
+          <CardDescription className="whitespace-pre-wrap text-sm text-foreground/80">
+            {item.request.message}
+          </CardDescription>
+        ) : null}
+        {readOnly ? (
+          <CardDescription data-testid="channel-user-input-owner-note">
+            Only the agent&apos;s owner can answer this question.
+          </CardDescription>
+        ) : sent ? (
+          <CardDescription>Sent, waiting for the agent.</CardDescription>
+        ) : null}
+      </CardHeader>
+      {!sent ? (
+        <CardContent className="space-y-5">
+          {item.request.questions.map((question) => {
+            const value = state[question.id] ?? {
+              selected: [],
+              custom: "",
+              notes: {},
+            };
+            return (
+              <fieldset key={question.id} className="space-y-2">
+                <legend className="text-sm font-medium">
+                  <span className="text-muted-foreground">
+                    {question.header}
+                  </span>
+                  <span className="mt-1 block">{question.question}</span>
+                </legend>
+                <div className="space-y-1.5">
+                  {question.options.map((option) => {
+                    const checked = value.selected.includes(option.value);
+                    return (
+                      <label
+                        className={cn(
+                          "flex items-start gap-2 rounded-md border border-border/60 p-2 text-sm",
+                          checked && "border-primary/50 bg-primary/5",
+                        )}
+                        key={option.value}
+                      >
+                        <input
+                          aria-label={option.label}
+                          checked={checked}
+                          disabled={readOnly}
+                          name={question.id}
+                          type={question.multi_select ? "checkbox" : "radio"}
+                          onChange={() => {
+                            const selected = question.multi_select
+                              ? checked
+                                ? value.selected.filter(
+                                    (v) => v !== option.value,
+                                  )
+                                : [...value.selected, option.value]
+                              : [option.value];
+                            update(question.id, { selected });
+                          }}
+                        />
+                        <span>
+                          <span className="block">{option.label}</span>
+                          {option.description ? (
+                            <span className="block text-xs text-muted-foreground">
+                              {option.description}
+                            </span>
+                          ) : null}
+                        </span>
+                      </label>
+                    );
+                  })}
+                </div>
+                {question.allow_custom_answer ? (
+                  <Textarea
+                    aria-label={`${question.header} custom answer`}
+                    disabled={readOnly}
+                    placeholder="Your answer"
+                    value={value.custom}
+                    onChange={(event) =>
+                      update(question.id, {
+                        custom: event.target.value,
+                        selected: [],
+                      })
+                    }
+                  />
+                ) : null}
+                {question.allow_notes && value.selected.length > 0 ? (
+                  <Textarea
+                    aria-label={`${question.header} notes`}
+                    disabled={readOnly}
+                    placeholder="Notes (optional)"
+                    value={Object.values(value.notes)[0] ?? ""}
+                    onChange={(event) =>
+                      update(question.id, {
+                        notes: {
+                          [value.selected[0]]: event.target.value,
+                        },
+                      })
+                    }
+                  />
+                ) : null}
+              </fieldset>
+            );
+          })}
+        </CardContent>
+      ) : null}
+      {!sent ? (
+        <CardFooter className="gap-2">
+          <Button
+            data-testid="channel-user-input-skip"
+            disabled={readOnly}
+            type="button"
+            variant="ghost"
+            onClick={() => void onSkip(item)}
+          >
+            Skip
+          </Button>
+          <Button
+            data-testid="channel-user-input-submit"
+            disabled={readOnly || !hasAnswer}
+            type="button"
+            onClick={() => void submit()}
+          >
+            Submit
+          </Button>
+        </CardFooter>
+      ) : null}
+    </Card>
+  );
+}
diff --git a/desktop/src/features/channels/ui/ChannelUserInputStack.tsx b/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
new file mode 100644
index 00000000000..24829b14651
--- /dev/null
+++ b/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
@@ -0,0 +1,47 @@
+import * as React from "react";
+import { ChannelUserInputCard } from "@/features/channels/ui/ChannelUserInputCard";
+import type {
+  UserInputAnswers,
+  UserInputEvent,
+} from "@/features/channels/lib/userInput";
+
+type Props = {
+  pending: UserInputEvent[];
+  sent: UserInputEvent[];
+  currentPubkey: string;
+  profiles?: Record<string, { ownerPubkey: string | null }>;
+  onSkip: (item: UserInputEvent) => Promise<void>;
+  onSubmit: (item: UserInputEvent, answers: UserInputAnswers) => Promise<void>;
+};
+
+export function ChannelUserInputStack({
+  pending,
+  sent,
+  currentPubkey,
+  profiles,
+  onSkip,
+  onSubmit,
+}: Props) {
+  const sentIds = React.useMemo(
+    () => new Set(sent.map(({ event }) => event.id)),
+    [sent],
+  );
+  return (
+    <div
+      className="pointer-events-auto mx-5 mb-2 max-h-[min(48vh,34rem)] space-y-2 overflow-y-auto"
+      data-testid="channel-user-input-stack"
+    >
+      {[...sent, ...pending].map((item) => (
+        <ChannelUserInputCard
+          currentPubkey={currentPubkey}
+          item={item}
+          key={item.event.id}
+          profiles={profiles}
+          sent={sentIds.has(item.event.id)}
+          onSkip={onSkip}
+          onSubmit={onSubmit}
+        />
+      ))}
+    </div>
+  );
+}
diff --git a/desktop/src/shared/api/relayChannelFilters.ts b/desktop/src/shared/api/relayChannelFilters.ts
index 0d432d422e1..35a2b7fae6d 100644
--- a/desktop/src/shared/api/relayChannelFilters.ts
+++ b/desktop/src/shared/api/relayChannelFilters.ts
@@ -4,6 +4,8 @@ import {
   CHANNEL_TIMELINE_CONTENT_KINDS,
   HOME_MENTION_EVENT_KINDS,
   KIND_DELETION,
+  KIND_AGENT_USER_INPUT_ANSWER,
+  KIND_AGENT_USER_INPUT_REQUESTED,
   KIND_NIP29_DELETE_EVENT,
   KIND_REACTION,
   KIND_STREAM_MESSAGE,
@@ -19,6 +21,20 @@ import type { RelaySubscriptionFilter } from "@/shared/api/relayClientShared";
 export const AUX_BACKFILL_CHUNK_SIZE = 100;
 export const MAX_HISTORICAL_LIMIT = 10_000;
 
+export function buildChannelUserInputFilter(
+  channelId: string,
+  limit = 200,
+  since?: number,
+): RelaySubscriptionFilter {
+  const filter: RelaySubscriptionFilter = {
+    kinds: [KIND_AGENT_USER_INPUT_REQUESTED, KIND_AGENT_USER_INPUT_ANSWER],
+    "#h": [channelId],
+    limit,
+  };
+  if (since !== undefined) filter.since = since;
+  return filter;
+}
+
 /**
  * Live-subscription filter for an open channel: the broad
  * {@link CHANNEL_EVENT_KINDS} set so the tail delivers reactions/edits/
diff --git a/desktop/src/shared/api/tauriUserInput.ts b/desktop/src/shared/api/tauriUserInput.ts
new file mode 100644
index 00000000000..b54ba4e1e2d
--- /dev/null
+++ b/desktop/src/shared/api/tauriUserInput.ts
@@ -0,0 +1,13 @@
+import { invokeTauri } from "@/shared/api/tauri";
+
+export async function sendChannelUserInputAnswer(
+  channelId: string,
+  requestEventId: string,
+  answers: string,
+): Promise<{ eventId: string }> {
+  const response = await invokeTauri<{ event_id: string }>(
+    "send_channel_user_input_answer",
+    { channelId, requestEventId, answers: JSON.parse(answers) },
+  );
+  return { eventId: response.event_id };
+}
diff --git a/desktop/src/shared/constants/kinds.ts b/desktop/src/shared/constants/kinds.ts
index ef3234f4c55..ad5e418aee6 100644
--- a/desktop/src/shared/constants/kinds.ts
+++ b/desktop/src/shared/constants/kinds.ts
@@ -31,6 +31,8 @@ export const KIND_JOB_ERROR = 43006;
 export const KIND_FORUM_POST = 45001;
 export const KIND_FORUM_COMMENT = 45003;
 export const KIND_APPROVAL_REQUEST = 46010;
+export const KIND_AGENT_USER_INPUT_REQUESTED = 46040;
+export const KIND_AGENT_USER_INPUT_ANSWER = 46041;
 export const KIND_MEMBER_ADDED_NOTIFICATION = 44100;
 export const KIND_MEMBER_REMOVED_NOTIFICATION = 44101;
 export const KIND_TYPING_INDICATOR = 20002;
diff --git a/desktop/src/testing/e2eBridge.ts b/desktop/src/testing/e2eBridge.ts
index b2ab8624d71..90d77cbc596 100644
--- a/desktop/src/testing/e2eBridge.ts
+++ b/desktop/src/testing/e2eBridge.ts
@@ -27,6 +27,7 @@ import {
   KIND_EMOJI_SET,
 } from "@/shared/api/customEmoji";
 import {
+  KIND_AGENT_USER_INPUT_REQUESTED,
   KIND_AGENT_OBSERVER_FRAME,
   KIND_CHANNEL_THREAD_SUMMARY,
   KIND_CHANNEL_WINDOW_BOUNDS,
@@ -1072,6 +1073,12 @@ declare global {
       /** 64-hex id required for the event to be a valid reaction target. */
       id?: string;
     }) => RelayEvent;
+    __BUZZ_E2E_EMIT_MOCK_USER_INPUT__?: (input: {
+      channelName: string;
+      requestId?: string;
+      content: string;
+      pubkey?: string;
+    }) => RelayEvent;
     /** Prepend `count` synthetic older messages to a channel's mock store so
      *  an older-history fetch has something to paginate. Mirrors how the real
      *  relay backfills history. Returns the created events. */
@@ -9682,6 +9689,27 @@ export function maybeInstallE2eTauriMocks() {
       id,
     );
   };
+  window.__BUZZ_E2E_EMIT_MOCK_USER_INPUT__ = ({
+    channelName,
+    requestId,
+    content,
+    pubkey,
+  }) => {
+    const channel = mockChannels.find(
+      (candidate) => candidate.name === channelName,
+    );
+    if (!channel) throw new Error(`Mock channel ${channelName} not found.`);
+    const event = createMockEvent(
+      KIND_AGENT_USER_INPUT_REQUESTED,
+      content,
+      [["h", channel.id]],
+      pubkey,
+      Math.floor(Date.now() / 1000),
+      requestId,
+    );
+    emitMockLiveEvent(channel.id, event);
+    return event;
+  };
   window.__BUZZ_E2E_PREPEND_MOCK_HISTORY__ = prependMockHistory;
   window.__BUZZ_E2E_EMIT_MOCK_TYPING__ = ({
     channelName,
@@ -11768,6 +11796,12 @@ export function maybeInstallE2eTauriMocks() {
           payload as Parameters<typeof handleSendChannelMessage>[0],
           activeConfig,
         );
+      case "send_channel_user_input_answer":
+        return {
+          event_id: `mock-user-input-answer-${Date.now()}`,
+          accepted: true,
+          message: "accepted",
+        };
       case "has_managed_agent_channel_message_marker": {
         const args = payload as {
           channelId: string;
diff --git a/desktop/tests/e2e/channels.spec.ts b/desktop/tests/e2e/channels.spec.ts
index 9da40224205..480d796930d 100644
--- a/desktop/tests/e2e/channels.spec.ts
+++ b/desktop/tests/e2e/channels.spec.ts
@@ -491,6 +491,88 @@ test.beforeEach(async ({ page }) => {
   await installMockBridge(page);
 });
 
+test("channel question card accepts an answer", async ({ page }) => {
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await page.waitForFunction(() =>
+    window.__BUZZ_E2E_HAS_MOCK_LIVE_SUBSCRIPTION__?.({
+      channelName: "general",
+      kind: 46040,
+    }),
+  );
+
+  await page.evaluate(() => {
+    const win = window as Window & {
+      __BUZZ_E2E_EMIT_MOCK_USER_INPUT__?: (input: {
+        channelName: string;
+        requestId?: string;
+        content: string;
+      }) => unknown;
+    };
+    win.__BUZZ_E2E_EMIT_MOCK_USER_INPUT__?.({
+      channelName: "general",
+      requestId: "a".repeat(64),
+      content: JSON.stringify({
+        request_id: "elicit-1",
+        session_id: "session-1",
+        turn_id: "turn-1",
+        channel_id: "9a1657ac-f7aa-5db0-b632-d8bbeb6dfb50",
+        engine: "claude",
+        message: "Choose an environment",
+        questions: [
+          {
+            id: "q0",
+            header: "Environment",
+            question: "Where should this run?",
+            options: [
+              {
+                value: "production",
+                label: "Production",
+                description: "The live environment",
+              },
+            ],
+          },
+        ],
+      }),
+    });
+  });
+
+  const card = page.getByTestId(
+    "channel-user-input-card-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  );
+  await expect(card).toBeVisible();
+  await card.getByRole("radio", { name: "Production" }).check();
+  await card.getByTestId("channel-user-input-submit").click();
+  await expect(card).toContainText("Sent, waiting for the agent.");
+  await expect
+    .poll(() =>
+      page.evaluate(() =>
+        (
+          window as Window & {
+            __BUZZ_E2E_COMMAND_LOG__?: Array<{
+              command: string;
+              payload: {
+                channelId?: string;
+                requestEventId?: string;
+                answers?: unknown;
+              };
+            }>;
+          }
+        ).__BUZZ_E2E_COMMAND_LOG__?.find(
+          (entry) => entry.command === "send_channel_user_input_answer",
+        ),
+      ),
+    )
+    .toMatchObject({
+      command: "send_channel_user_input_answer",
+      payload: {
+        channelId: "9a1657ac-f7aa-5db0-b632-d8bbeb6dfb50",
+        requestEventId: "a".repeat(64),
+        answers: { q0: "production" },
+      },
+    });
+});
+
 test("sidebar shows all channel types", async ({ page }) => {
   await page.goto("/");
 

From ffe9ebcabbfff3954c7d0d7eb445e83deca96a80 Mon Sep 17 00:00:00 2001
From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Sat, 1 Aug 2026 14:18:29 +0000
Subject: [PATCH 2/5] fix: harden desktop question answers

Signed-off-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-Authored-By: Oscar Le <oscar.lehuu@gmail.com>
---
 .../channels/hooks/useChannelUserInput.ts     |  38 ++---
 .../features/channels/lib/userInput.test.mjs  |  86 +++++++++++-
 .../src/features/channels/lib/userInput.ts    |  84 ++++++++++-
 .../src/features/channels/ui/ChannelPane.tsx  |   2 +
 .../channels/ui/ChannelUserInputCard.tsx      | 130 +++++++++---------
 .../channels/ui/ChannelUserInputStack.tsx     |   6 +
 desktop/src/shared/api/tauriUserInput.ts      |   5 +-
 7 files changed, 262 insertions(+), 89 deletions(-)

diff --git a/desktop/src/features/channels/hooks/useChannelUserInput.ts b/desktop/src/features/channels/hooks/useChannelUserInput.ts
index 7457c654a8f..c5f09c12ecc 100644
--- a/desktop/src/features/channels/hooks/useChannelUserInput.ts
+++ b/desktop/src/features/channels/hooks/useChannelUserInput.ts
@@ -8,6 +8,7 @@ import {
   buildSkippedAnswers,
   buildUserInputAnswers,
   derivePendingUserInputs,
+  publishUserInputAnswer,
   type UserInputAnswers,
   type UserInputEvent,
 } from "@/features/channels/lib/userInput";
@@ -27,14 +28,17 @@ export function useChannelUserInput(channelId: string | null) {
   const [sentRequestIds, setSentRequestIds] = React.useState(
     () => new Set<string>(),
   );
+  const [errors, setErrors] = React.useState<Record<string, string>>({});
 
   React.useEffect(() => {
     setEvents([]);
     setOptimisticallyResolved(new Set());
     setSentRequestIds(new Set());
+    setErrors({});
     if (!channelId) return;
 
     let cancelled = false;
+    let dispose: (() => Promise<void>) | undefined;
     const filter = buildChannelUserInputFilter(channelId, RETAINED_EVENTS);
     const onEvent = (event: RelayEvent) => {
       if (cancelled) return;
@@ -47,9 +51,10 @@ export function useChannelUserInput(channelId: string | null) {
 
     const load = async () => {
       try {
-        const dispose = await relayClient.subscribeLive(filter, onEvent);
+        dispose = await relayClient.subscribeLive(filter, onEvent);
         if (cancelled) {
           await dispose();
+          dispose = undefined;
           return;
         }
         const history = await relayClient.fetchEvents(filter);
@@ -62,17 +67,12 @@ export function useChannelUserInput(channelId: string | null) {
               .slice(0, RETAINED_EVENTS);
           });
         }
-        return dispose;
       } catch (error) {
         console.error("Failed to load agent questions", error);
       }
     };
 
-    let dispose: (() => Promise<void>) | undefined;
-    void load().then((cleanup) => {
-      dispose = cleanup;
-      if (cancelled) void cleanup?.();
-    });
+    void load();
     return () => {
       cancelled = true;
       void dispose?.();
@@ -85,27 +85,30 @@ export function useChannelUserInput(channelId: string | null) {
     [currentPubkey, events, optimisticallyResolved],
   );
   const sent = React.useMemo(() => {
-    const active = new Set(
-      derivePendingUserInputs(events, currentPubkey).map(
-        ({ event }) => event.id,
-      ),
+    return derivePendingUserInputs(events, currentPubkey).filter(({ event }) =>
+      sentRequestIds.has(event.id),
     );
-    return derivePendingUserInputs(events, currentPubkey, new Set())
-      .filter(
-        ({ event }) => sentRequestIds.has(event.id) && active.has(event.id),
-      )
-      .map((request) => request);
   }, [currentPubkey, events, sentRequestIds]);
 
   const answer = React.useCallback(
     async (request: UserInputEvent, answers: UserInputAnswers) => {
+      setErrors((current) => {
+        const next = { ...current };
+        delete next[request.event.id];
+        return next;
+      });
       setSendingRequestId(request.event.id);
       try {
-        await sendChannelUserInputAnswer(
+        const error = await publishUserInputAnswer(
+          sendChannelUserInputAnswer,
           channelId ?? request.request.channel_id,
           request.event.id,
           buildUserInputAnswers(answers),
         );
+        if (error) {
+          setErrors((current) => ({ ...current, [request.event.id]: error }));
+          return;
+        }
         setOptimisticallyResolved((current) => {
           const next = new Set(current);
           next.add(request.event.id);
@@ -138,6 +141,7 @@ export function useChannelUserInput(channelId: string | null) {
     currentPubkey,
     sendingRequestId,
     sentRequestIds,
+    errors,
     answer,
     skip,
     isLoading: Boolean(channelId) && identityQuery.isLoading,
diff --git a/desktop/src/features/channels/lib/userInput.test.mjs b/desktop/src/features/channels/lib/userInput.test.mjs
index 3044d92f24d..da213ff4d88 100644
--- a/desktop/src/features/channels/lib/userInput.test.mjs
+++ b/desktop/src/features/channels/lib/userInput.test.mjs
@@ -1,9 +1,14 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import {
+  buildQuestionAnswer,
   buildSkippedAnswers,
   buildUserInputAnswers,
   derivePendingUserInputs,
+  publishUserInputAnswer,
+  selectUserInputOption,
+  serializeUserInputAnswers,
+  setUserInputCustom,
 } from "./userInput.ts";
 
 const request = (id, created_at = 10) => ({
@@ -87,13 +92,82 @@ test("optimistic resolution hides the card", () => {
 
 test("answer payloads preserve all wire shapes", () => {
   assert.equal(
-    buildUserInputAnswers({
-      q0: "production",
-      q1: ["lint", "tests"],
-      q2: { selected: "yes", choice_notes: { yes: "because" } },
-      q3: null,
-    }),
+    serializeUserInputAnswers(
+      buildUserInputAnswers({
+        q0: "production",
+        q1: ["lint", "tests"],
+        q2: { selected: "yes", choice_notes: { yes: "because" } },
+        q3: null,
+      }),
+    ),
     '{"q0":"production","q1":["lint","tests"],"q2":{"selected":"yes","choice_notes":{"yes":"because"}},"q3":null}',
   );
   assert.deepEqual(buildSkippedAnswers(["q0", "q1"]), { q0: null, q1: null });
 });
+
+test("custom text and option selection are mutually exclusive", () => {
+  const question = {
+    id: "q0",
+    header: "Environment",
+    question: "Where?",
+    options: [{ value: "production", label: "Production", description: "" }],
+    allow_custom_answer: true,
+  };
+  const withCustom = setUserInputCustom(
+    { selected: [], custom: "", notes: {} },
+    "staging",
+  );
+  assert.deepEqual(withCustom.selected, []);
+  const withOption = selectUserInputOption(question, withCustom, "production");
+  assert.deepEqual(withOption, {
+    selected: ["production"],
+    custom: "",
+    notes: {},
+  });
+});
+
+test("publish failures return an inline-safe error and do not resolve", async () => {
+  const answers = { q0: "production" };
+  const error = await publishUserInputAnswer(
+    async () => {
+      throw new Error("relay rejected");
+    },
+    "channel",
+    "request",
+    answers,
+  );
+  assert.equal(error, "relay rejected");
+  assert.deepEqual(answers, { q0: "production" });
+});
+
+test("multi-select notes are keyed and pruned by selected option", () => {
+  const question = {
+    id: "q0",
+    header: "Checks",
+    question: "Which?",
+    options: [
+      { value: "lint", label: "Lint", description: "" },
+      { value: "tests", label: "Tests", description: "" },
+    ],
+    multi_select: true,
+    allow_notes: true,
+  };
+  let draft = selectUserInputOption(
+    question,
+    { selected: [], custom: "", notes: {} },
+    "lint",
+  );
+  draft = { ...draft, notes: { lint: "fast", tests: "old" } };
+  draft = selectUserInputOption(question, draft, "tests");
+  assert.deepEqual(draft, {
+    selected: ["lint", "tests"],
+    custom: "",
+    notes: { lint: "fast", tests: "old" },
+  });
+  draft = selectUserInputOption(question, draft, "lint");
+  assert.deepEqual(draft.notes, { tests: "old" });
+  assert.deepEqual(buildQuestionAnswer(question, draft), {
+    selected: ["tests"],
+    choice_notes: { tests: "old" },
+  });
+});
diff --git a/desktop/src/features/channels/lib/userInput.ts b/desktop/src/features/channels/lib/userInput.ts
index 8f0b8e05d5c..eb7dce0eda4 100644
--- a/desktop/src/features/channels/lib/userInput.ts
+++ b/desktop/src/features/channels/lib/userInput.ts
@@ -44,6 +44,79 @@ export type UserInputAnswerValue =
 
 export type UserInputAnswers = Record<string, UserInputAnswerValue>;
 
+export async function publishUserInputAnswer(
+  publish: (
+    channelId: string,
+    requestEventId: string,
+    answers: UserInputAnswers,
+  ) => Promise<unknown>,
+  channelId: string,
+  requestEventId: string,
+  answers: UserInputAnswers,
+): Promise<string | null> {
+  try {
+    await publish(channelId, requestEventId, answers);
+    return null;
+  } catch (error) {
+    return error instanceof Error ? error.message : "Failed to send answer.";
+  }
+}
+
+export type UserInputDraft = {
+  selected: string[];
+  custom: string;
+  notes: Record<string, string>;
+};
+
+export const emptyUserInputDraft = (): UserInputDraft => ({
+  selected: [],
+  custom: "",
+  notes: {},
+});
+
+export function selectUserInputOption(
+  question: UserInputQuestion,
+  draft: UserInputDraft,
+  value: string,
+): UserInputDraft {
+  const selected = question.multi_select
+    ? draft.selected.includes(value)
+      ? draft.selected.filter((item) => item !== value)
+      : [...draft.selected, value]
+    : [value];
+  const selectedSet = new Set(selected);
+  return {
+    selected,
+    custom: "",
+    notes: Object.fromEntries(
+      Object.entries(draft.notes).filter(([key]) => selectedSet.has(key)),
+    ),
+  };
+}
+
+export function setUserInputCustom(
+  draft: UserInputDraft,
+  custom: string,
+): UserInputDraft {
+  return custom.trim()
+    ? { selected: [], custom, notes: {} }
+    : { ...draft, custom };
+}
+
+export function buildQuestionAnswer(
+  question: UserInputQuestion,
+  draft: UserInputDraft,
+): UserInputAnswerValue {
+  if (draft.custom.trim()) return draft.custom.trim();
+  if (question.allow_notes && Object.keys(draft.notes).length > 0) {
+    return {
+      selected: question.multi_select ? draft.selected : draft.selected[0],
+      choice_notes: draft.notes,
+    };
+  }
+  return question.multi_select ? draft.selected : draft.selected[0];
+}
+
 export function parseUserInputRequest(
   event: RelayEvent,
 ): UserInputRequest | null {
@@ -114,11 +187,18 @@ export function derivePendingUserInputs(
 }
 
 export function buildUserInputAnswers(
-  values: Record<string, UserInputAnswerValue>,
-): string {
+  values: UserInputAnswers,
+): UserInputAnswers {
+  return values;
+}
+
+export function serializeUserInputAnswers(values: UserInputAnswers): string {
   return JSON.stringify(values);
 }
 
+// `null` is decoded by the harness as `None`: optional fields are omitted,
+// while a required field cancels the form. This intentionally means "answer
+// nothing", rather than dismissing the durable request locally.
 export function buildSkippedAnswers(questionIds: string[]): UserInputAnswers {
   return Object.fromEntries(questionIds.map((id) => [id, null]));
 }
diff --git a/desktop/src/features/channels/ui/ChannelPane.tsx b/desktop/src/features/channels/ui/ChannelPane.tsx
index ed78fc9fe71..483ea4b4229 100644
--- a/desktop/src/features/channels/ui/ChannelPane.tsx
+++ b/desktop/src/features/channels/ui/ChannelPane.tsx
@@ -749,6 +749,8 @@ export const ChannelPane = React.memo(function ChannelPane({
                     pending={userInput.pending}
                     profiles={profiles}
                     sent={userInput.sent}
+                    errors={userInput.errors}
+                    sendingRequestId={userInput.sendingRequestId}
                     onSkip={userInput.skip}
                     onSubmit={userInput.answer}
                   />
diff --git a/desktop/src/features/channels/ui/ChannelUserInputCard.tsx b/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
index 71f0e65f2b5..f3d1ab761ee 100644
--- a/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
+++ b/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
@@ -10,9 +10,14 @@ import {
 } from "@/shared/ui/card";
 import { Textarea } from "@/shared/ui/textarea";
 import { cn } from "@/shared/lib/cn";
-import type {
-  UserInputAnswerValue,
-  UserInputEvent,
+import {
+  buildQuestionAnswer,
+  emptyUserInputDraft,
+  selectUserInputOption,
+  setUserInputCustom,
+  type UserInputAnswerValue,
+  type UserInputDraft,
+  type UserInputEvent,
 } from "@/features/channels/lib/userInput";
 
 type Props = {
@@ -20,6 +25,8 @@ type Props = {
   currentPubkey: string;
   profiles?: Record<string, { ownerPubkey: string | null }>;
   sent?: boolean;
+  error?: string;
+  sending?: boolean;
   onSubmit: (
     item: UserInputEvent,
     answers: Record<string, UserInputAnswerValue>,
@@ -27,21 +34,17 @@ type Props = {
   onSkip: (item: UserInputEvent) => Promise<void>;
 };
 
-type QuestionState = {
-  selected: string[];
-  custom: string;
-  notes: Record<string, string>;
-};
-
 export function ChannelUserInputCard({
   item,
   currentPubkey,
   profiles,
   sent = false,
+  error,
+  sending = false,
   onSubmit,
   onSkip,
 }: Props) {
-  const [state, setState] = React.useState<Record<string, QuestionState>>({});
+  const [state, setState] = React.useState<Record<string, UserInputDraft>>({});
   const ownerPubkey = profiles?.[item.event.pubkey]?.ownerPubkey ?? null;
   const readOnly = ownerPubkey !== null && ownerPubkey !== currentPubkey;
   const hasAnswer = item.request.questions.every((question) => {
@@ -49,7 +52,7 @@ export function ChannelUserInputCard({
     return Boolean(value?.custom.trim() || value?.selected.length);
   });
 
-  const update = (id: string, patch: Partial<QuestionState>) => {
+  const update = (id: string, patch: Partial<UserInputDraft>) => {
     setState((current) => ({
       ...current,
       [id]: {
@@ -62,23 +65,10 @@ export function ChannelUserInputCard({
   const submit = async () => {
     const answers: Record<string, UserInputAnswerValue> = {};
     for (const question of item.request.questions) {
-      const value = state[question.id] ?? {
-        selected: [],
-        custom: "",
-        notes: {},
-      };
-      if (value.custom.trim()) {
-        answers[question.id] = value.custom.trim();
-      } else if (question.allow_notes && Object.keys(value.notes).length > 0) {
-        answers[question.id] = {
-          selected: question.multi_select ? value.selected : value.selected[0],
-          choice_notes: value.notes,
-        };
-      } else {
-        answers[question.id] = question.multi_select
-          ? value.selected
-          : value.selected[0];
-      }
+      answers[question.id] = buildQuestionAnswer(
+        question,
+        state[question.id] ?? emptyUserInputDraft(),
+      );
     }
     await onSubmit(item, answers);
   };
@@ -108,11 +98,7 @@ export function ChannelUserInputCard({
       {!sent ? (
         <CardContent className="space-y-5">
           {item.request.questions.map((question) => {
-            const value = state[question.id] ?? {
-              selected: [],
-              custom: "",
-              notes: {},
-            };
+            const value = state[question.id] ?? emptyUserInputDraft();
             return (
               <fieldset key={question.id} className="space-y-2">
                 <legend className="text-sm font-medium">
@@ -139,14 +125,14 @@ export function ChannelUserInputCard({
                           name={question.id}
                           type={question.multi_select ? "checkbox" : "radio"}
                           onChange={() => {
-                            const selected = question.multi_select
-                              ? checked
-                                ? value.selected.filter(
-                                    (v) => v !== option.value,
-                                  )
-                                : [...value.selected, option.value]
-                              : [option.value];
-                            update(question.id, { selected });
+                            update(
+                              question.id,
+                              selectUserInputOption(
+                                question,
+                                value,
+                                option.value,
+                              ),
+                            );
                           }}
                         />
                         <span>
@@ -168,27 +154,42 @@ export function ChannelUserInputCard({
                     placeholder="Your answer"
                     value={value.custom}
                     onChange={(event) =>
-                      update(question.id, {
-                        custom: event.target.value,
-                        selected: [],
-                      })
+                      setState((current) => ({
+                        ...current,
+                        [question.id]: setUserInputCustom(
+                          value,
+                          event.target.value,
+                        ),
+                      }))
                     }
                   />
                 ) : null}
                 {question.allow_notes && value.selected.length > 0 ? (
-                  <Textarea
-                    aria-label={`${question.header} notes`}
-                    disabled={readOnly}
-                    placeholder="Notes (optional)"
-                    value={Object.values(value.notes)[0] ?? ""}
-                    onChange={(event) =>
-                      update(question.id, {
-                        notes: {
-                          [value.selected[0]]: event.target.value,
-                        },
-                      })
-                    }
-                  />
+                  <div className="space-y-2">
+                    {value.selected.map((selectedValue) => {
+                      const option = question.options.find(
+                        ({ value: optionValue }) =>
+                          optionValue === selectedValue,
+                      );
+                      return (
+                        <Textarea
+                          aria-label={`${question.header} notes for ${option?.label ?? selectedValue}`}
+                          disabled={readOnly}
+                          key={selectedValue}
+                          placeholder={`Notes for ${option?.label ?? selectedValue} (optional)`}
+                          value={value.notes[selectedValue] ?? ""}
+                          onChange={(event) =>
+                            update(question.id, {
+                              notes: {
+                                ...value.notes,
+                                [selectedValue]: event.target.value,
+                              },
+                            })
+                          }
+                        />
+                      );
+                    })}
+                  </div>
                 ) : null}
               </fieldset>
             );
@@ -199,23 +200,28 @@ export function ChannelUserInputCard({
         <CardFooter className="gap-2">
           <Button
             data-testid="channel-user-input-skip"
-            disabled={readOnly}
+            disabled={readOnly || sending}
             type="button"
             variant="ghost"
             onClick={() => void onSkip(item)}
           >
-            Skip
+            {sending ? "Sending..." : "Answer nothing"}
           </Button>
           <Button
             data-testid="channel-user-input-submit"
-            disabled={readOnly || !hasAnswer}
+            disabled={readOnly || !hasAnswer || sending}
             type="button"
             onClick={() => void submit()}
           >
-            Submit
+            {sending ? "Sending..." : "Submit"}
           </Button>
         </CardFooter>
       ) : null}
+      {error ? (
+        <CardDescription className="px-6 pb-4 text-destructive" role="alert">
+          Could not send answer: {error}
+        </CardDescription>
+      ) : null}
     </Card>
   );
 }
diff --git a/desktop/src/features/channels/ui/ChannelUserInputStack.tsx b/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
index 24829b14651..ce05ce6a0f4 100644
--- a/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
+++ b/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
@@ -10,6 +10,8 @@ type Props = {
   sent: UserInputEvent[];
   currentPubkey: string;
   profiles?: Record<string, { ownerPubkey: string | null }>;
+  errors: Record<string, string>;
+  sendingRequestId: string | null;
   onSkip: (item: UserInputEvent) => Promise<void>;
   onSubmit: (item: UserInputEvent, answers: UserInputAnswers) => Promise<void>;
 };
@@ -19,6 +21,8 @@ export function ChannelUserInputStack({
   sent,
   currentPubkey,
   profiles,
+  errors,
+  sendingRequestId,
   onSkip,
   onSubmit,
 }: Props) {
@@ -38,6 +42,8 @@ export function ChannelUserInputStack({
           key={item.event.id}
           profiles={profiles}
           sent={sentIds.has(item.event.id)}
+          error={errors[item.event.id]}
+          sending={sendingRequestId === item.event.id}
           onSkip={onSkip}
           onSubmit={onSubmit}
         />
diff --git a/desktop/src/shared/api/tauriUserInput.ts b/desktop/src/shared/api/tauriUserInput.ts
index b54ba4e1e2d..e50cf6e66b0 100644
--- a/desktop/src/shared/api/tauriUserInput.ts
+++ b/desktop/src/shared/api/tauriUserInput.ts
@@ -1,13 +1,14 @@
 import { invokeTauri } from "@/shared/api/tauri";
+import type { UserInputAnswers } from "@/features/channels/lib/userInput";
 
 export async function sendChannelUserInputAnswer(
   channelId: string,
   requestEventId: string,
-  answers: string,
+  answers: UserInputAnswers,
 ): Promise<{ eventId: string }> {
   const response = await invokeTauri<{ event_id: string }>(
     "send_channel_user_input_answer",
-    { channelId, requestEventId, answers: JSON.parse(answers) },
+    { channelId, requestEventId, answers },
   );
   return { eventId: response.event_id };
 }

From c7db0ff1f711b54c3bea25326075ff1078da5369 Mon Sep 17 00:00:00 2001
From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Sat, 1 Aug 2026 15:22:19 +0000
Subject: [PATCH 3/5] feat: add durable user-input resolutions

Signed-off-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-Authored-By: Oscar Le <oscar.lehuu@gmail.com>
---
 AGENTS.md                                     |   4 +-
 ARCHITECTURE.md                               |   4 +-
 crates/buzz-acp/src/acp.rs                    |  13 +
 crates/buzz-acp/src/elicitation.rs            | 246 +++++++++++++++++-
 crates/buzz-acp/src/lib.rs                    |   3 +
 crates/buzz-core/src/kind.rs                  |   3 +
 crates/buzz-core/src/user_input.rs            |  52 ++++
 crates/buzz-relay/src/handlers/event.rs       |   2 +-
 crates/buzz-relay/src/handlers/ingest.rs      |   9 +-
 crates/buzz-sdk/src/builders.rs               |  56 +++-
 .../channels/hooks/useChannelUserInput.ts     |   7 +
 .../features/channels/lib/userInput.test.mjs  |  43 +++
 .../src/features/channels/lib/userInput.ts    |  85 +++++-
 .../src/features/channels/ui/ChannelPane.tsx  |   3 +-
 .../channels/ui/ChannelUserInputCard.tsx      |  35 ++-
 .../channels/ui/ChannelUserInputStack.tsx     |  42 ++-
 desktop/src/shared/api/relayChannelFilters.ts |   7 +-
 desktop/src/shared/constants/kinds.ts         |   1 +
 desktop/src/testing/e2eBridge.ts              |  28 ++
 desktop/tests/e2e/channels.spec.ts            |  24 ++
 20 files changed, 617 insertions(+), 50 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 9453bd8d736..4d69e63a96d 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -607,7 +607,9 @@ usage.
 for agent-directed human questions. Requests are published as durable,
 channel-scoped `KIND_AGENT_USER_INPUT_REQUESTED` events; owner-authored
 answers use `KIND_AGENT_USER_INPUT_ANSWER` and link to the request with an
-`e` tag. Permission requests remain governed by the existing bypass/approval
+`e` tag. Terminal requests publish `KIND_AGENT_USER_INPUT_RESOLVED` with the
+request event id and outcome (`answered`, `declined`, or `cancelled`), also
+linked with an `e` tag. Permission requests remain governed by the existing bypass/approval
 path. The agent-facing controls are:
 
 ```text
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 9345fa2da64..130398ed4ea 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -137,10 +137,10 @@ The `kind` integer is the only dispatch switch. The relay routes, stores, and fa
 | 45001 | KIND_FORUM_POST | Forum thread root |
 | 45003 | KIND_FORUM_COMMENT | Forum thread reply |
 | 46001–46012 | KIND_WORKFLOW_* | Workflow execution events |
-| 46040–46041 | KIND_AGENT_USER_INPUT_* | ACP agent-directed human-input requests and answers |
+| 46040–46042 | KIND_AGENT_USER_INPUT_* | ACP agent-directed human-input requests, answers, and terminal resolutions |
 | 20001 | KIND_PRESENCE_UPDATE | Ephemeral presence heartbeat |
 
-`buzz-core` defines all 81 kinds as `pub const KIND_*: u32` and exports `ALL_KINDS: &[u32]`. Kinds are `u32` (NIP-01 specifies unsigned integer; `u32` covers the full range). Buzz uses both standard Nostr kinds (e.g., kind 7 for reactions) and custom ranges (40000+).
+`buzz-core` defines all 82 kinds as `pub const KIND_*: u32` and exports `ALL_KINDS: &[u32]`. Kinds are `u32` (NIP-01 specifies unsigned integer; `u32` covers the full range). Buzz uses both standard Nostr kinds (e.g., kind 7 for reactions) and custom ranges (40000+).
 
 Note: `KIND_AUTH` (22242) is `pub const KIND_AUTH: u32` in `buzz-core/src/kind.rs` and imported by `buzz-relay/src/handlers/event.rs`. `KIND_CANVAS` (40100) is likewise `pub const KIND_CANVAS: u32` in `buzz-core/src/kind.rs`.
 
diff --git a/crates/buzz-acp/src/acp.rs b/crates/buzz-acp/src/acp.rs
index 47e734c8d24..8c84929bf68 100644
--- a/crates/buzz-acp/src/acp.rs
+++ b/crates/buzz-acp/src/acp.rs
@@ -815,6 +815,7 @@ impl AcpClient {
                 // caller will invoke cancel_with_cleanup.
             }
             Err(_) => {
+                self.cancel_pending_user_input().await;
                 self.last_prompt_id = None;
                 self.current_hard_deadline = None;
             }
@@ -822,6 +823,18 @@ impl AcpClient {
         self.parse_stop_reason(&result?)
     }
 
+    async fn cancel_pending_user_input(&mut self) {
+        if let (Some(runtime), Some(event_id)) = (
+            self.user_input_runtime.as_ref(),
+            self.pending_user_input_event_id.as_deref(),
+        ) {
+            runtime.cancel(event_id).await;
+        }
+        self.pending_user_input_id = None;
+        self.pending_user_input_event_id = None;
+        self.user_input_responded = false;
+    }
+
     /// Send a `session/cancel` **notification** (no `id` field, no response expected).
     ///
     /// After calling this, the agent will eventually respond to the in-flight
diff --git a/crates/buzz-acp/src/elicitation.rs b/crates/buzz-acp/src/elicitation.rs
index c76e3662bf8..16becbb0cf8 100644
--- a/crates/buzz-acp/src/elicitation.rs
+++ b/crates/buzz-acp/src/elicitation.rs
@@ -7,7 +7,7 @@ use buzz_core::{
     kind::KIND_AGENT_USER_INPUT_ANSWER,
     user_input::{
         Engine, Option_, UserInputAnswer, UserInputAnswers, UserInputQuestion, UserInputRequest,
-        UserInputSelection,
+        UserInputResolutionOutcome, UserInputResolved, UserInputSelection,
     },
 };
 use nostr::{Alphabet, Keys, SingleLetterTag, TagKind};
@@ -57,7 +57,12 @@ pub(crate) struct QuestionRuntime {
     keys: Keys,
     owner_cache: Arc<OwnerCache>,
     rest_client: RestClient,
-    pending: Mutex<std::collections::HashMap<String, oneshot::Sender<Option<UserInputAnswers>>>>,
+    pending: Mutex<std::collections::HashMap<String, PendingRequest>>,
+}
+
+struct PendingRequest {
+    channel_id: Uuid,
+    sender: oneshot::Sender<Option<UserInputAnswers>>,
 }
 
 impl QuestionRuntime {
@@ -106,7 +111,13 @@ impl QuestionRuntime {
             .map_err(|e| e.to_string())?;
         let event_id = event.id.to_hex();
         let (tx, rx) = oneshot::channel();
-        self.pending.lock().await.insert(event_id.clone(), tx);
+        self.pending.lock().await.insert(
+            event_id.clone(),
+            PendingRequest {
+                channel_id,
+                sender: tx,
+            },
+        );
         if let Err(error) = self.publisher.publish_event(event).await {
             self.pending.lock().await.remove(&event_id);
             return Err(error.to_string());
@@ -115,8 +126,70 @@ impl QuestionRuntime {
     }
 
     pub(crate) async fn cancel(&self, event_id: &str) {
-        if let Some(sender) = self.pending.lock().await.remove(event_id) {
-            let _ = sender.send(None);
+        if let Some(pending) = self.pending.lock().await.remove(event_id) {
+            let _ = pending.sender.send(None);
+            self.publish_resolution(
+                pending.channel_id,
+                event_id,
+                UserInputResolutionOutcome::Cancelled,
+            )
+            .await;
+        }
+    }
+
+    /// Resolve every request still owned by this runtime during graceful shutdown.
+    pub(crate) async fn shutdown_pending(&self) {
+        let pending = {
+            let mut guard = self.pending.lock().await;
+            std::mem::take(&mut *guard)
+        };
+        for (event_id, pending) in pending {
+            let _ = pending.sender.send(None);
+            self.publish_resolution(
+                pending.channel_id,
+                &event_id,
+                UserInputResolutionOutcome::Cancelled,
+            )
+            .await;
+        }
+    }
+
+    async fn publish_resolution(
+        &self,
+        channel_id: Uuid,
+        request_event_id: &str,
+        outcome: UserInputResolutionOutcome,
+    ) {
+        let content = match serde_json::to_string(&UserInputResolved {
+            request_event_id: request_event_id.to_owned(),
+            outcome,
+        }) {
+            Ok(content) => content,
+            Err(error) => {
+                tracing::warn!(%error, request_event_id, "failed to serialize user-input resolution");
+                return;
+            }
+        };
+        let builder = match buzz_sdk::build_agent_user_input_resolved(
+            channel_id,
+            request_event_id,
+            &content,
+        ) {
+            Ok(builder) => builder,
+            Err(error) => {
+                tracing::warn!(%error, request_event_id, "failed to build user-input resolution");
+                return;
+            }
+        };
+        match builder.sign_with_keys(&self.keys) {
+            Ok(event) => {
+                if let Err(error) = self.publisher.publish_event(event).await {
+                    tracing::warn!(%error, request_event_id, "failed to publish user-input resolution");
+                }
+            }
+            Err(error) => {
+                tracing::warn!(%error, request_event_id, "failed to sign user-input resolution");
+            }
         }
     }
 
@@ -156,9 +229,20 @@ impl QuestionRuntime {
                 return;
             }
         };
-        let sender = self.pending.lock().await.remove(&request_event_id);
-        if let Some(sender) = sender {
-            let _ = sender.send(Some(answers));
+        let pending = self.pending.lock().await.remove(&request_event_id);
+        if let Some(pending) = pending {
+            let declined = answers.values().all(Option::is_none);
+            let _ = pending.sender.send(Some(answers));
+            self.publish_resolution(
+                pending.channel_id,
+                &request_event_id,
+                if declined {
+                    UserInputResolutionOutcome::Declined
+                } else {
+                    UserInputResolutionOutcome::Answered
+                },
+            )
+            .await;
         } else {
             tracing::debug!(request_event_id, "ignoring late user-input answer");
         }
@@ -278,6 +362,9 @@ pub(crate) fn normalize_form(schema: &serde_json::Value) -> Option<NormalizedFor
             options,
             multi_select,
             allow_custom_answer: custom_key.is_some(),
+            required: required.contains(key.as_str()),
+            // ACP has no notes concept; intentionally false until an engine
+            // provides a notes affordance.
             allow_notes: false,
         };
         questions.push(question);
@@ -395,6 +482,7 @@ pub(crate) fn reconstruct_content(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use tokio::sync::mpsc;
 
     #[test]
     fn normalizes_select_and_freeform() {
@@ -505,6 +593,29 @@ mod tests {
         assert!(reconstruct_content(&form, &missing_required).is_none());
     }
 
+    #[test]
+    fn required_round_trips_and_old_question_events_default_to_false() {
+        let schema = serde_json::json!({
+            "type":"object",
+            "properties":{"question_0":{"type":"string"}},
+            "required":["question_0"]
+        });
+        let form = normalize_form(&schema).expect("supported");
+        assert!(form.questions[0].required);
+        let encoded = serde_json::to_string(&form.questions[0]).expect("question JSON");
+        assert!(
+            serde_json::from_str::<UserInputQuestion>(&encoded)
+                .expect("question round trip")
+                .required
+        );
+        let old = r#"{"id":"q0","header":"Pick","question":"Choose","options":[]}"#;
+        assert!(
+            !serde_json::from_str::<UserInputQuestion>(old)
+                .expect("old question JSON")
+                .required
+        );
+    }
+
     #[tokio::test]
     async fn ignores_non_owner_then_accepts_first_owner_answer() {
         let channel_id = Uuid::new_v4();
@@ -589,4 +700,123 @@ mod tests {
             })
             .await;
     }
+
+    #[tokio::test]
+    async fn publishes_one_resolution_for_each_terminal_outcome() {
+        async fn publish_request(
+            channel_id: Uuid,
+            owner: &Keys,
+        ) -> (
+            Arc<QuestionRuntime>,
+            mpsc::Receiver<nostr::Event>,
+            String,
+            oneshot::Receiver<Option<UserInputAnswers>>,
+        ) {
+            let (publisher, published) = RelayEventPublisher::test_pair();
+            let runtime = QuestionRuntime::new(
+                publisher,
+                owner.clone(),
+                Arc::new(crate::OwnerCache::new(Some(owner.public_key().to_hex()))),
+                RestClient {
+                    http: reqwest::Client::new(),
+                    base_url: "http://127.0.0.1:0".to_string(),
+                    keys: owner.clone(),
+                    auth_tag_json: None,
+                },
+            );
+            let form = normalize_form(&serde_json::json!({
+                "type":"object",
+                "properties":{"question_0":{"type":"string"}}
+            }))
+            .expect("supported");
+            let (event_id, receiver) = runtime
+                .publish(
+                    channel_id,
+                    "session",
+                    "turn",
+                    Engine::Claude,
+                    form,
+                    "request",
+                    None,
+                    None,
+                )
+                .await
+                .expect("publish");
+            (runtime, published, event_id, receiver)
+        }
+
+        async fn resolution(published: &mut mpsc::Receiver<nostr::Event>) -> UserInputResolved {
+            let _request = published.recv().await.expect("request event");
+            let event = published.recv().await.expect("resolution event");
+            assert_eq!(
+                event.kind.as_u16() as u32,
+                buzz_core::kind::KIND_AGENT_USER_INPUT_RESOLVED
+            );
+            serde_json::from_str(&event.content).expect("resolution contract")
+        }
+
+        let channel_id = Uuid::new_v4();
+        let owner = Keys::generate();
+
+        let (runtime, mut published, event_id, receiver) =
+            publish_request(channel_id, &owner).await;
+        let answer =
+            buzz_sdk::build_agent_user_input_answer(channel_id, &event_id, r#"{"q0":"answer"}"#)
+                .expect("answer builder")
+                .sign_with_keys(&owner)
+                .expect("answer signature");
+        runtime
+            .handle_event(&BuzzEvent {
+                channel_id,
+                event: answer,
+            })
+            .await;
+        assert!(receiver.await.expect("answer received").is_some());
+        assert_eq!(
+            resolution(&mut published).await.outcome,
+            UserInputResolutionOutcome::Answered
+        );
+
+        let (runtime, mut published, event_id, receiver) =
+            publish_request(channel_id, &owner).await;
+        let decline =
+            buzz_sdk::build_agent_user_input_answer(channel_id, &event_id, r#"{"q0":null}"#)
+                .expect("answer builder")
+                .sign_with_keys(&owner)
+                .expect("answer signature");
+        runtime
+            .handle_event(&BuzzEvent {
+                channel_id,
+                event: decline,
+            })
+            .await;
+        assert!(receiver.await.expect("decline received").is_some());
+        assert_eq!(
+            resolution(&mut published).await.outcome,
+            UserInputResolutionOutcome::Declined
+        );
+
+        let (runtime, mut published, event_id, receiver) =
+            publish_request(channel_id, &owner).await;
+        runtime.cancel(&event_id).await;
+        assert!(receiver.await.expect("cancel received").is_none());
+        assert_eq!(
+            resolution(&mut published).await.outcome,
+            UserInputResolutionOutcome::Cancelled
+        );
+
+        let (runtime, mut published, _event_id, receiver) =
+            publish_request(channel_id, &owner).await;
+        runtime.shutdown_pending().await;
+        assert!(receiver.await.expect("shutdown received").is_none());
+        assert_eq!(
+            resolution(&mut published).await.outcome,
+            UserInputResolutionOutcome::Cancelled
+        );
+        assert!(
+            tokio::time::timeout(std::time::Duration::from_millis(10), published.recv())
+                .await
+                .is_err()
+        );
+    }
 }
diff --git a/crates/buzz-acp/src/lib.rs b/crates/buzz-acp/src/lib.rs
index 464197b7976..ea669ed2539 100644
--- a/crates/buzz-acp/src/lib.rs
+++ b/crates/buzz-acp/src/lib.rs
@@ -2729,6 +2729,9 @@ async fn tokio_main() -> Result<()> {
     }
 
     tracing::info!("shutdown: waiting for in-flight prompts");
+    // Resolve pending elicitation requests before reaping agents so clients
+    // receive a terminal event during graceful harness shutdown.
+    user_input_runtime.shutdown_pending().await;
     // 30 s is generous for in-flight prompts to be cancelled; using
     // max_turn_duration here would cause Ctrl+C to hang for up to an hour.
     let grace = Duration::from_secs(30);
diff --git a/crates/buzz-core/src/kind.rs b/crates/buzz-core/src/kind.rs
index 8e3b29e3339..20663145015 100644
--- a/crates/buzz-core/src/kind.rs
+++ b/crates/buzz-core/src/kind.rs
@@ -571,6 +571,8 @@ pub const KIND_WORKFLOW_APPROVAL_DENIED: u32 = 46012;
 pub const KIND_AGENT_USER_INPUT_REQUESTED: u32 = 46040;
 /// An owner-authored answer to an ACP agent human-input request.
 pub const KIND_AGENT_USER_INPUT_ANSWER: u32 = 46041;
+/// Terminal resolution of an ACP agent human-input request.
+pub const KIND_AGENT_USER_INPUT_RESOLVED: u32 = 46042;
 
 // User groups (47000–47999)
 
@@ -728,6 +730,7 @@ pub const ALL_KINDS: &[u32] = &[
     KIND_WORKFLOW_APPROVAL_DENIED,
     KIND_AGENT_USER_INPUT_REQUESTED,
     KIND_AGENT_USER_INPUT_ANSWER,
+    KIND_AGENT_USER_INPUT_RESOLVED,
     KIND_AUDIT_ENTRY,
     KIND_HUDDLE_STARTED,
     KIND_HUDDLE_PARTICIPANT_JOINED,
diff --git a/crates/buzz-core/src/user_input.rs b/crates/buzz-core/src/user_input.rs
index fc9060571dd..5a02f71c746 100644
--- a/crates/buzz-core/src/user_input.rs
+++ b/crates/buzz-core/src/user_input.rs
@@ -46,6 +46,9 @@ pub struct UserInputQuestion {
     /// Whether notes may accompany a selection.
     #[serde(default)]
     pub allow_notes: bool,
+    /// Whether an answer is required by the originating engine schema.
+    #[serde(default)]
+    pub required: bool,
 }
 
 /// A durable question request published to a channel.
@@ -101,3 +104,52 @@ pub enum UserInputSelection {
 
 /// Answers keyed by Crew-owned question IDs.
 pub type UserInputAnswers = BTreeMap<String, Option<UserInputAnswer>>;
+
+/// Outcome of a durable agent question request.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum UserInputResolutionOutcome {
+    /// The owner supplied an answer.
+    Answered,
+    /// The owner explicitly answered nothing.
+    Declined,
+    /// The turn or harness terminated before an answer was received.
+    Cancelled,
+}
+
+/// Terminal resolution of a durable agent question request.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct UserInputResolved {
+    /// Event id of the corresponding kind-46040 request.
+    pub request_event_id: String,
+    /// Terminal outcome.
+    pub outcome: UserInputResolutionOutcome,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn resolution_contract_uses_stable_wire_vocabulary() {
+        let value = UserInputResolved {
+            request_event_id: "a".repeat(64),
+            outcome: UserInputResolutionOutcome::Cancelled,
+        };
+        assert_eq!(
+            serde_json::to_value(value).expect("serialize resolution"),
+            serde_json::json!({
+                "request_event_id": "a".repeat(64),
+                "outcome": "cancelled"
+            })
+        );
+    }
+
+    #[test]
+    fn question_required_defaults_for_legacy_events() {
+        let question: UserInputQuestion =
+            serde_json::from_str(r#"{"id":"q0","header":"Pick","question":"Choose","options":[]}"#)
+                .expect("deserialize legacy question");
+        assert!(!question.required);
+    }
+}
diff --git a/crates/buzz-relay/src/handlers/event.rs b/crates/buzz-relay/src/handlers/event.rs
index 480671238b6..5119e89a980 100644
--- a/crates/buzz-relay/src/handlers/event.rs
+++ b/crates/buzz-relay/src/handlers/event.rs
@@ -45,7 +45,7 @@ pub(crate) fn bounded_kind_label(kind: u32) -> String {
         44100..=44101 => kind.to_string(),
         44200 => kind.to_string(),
         45001..=45003 => kind.to_string(),
-        46001..=46012 | 46020 | 46030..=46031 | 46040..=46041 => kind.to_string(),
+        46001..=46012 | 46020 | 46030..=46031 | 46040..=46042 => kind.to_string(),
         48001 | 48100..=48103 | 48106 => kind.to_string(),
         49001 => kind.to_string(),
         _ => "other".to_string(),
diff --git a/crates/buzz-relay/src/handlers/ingest.rs b/crates/buzz-relay/src/handlers/ingest.rs
index 81815c05ef6..03dc7f1ad16 100644
--- a/crates/buzz-relay/src/handlers/ingest.rs
+++ b/crates/buzz-relay/src/handlers/ingest.rs
@@ -13,9 +13,9 @@ use buzz_auth::Scope;
 use buzz_core::kind::{
     event_kind_u32, is_identity_archive_request_kind, is_parameterized_replaceable,
     is_relay_admin_kind, KIND_AGENT_ENGRAM, KIND_AGENT_PROFILE, KIND_AGENT_TURN_METRIC,
-    KIND_AGENT_USER_INPUT_ANSWER, KIND_AGENT_USER_INPUT_REQUESTED, KIND_APPROVAL_DENY,
-    KIND_APPROVAL_GRANT, KIND_AUTH, KIND_BOOKMARK_LIST, KIND_BOOKMARK_SET, KIND_CANVAS,
-    KIND_CONTACT_LIST, KIND_DELETION, KIND_DM_ADD_MEMBER, KIND_DM_HIDE, KIND_DM_OPEN,
+    KIND_AGENT_USER_INPUT_ANSWER, KIND_AGENT_USER_INPUT_REQUESTED, KIND_AGENT_USER_INPUT_RESOLVED,
+    KIND_APPROVAL_DENY, KIND_APPROVAL_GRANT, KIND_AUTH, KIND_BOOKMARK_LIST, KIND_BOOKMARK_SET,
+    KIND_CANVAS, KIND_CONTACT_LIST, KIND_DELETION, KIND_DM_ADD_MEMBER, KIND_DM_HIDE, KIND_DM_OPEN,
     KIND_EMOJI_LIST, KIND_EMOJI_SET, KIND_EVENT_REMINDER, KIND_FOLLOW_SET, KIND_FORUM_COMMENT,
     KIND_FORUM_POST, KIND_FORUM_VOTE, KIND_GIFT_WRAP, KIND_GIT_ISSUE, KIND_GIT_PATCH,
     KIND_GIT_PR_UPDATE, KIND_GIT_PULL_REQUEST, KIND_GIT_REPO_ANNOUNCEMENT, KIND_GIT_REPO_STATE,
@@ -258,7 +258,8 @@ fn required_scope_for_kind(kind: u32, event: &Event) -> Result<Scope, &'static s
         | KIND_FORUM_VOTE
         | KIND_FORUM_COMMENT
         | KIND_AGENT_USER_INPUT_REQUESTED
-        | KIND_AGENT_USER_INPUT_ANSWER => Ok(Scope::MessagesWrite),
+        | KIND_AGENT_USER_INPUT_ANSWER
+        | KIND_AGENT_USER_INPUT_RESOLVED => Ok(Scope::MessagesWrite),
         KIND_NIP29_PUT_USER | KIND_NIP29_REMOVE_USER | KIND_NIP29_DELETE_GROUP => {
             Ok(Scope::AdminChannels)
         }
diff --git a/crates/buzz-sdk/src/builders.rs b/crates/buzz-sdk/src/builders.rs
index 01680edf0fd..49cb4450813 100644
--- a/crates/buzz-sdk/src/builders.rs
+++ b/crates/buzz-sdk/src/builders.rs
@@ -6,13 +6,14 @@
 use buzz_core::{
     kind::{
         KIND_AGENT_OBSERVER_FRAME, KIND_AGENT_USER_INPUT_ANSWER, KIND_AGENT_USER_INPUT_REQUESTED,
-        KIND_APPROVAL_DENY, KIND_APPROVAL_GRANT, KIND_DELETION, KIND_DM_ADD_MEMBER, KIND_DM_OPEN,
-        KIND_EMOJI_SET, KIND_GIT_ISSUE, KIND_GIT_PATCH, KIND_GIT_PR_UPDATE, KIND_GIT_PULL_REQUEST,
-        KIND_GIT_REPO_ANNOUNCEMENT, KIND_GIT_STATUS_CLOSED, KIND_GIT_STATUS_DRAFT,
-        KIND_GIT_STATUS_MERGED, KIND_GIT_STATUS_OPEN, KIND_IA_ARCHIVE_REQUEST,
-        KIND_IA_UNARCHIVE_REQUEST, KIND_MODERATION_BAN, KIND_MODERATION_RESOLVE_REPORT,
-        KIND_MODERATION_TIMEOUT, KIND_MODERATION_UNBAN, KIND_MODERATION_UNTIMEOUT,
-        KIND_PRESENCE_UPDATE, KIND_USER_STATUS, KIND_WORKFLOW_DEF, KIND_WORKFLOW_TRIGGER,
+        KIND_AGENT_USER_INPUT_RESOLVED, KIND_APPROVAL_DENY, KIND_APPROVAL_GRANT, KIND_DELETION,
+        KIND_DM_ADD_MEMBER, KIND_DM_OPEN, KIND_EMOJI_SET, KIND_GIT_ISSUE, KIND_GIT_PATCH,
+        KIND_GIT_PR_UPDATE, KIND_GIT_PULL_REQUEST, KIND_GIT_REPO_ANNOUNCEMENT,
+        KIND_GIT_STATUS_CLOSED, KIND_GIT_STATUS_DRAFT, KIND_GIT_STATUS_MERGED,
+        KIND_GIT_STATUS_OPEN, KIND_IA_ARCHIVE_REQUEST, KIND_IA_UNARCHIVE_REQUEST,
+        KIND_MODERATION_BAN, KIND_MODERATION_RESOLVE_REPORT, KIND_MODERATION_TIMEOUT,
+        KIND_MODERATION_UNBAN, KIND_MODERATION_UNTIMEOUT, KIND_PRESENCE_UPDATE, KIND_USER_STATUS,
+        KIND_WORKFLOW_DEF, KIND_WORKFLOW_TRIGGER,
     },
     observer::{
         content_looks_like_nip44, OBSERVER_AGENT_TAG, OBSERVER_FRAME_CONTROL, OBSERVER_FRAME_TAG,
@@ -1567,6 +1568,21 @@ pub fn build_agent_user_input_answer(
     Ok(EventBuilder::new(Kind::Custom(KIND_AGENT_USER_INPUT_ANSWER as u16), content).tags(tags))
 }
 
+/// Build a terminal resolution event for an agent question request.
+pub fn build_agent_user_input_resolved(
+    channel_id: Uuid,
+    request_event_id: &str,
+    content: &str,
+) -> Result<EventBuilder, SdkError> {
+    check_content(content, 16 * 1024)?;
+    let request_event_id = check_hex_exact(request_event_id, 64, "request_event_id")?;
+    let tags = vec![
+        tag(&["h", &channel_id.to_string()])?,
+        tag(&["e", &request_event_id])?,
+    ];
+    Ok(EventBuilder::new(Kind::Custom(KIND_AGENT_USER_INPUT_RESOLVED as u16), content).tags(tags))
+}
+
 /// Build a DM open event (kind 41010).
 ///
 /// `pubkeys` must be 1–8 hex-encoded pubkeys to include in the DM conversation.
@@ -3947,4 +3963,30 @@ mod tests {
             .iter()
             .any(|tag| { tag.as_slice() == ["e".to_string(), request.clone()] }));
     }
+
+    #[test]
+    fn agent_user_input_resolved_builder_sets_kind_and_request_link() {
+        let channel = Uuid::new_v4();
+        let request = "b".repeat(64);
+        let event = sign(
+            build_agent_user_input_resolved(
+                channel,
+                &request,
+                r#"{"request_event_id":"bbbb","outcome":"cancelled"}"#,
+            )
+            .unwrap(),
+        );
+        assert_eq!(
+            event.kind,
+            Kind::Custom(KIND_AGENT_USER_INPUT_RESOLVED as u16)
+        );
+        assert!(event
+            .tags
+            .iter()
+            .any(|tag| { tag.as_slice() == ["h".to_string(), channel.to_string()] }));
+        assert!(event
+            .tags
+            .iter()
+            .any(|tag| { tag.as_slice() == ["e".to_string(), request.clone()] }));
+    }
 }
diff --git a/desktop/src/features/channels/hooks/useChannelUserInput.ts b/desktop/src/features/channels/hooks/useChannelUserInput.ts
index c5f09c12ecc..ba563a0fb69 100644
--- a/desktop/src/features/channels/hooks/useChannelUserInput.ts
+++ b/desktop/src/features/channels/hooks/useChannelUserInput.ts
@@ -7,6 +7,7 @@ import { sendChannelUserInputAnswer } from "@/shared/api/tauriUserInput";
 import {
   buildSkippedAnswers,
   buildUserInputAnswers,
+  deriveResolvedUserInputs,
   derivePendingUserInputs,
   publishUserInputAnswer,
   type UserInputAnswers,
@@ -89,6 +90,10 @@ export function useChannelUserInput(channelId: string | null) {
       sentRequestIds.has(event.id),
     );
   }, [currentPubkey, events, sentRequestIds]);
+  const resolved = React.useMemo(
+    () => deriveResolvedUserInputs(events),
+    [events],
+  );
 
   const answer = React.useCallback(
     async (request: UserInputEvent, answers: UserInputAnswers) => {
@@ -136,8 +141,10 @@ export function useChannelUserInput(channelId: string | null) {
   );
 
   return {
+    hasCards: pending.length > 0 || sent.length > 0 || resolved.length > 0,
     pending,
     sent,
+    resolved,
     currentPubkey,
     sendingRequestId,
     sentRequestIds,
diff --git a/desktop/src/features/channels/lib/userInput.test.mjs b/desktop/src/features/channels/lib/userInput.test.mjs
index da213ff4d88..661b0a773e1 100644
--- a/desktop/src/features/channels/lib/userInput.test.mjs
+++ b/desktop/src/features/channels/lib/userInput.test.mjs
@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import {
   buildQuestionAnswer,
+  canSubmitUserInput,
   buildSkippedAnswers,
   buildUserInputAnswers,
   derivePendingUserInputs,
@@ -9,6 +10,7 @@ import {
   selectUserInputOption,
   serializeUserInputAnswers,
   setUserInputCustom,
+  deriveResolvedUserInputs,
 } from "./userInput.ts";
 
 const request = (id, created_at = 10) => ({
@@ -90,6 +92,47 @@ test("optimistic resolution hides the card", () => {
   );
 });
 
+test("resolved requests become terminal and stay out of pending questions", () => {
+  const requestEvent = request("request-1");
+  const resolvedEvent = {
+    id: "resolved-1",
+    kind: 46042,
+    pubkey: "agent",
+    content: JSON.stringify({
+      request_event_id: "request-1",
+      outcome: "cancelled",
+    }),
+    tags: [
+      ["h", "channel"],
+      ["e", "request-1"],
+    ],
+    created_at: 20,
+  };
+  assert.equal(
+    derivePendingUserInputs([requestEvent, resolvedEvent], "owner").length,
+    0,
+  );
+  assert.deepEqual(
+    deriveResolvedUserInputs([requestEvent, resolvedEvent]).map(
+      ({ resolution }) => resolution,
+    ),
+    ["cancelled"],
+  );
+});
+
+test("submit only requires required questions", () => {
+  const questions = [
+    { id: "q0", required: true },
+    { id: "q1", required: false },
+  ];
+  assert.equal(
+    canSubmitUserInput(questions, {
+      q0: { selected: ["yes"], custom: "", notes: {} },
+    }),
+    true,
+  );
+});
+
 test("answer payloads preserve all wire shapes", () => {
   assert.equal(
     serializeUserInputAnswers(
diff --git a/desktop/src/features/channels/lib/userInput.ts b/desktop/src/features/channels/lib/userInput.ts
index eb7dce0eda4..8d306ad35b5 100644
--- a/desktop/src/features/channels/lib/userInput.ts
+++ b/desktop/src/features/channels/lib/userInput.ts
@@ -1,6 +1,7 @@
 import {
   KIND_AGENT_USER_INPUT_ANSWER,
   KIND_AGENT_USER_INPUT_REQUESTED,
+  KIND_AGENT_USER_INPUT_RESOLVED,
 } from "@/shared/constants/kinds";
 import type { RelayEvent } from "@/shared/api/types";
 
@@ -18,6 +19,7 @@ export type UserInputQuestion = {
   multi_select?: boolean;
   allow_custom_answer?: boolean;
   allow_notes?: boolean;
+  required?: boolean;
 };
 
 export type UserInputRequest = {
@@ -36,6 +38,13 @@ export type UserInputEvent = {
   request: UserInputRequest;
 };
 
+export type UserInputResolutionOutcome = "answered" | "declined" | "cancelled";
+
+export type UserInputResolved = {
+  request_event_id: string;
+  outcome: UserInputResolutionOutcome;
+};
+
 export type UserInputAnswerValue =
   | string
   | string[]
@@ -74,6 +83,17 @@ export const emptyUserInputDraft = (): UserInputDraft => ({
   notes: {},
 });
 
+export function canSubmitUserInput(
+  questions: UserInputQuestion[],
+  drafts: Record<string, UserInputDraft>,
+): boolean {
+  return questions.every((question) => {
+    if (!question.required) return true;
+    const value = drafts[question.id];
+    return Boolean(value?.custom.trim() || value?.selected.length);
+  });
+}
+
 export function selectUserInputOption(
   question: UserInputQuestion,
   draft: UserInputDraft,
@@ -143,6 +163,32 @@ export function getAnswerRequestId(event: RelayEvent): string | null {
   return tag?.[1] ?? null;
 }
 
+export function getResolvedRequestId(event: RelayEvent): string | null {
+  if (event.kind !== KIND_AGENT_USER_INPUT_RESOLVED) return null;
+  const tag = event.tags.find(([name]) => name === "e");
+  return tag?.[1] ?? null;
+}
+
+export function parseUserInputResolution(
+  event: RelayEvent,
+): UserInputResolved | null {
+  if (event.kind !== KIND_AGENT_USER_INPUT_RESOLVED) return null;
+  try {
+    const value = JSON.parse(event.content) as UserInputResolved;
+    if (
+      !value ||
+      typeof value !== "object" ||
+      typeof value.request_event_id !== "string" ||
+      !["answered", "declined", "cancelled"].includes(value.outcome)
+    ) {
+      return null;
+    }
+    return value;
+  } catch {
+    return null;
+  }
+}
+
 export function dedupeUserInputEvents(
   events: RelayEvent[],
   limit = 200,
@@ -172,6 +218,12 @@ export function derivePendingUserInputs(
       .map(getAnswerRequestId)
       .filter((id): id is string => id !== null),
   );
+  const resolved = new Map<string, UserInputResolutionOutcome>();
+  for (const event of deduped) {
+    const resolution = parseUserInputResolution(event);
+    const requestId = getResolvedRequestId(event);
+    if (resolution && requestId) resolved.set(requestId, resolution.outcome);
+  }
   return deduped
     .filter((event) => event.kind === KIND_AGENT_USER_INPUT_REQUESTED)
     .map((event) => {
@@ -181,7 +233,38 @@ export function derivePendingUserInputs(
     .filter((item): item is UserInputEvent => item !== null)
     .filter(
       ({ event }) =>
-        !answered.has(event.id) && !optimisticallyResolvedIds.has(event.id),
+        !answered.has(event.id) &&
+        !resolved.has(event.id) &&
+        !optimisticallyResolvedIds.has(event.id),
+    )
+    .sort((left, right) => right.event.created_at - left.event.created_at);
+}
+
+export function deriveResolvedUserInputs(
+  events: RelayEvent[],
+): Array<UserInputEvent & { resolution: UserInputResolutionOutcome }> {
+  const deduped = dedupeUserInputEvents(events);
+  const resolutions = new Map<string, UserInputResolutionOutcome>();
+  for (const event of deduped) {
+    const requestId = getResolvedRequestId(event);
+    const resolution = parseUserInputResolution(event);
+    if (requestId && resolution) resolutions.set(requestId, resolution.outcome);
+  }
+  return deduped
+    .filter((event) => event.kind === KIND_AGENT_USER_INPUT_REQUESTED)
+    .map((event) => {
+      const request = parseUserInputRequest(event);
+      const outcome = resolutions.get(event.id);
+      return request && outcome
+        ? { event, request, resolution: outcome }
+        : null;
+    })
+    .filter(
+      (
+        item,
+      ): item is UserInputEvent & {
+        resolution: UserInputResolutionOutcome;
+      } => item !== null,
     )
     .sort((left, right) => right.event.created_at - left.event.created_at);
 }
diff --git a/desktop/src/features/channels/ui/ChannelPane.tsx b/desktop/src/features/channels/ui/ChannelPane.tsx
index 483ea4b4229..5f95fcd5191 100644
--- a/desktop/src/features/channels/ui/ChannelPane.tsx
+++ b/desktop/src/features/channels/ui/ChannelPane.tsx
@@ -743,10 +743,11 @@ export const ChannelPane = React.memo(function ChannelPane({
                   </div>
                 ) : null}
                 <ComposerDockBackdrop gutterClassName="inset-x-5" />
-                {userInput.pending.length > 0 || userInput.sent.length > 0 ? (
+                {userInput.hasCards ? (
                   <ChannelUserInputStack
                     currentPubkey={currentPubkey ?? ""}
                     pending={userInput.pending}
+                    resolved={userInput.resolved}
                     profiles={profiles}
                     sent={userInput.sent}
                     errors={userInput.errors}
diff --git a/desktop/src/features/channels/ui/ChannelUserInputCard.tsx b/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
index f3d1ab761ee..4e5b541ace7 100644
--- a/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
+++ b/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
@@ -12,6 +12,7 @@ import { Textarea } from "@/shared/ui/textarea";
 import { cn } from "@/shared/lib/cn";
 import {
   buildQuestionAnswer,
+  canSubmitUserInput,
   emptyUserInputDraft,
   selectUserInputOption,
   setUserInputCustom,
@@ -25,6 +26,7 @@ type Props = {
   currentPubkey: string;
   profiles?: Record<string, { ownerPubkey: string | null }>;
   sent?: boolean;
+  resolution?: "answered" | "declined" | "cancelled";
   error?: string;
   sending?: boolean;
   onSubmit: (
@@ -39,6 +41,7 @@ export function ChannelUserInputCard({
   currentPubkey,
   profiles,
   sent = false,
+  resolution,
   error,
   sending = false,
   onSubmit,
@@ -47,10 +50,8 @@ export function ChannelUserInputCard({
   const [state, setState] = React.useState<Record<string, UserInputDraft>>({});
   const ownerPubkey = profiles?.[item.event.pubkey]?.ownerPubkey ?? null;
   const readOnly = ownerPubkey !== null && ownerPubkey !== currentPubkey;
-  const hasAnswer = item.request.questions.every((question) => {
-    const value = state[question.id];
-    return Boolean(value?.custom.trim() || value?.selected.length);
-  });
+  const terminal = resolution !== undefined;
+  const hasAnswer = canSubmitUserInput(item.request.questions, state);
 
   const update = (id: string, patch: Partial<UserInputDraft>) => {
     setState((current) => ({
@@ -65,10 +66,10 @@ export function ChannelUserInputCard({
   const submit = async () => {
     const answers: Record<string, UserInputAnswerValue> = {};
     for (const question of item.request.questions) {
-      answers[question.id] = buildQuestionAnswer(
-        question,
-        state[question.id] ?? emptyUserInputDraft(),
-      );
+      const value = state[question.id] ?? emptyUserInputDraft();
+      if (value.custom.trim() || value.selected.length > 0) {
+        answers[question.id] = buildQuestionAnswer(question, value);
+      }
     }
     await onSubmit(item, answers);
   };
@@ -80,7 +81,15 @@ export function ChannelUserInputCard({
     >
       <CardHeader className="pb-3">
         <CardTitle className="text-base">
-          {sent ? "Answer sent" : "Agent question"}
+          {terminal
+            ? resolution === "cancelled"
+              ? "Question cancelled"
+              : resolution === "declined"
+                ? "Question declined"
+                : "Question answered"
+            : sent
+              ? "Answer sent"
+              : "Agent question"}
         </CardTitle>
         {item.request.message ? (
           <CardDescription className="whitespace-pre-wrap text-sm text-foreground/80">
@@ -93,9 +102,13 @@ export function ChannelUserInputCard({
           </CardDescription>
         ) : sent ? (
           <CardDescription>Sent, waiting for the agent.</CardDescription>
+        ) : terminal ? (
+          <CardDescription>
+            This question is no longer waiting for an answer.
+          </CardDescription>
         ) : null}
       </CardHeader>
-      {!sent ? (
+      {!sent && !terminal ? (
         <CardContent className="space-y-5">
           {item.request.questions.map((question) => {
             const value = state[question.id] ?? emptyUserInputDraft();
@@ -196,7 +209,7 @@ export function ChannelUserInputCard({
           })}
         </CardContent>
       ) : null}
-      {!sent ? (
+      {!sent && !terminal ? (
         <CardFooter className="gap-2">
           <Button
             data-testid="channel-user-input-skip"
diff --git a/desktop/src/features/channels/ui/ChannelUserInputStack.tsx b/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
index ce05ce6a0f4..9c9ab818b54 100644
--- a/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
+++ b/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
@@ -8,6 +8,11 @@ import type {
 type Props = {
   pending: UserInputEvent[];
   sent: UserInputEvent[];
+  resolved: Array<
+    UserInputEvent & {
+      resolution: "answered" | "declined" | "cancelled";
+    }
+  >;
   currentPubkey: string;
   profiles?: Record<string, { ownerPubkey: string | null }>;
   errors: Record<string, string>;
@@ -16,9 +21,16 @@ type Props = {
   onSubmit: (item: UserInputEvent, answers: UserInputAnswers) => Promise<void>;
 };
 
+type ResolvedUserInputEvent = UserInputEvent & {
+  resolution: "answered" | "declined" | "cancelled";
+};
+
+type CardItem = UserInputEvent | ResolvedUserInputEvent;
+
 export function ChannelUserInputStack({
   pending,
   sent,
+  resolved,
   currentPubkey,
   profiles,
   errors,
@@ -35,19 +47,23 @@ export function ChannelUserInputStack({
       className="pointer-events-auto mx-5 mb-2 max-h-[min(48vh,34rem)] space-y-2 overflow-y-auto"
       data-testid="channel-user-input-stack"
     >
-      {[...sent, ...pending].map((item) => (
-        <ChannelUserInputCard
-          currentPubkey={currentPubkey}
-          item={item}
-          key={item.event.id}
-          profiles={profiles}
-          sent={sentIds.has(item.event.id)}
-          error={errors[item.event.id]}
-          sending={sendingRequestId === item.event.id}
-          onSkip={onSkip}
-          onSubmit={onSubmit}
-        />
-      ))}
+      {([...sent, ...resolved, ...pending] as CardItem[]).map((item) => {
+        const resolution = "resolution" in item ? item.resolution : undefined;
+        return (
+          <ChannelUserInputCard
+            currentPubkey={currentPubkey}
+            item={item}
+            key={item.event.id}
+            profiles={profiles}
+            sent={sentIds.has(item.event.id)}
+            resolution={resolution}
+            error={errors[item.event.id]}
+            sending={sendingRequestId === item.event.id}
+            onSkip={onSkip}
+            onSubmit={onSubmit}
+          />
+        );
+      })}
     </div>
   );
 }
diff --git a/desktop/src/shared/api/relayChannelFilters.ts b/desktop/src/shared/api/relayChannelFilters.ts
index 35a2b7fae6d..73a68bf0926 100644
--- a/desktop/src/shared/api/relayChannelFilters.ts
+++ b/desktop/src/shared/api/relayChannelFilters.ts
@@ -6,6 +6,7 @@ import {
   KIND_DELETION,
   KIND_AGENT_USER_INPUT_ANSWER,
   KIND_AGENT_USER_INPUT_REQUESTED,
+  KIND_AGENT_USER_INPUT_RESOLVED,
   KIND_NIP29_DELETE_EVENT,
   KIND_REACTION,
   KIND_STREAM_MESSAGE,
@@ -27,7 +28,11 @@ export function buildChannelUserInputFilter(
   since?: number,
 ): RelaySubscriptionFilter {
   const filter: RelaySubscriptionFilter = {
-    kinds: [KIND_AGENT_USER_INPUT_REQUESTED, KIND_AGENT_USER_INPUT_ANSWER],
+    kinds: [
+      KIND_AGENT_USER_INPUT_REQUESTED,
+      KIND_AGENT_USER_INPUT_ANSWER,
+      KIND_AGENT_USER_INPUT_RESOLVED,
+    ],
     "#h": [channelId],
     limit,
   };
diff --git a/desktop/src/shared/constants/kinds.ts b/desktop/src/shared/constants/kinds.ts
index ad5e418aee6..15c53b1e4dc 100644
--- a/desktop/src/shared/constants/kinds.ts
+++ b/desktop/src/shared/constants/kinds.ts
@@ -33,6 +33,7 @@ export const KIND_FORUM_COMMENT = 45003;
 export const KIND_APPROVAL_REQUEST = 46010;
 export const KIND_AGENT_USER_INPUT_REQUESTED = 46040;
 export const KIND_AGENT_USER_INPUT_ANSWER = 46041;
+export const KIND_AGENT_USER_INPUT_RESOLVED = 46042;
 export const KIND_MEMBER_ADDED_NOTIFICATION = 44100;
 export const KIND_MEMBER_REMOVED_NOTIFICATION = 44101;
 export const KIND_TYPING_INDICATOR = 20002;
diff --git a/desktop/src/testing/e2eBridge.ts b/desktop/src/testing/e2eBridge.ts
index 90d77cbc596..721efaa086e 100644
--- a/desktop/src/testing/e2eBridge.ts
+++ b/desktop/src/testing/e2eBridge.ts
@@ -28,6 +28,7 @@ import {
 } from "@/shared/api/customEmoji";
 import {
   KIND_AGENT_USER_INPUT_REQUESTED,
+  KIND_AGENT_USER_INPUT_RESOLVED,
   KIND_AGENT_OBSERVER_FRAME,
   KIND_CHANNEL_THREAD_SUMMARY,
   KIND_CHANNEL_WINDOW_BOUNDS,
@@ -1079,6 +1080,11 @@ declare global {
       content: string;
       pubkey?: string;
     }) => RelayEvent;
+    __BUZZ_E2E_EMIT_MOCK_USER_INPUT_RESOLVED__?: (input: {
+      channelName: string;
+      requestEventId: string;
+      outcome: "answered" | "declined" | "cancelled";
+    }) => RelayEvent;
     /** Prepend `count` synthetic older messages to a channel's mock store so
      *  an older-history fetch has something to paginate. Mirrors how the real
      *  relay backfills history. Returns the created events. */
@@ -9710,6 +9716,28 @@ export function maybeInstallE2eTauriMocks() {
     emitMockLiveEvent(channel.id, event);
     return event;
   };
+  window.__BUZZ_E2E_EMIT_MOCK_USER_INPUT_RESOLVED__ = ({
+    channelName,
+    requestEventId,
+    outcome,
+  }) => {
+    const channel = mockChannels.find(
+      (candidate) => candidate.name === channelName,
+    );
+    if (!channel) throw new Error(`Mock channel ${channelName} not found.`);
+    const event = createMockEvent(
+      KIND_AGENT_USER_INPUT_RESOLVED,
+      JSON.stringify({ request_event_id: requestEventId, outcome }),
+      [
+        ["h", channel.id],
+        ["e", requestEventId],
+      ],
+      DEFAULT_MOCK_IDENTITY.pubkey,
+    );
+    recordMockMessage(channel.id, event);
+    emitMockLiveEvent(channel.id, event);
+    return event;
+  };
   window.__BUZZ_E2E_PREPEND_MOCK_HISTORY__ = prependMockHistory;
   window.__BUZZ_E2E_EMIT_MOCK_TYPING__ = ({
     channelName,
diff --git a/desktop/tests/e2e/channels.spec.ts b/desktop/tests/e2e/channels.spec.ts
index 480d796930d..50ff5f34083 100644
--- a/desktop/tests/e2e/channels.spec.ts
+++ b/desktop/tests/e2e/channels.spec.ts
@@ -544,6 +544,12 @@ test("channel question card accepts an answer", async ({ page }) => {
   await card.getByRole("radio", { name: "Production" }).check();
   await card.getByTestId("channel-user-input-submit").click();
   await expect(card).toContainText("Sent, waiting for the agent.");
+  await page.waitForFunction(() =>
+    window.__BUZZ_E2E_HAS_MOCK_LIVE_SUBSCRIPTION__?.({
+      channelName: "general",
+      kind: 46042,
+    }),
+  );
   await expect
     .poll(() =>
       page.evaluate(() =>
@@ -571,6 +577,24 @@ test("channel question card accepts an answer", async ({ page }) => {
         answers: { q0: "production" },
       },
     });
+
+  await page.evaluate(() => {
+    const win = window as Window & {
+      __BUZZ_E2E_EMIT_MOCK_USER_INPUT_RESOLVED__?: (input: {
+        channelName: string;
+        requestEventId: string;
+        outcome: "answered" | "declined" | "cancelled";
+      }) => unknown;
+    };
+    win.__BUZZ_E2E_EMIT_MOCK_USER_INPUT_RESOLVED__?.({
+      channelName: "general",
+      requestEventId: "a".repeat(64),
+      outcome: "answered",
+    });
+  });
+  await expect(card).toContainText("Question answered");
+  await expect(card.getByTestId("channel-user-input-submit")).toHaveCount(0);
+  await expect(card.locator("input, textarea")).toHaveCount(0);
 });
 
 test("sidebar shows all channel types", async ({ page }) => {

From d49f26f16cd8c05e547eb91c8108091a347808bd Mon Sep 17 00:00:00 2001
From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Sat, 1 Aug 2026 15:27:51 +0000
Subject: [PATCH 4/5] test: update CLI command inventory

Signed-off-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-Authored-By: Oscar Le <oscar.lehuu@gmail.com>
---
 crates/buzz-cli/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/buzz-cli/src/lib.rs b/crates/buzz-cli/src/lib.rs
index 5c1b84d80fc..d4bfeea6353 100644
--- a/crates/buzz-cli/src/lib.rs
+++ b/crates/buzz-cli/src/lib.rs
@@ -1936,6 +1936,7 @@ mod tests {
             "repos",
             "social",
             "upload",
+            "user-input",
             "users",
             "workflows",
         ];

From 1871347a458c219cd7883a0e20948e7929eb330d Mon Sep 17 00:00:00 2001
From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Sat, 1 Aug 2026 15:34:53 +0000
Subject: [PATCH 5/5] fix: scope terminal question cards

Signed-off-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-Authored-By: Oscar Le <oscar.lehuu@gmail.com>
---
 .../channels/hooks/useChannelUserInput.ts     | 44 +++++++++++++++++--
 .../features/channels/lib/userInput.test.mjs  |  4 ++
 .../src/features/channels/lib/userInput.ts    | 11 ++++-
 .../src/features/channels/ui/ChannelPane.tsx  |  1 +
 .../channels/ui/ChannelUserInputCard.tsx      | 14 ++++++
 .../channels/ui/ChannelUserInputStack.tsx     |  3 ++
 desktop/tests/e2e/channels.spec.ts            |  2 +
 7 files changed, 74 insertions(+), 5 deletions(-)

diff --git a/desktop/src/features/channels/hooks/useChannelUserInput.ts b/desktop/src/features/channels/hooks/useChannelUserInput.ts
index ba563a0fb69..9cdb4600c66 100644
--- a/desktop/src/features/channels/hooks/useChannelUserInput.ts
+++ b/desktop/src/features/channels/hooks/useChannelUserInput.ts
@@ -4,6 +4,7 @@ import { relayClient } from "@/shared/api/relayClient";
 import { buildChannelUserInputFilter } from "@/shared/api/relayChannelFilters";
 import type { RelayEvent } from "@/shared/api/types";
 import { sendChannelUserInputAnswer } from "@/shared/api/tauriUserInput";
+import { KIND_AGENT_USER_INPUT_REQUESTED } from "@/shared/constants/kinds";
 import {
   buildSkippedAnswers,
   buildUserInputAnswers,
@@ -30,12 +31,20 @@ export function useChannelUserInput(channelId: string | null) {
     () => new Set<string>(),
   );
   const [errors, setErrors] = React.useState<Record<string, string>>({});
+  const [visibleRequestIds, setVisibleRequestIds] = React.useState(
+    () => new Set<string>(),
+  );
+  const [dismissedResolutionIds, setDismissedResolutionIds] = React.useState(
+    () => new Set<string>(),
+  );
 
   React.useEffect(() => {
     setEvents([]);
     setOptimisticallyResolved(new Set());
     setSentRequestIds(new Set());
     setErrors({});
+    setVisibleRequestIds(new Set());
+    setDismissedResolutionIds(new Set());
     if (!channelId) return;
 
     let cancelled = false;
@@ -43,6 +52,12 @@ export function useChannelUserInput(channelId: string | null) {
     const filter = buildChannelUserInputFilter(channelId, RETAINED_EVENTS);
     const onEvent = (event: RelayEvent) => {
       if (cancelled) return;
+      if (event.kind === KIND_AGENT_USER_INPUT_REQUESTED) {
+        setVisibleRequestIds((current) => {
+          if (current.has(event.id)) return current;
+          return new Set(current).add(event.id);
+        });
+      }
       setEvents((current) => {
         if (current.some((existing) => existing.id === event.id))
           return current;
@@ -60,6 +75,16 @@ export function useChannelUserInput(channelId: string | null) {
         }
         const history = await relayClient.fetchEvents(filter);
         if (!cancelled) {
+          const pendingIds = new Set(
+            derivePendingUserInputs(history, currentPubkey).map(
+              ({ event }) => event.id,
+            ),
+          );
+          setVisibleRequestIds((current) => {
+            const next = new Set(current);
+            for (const id of pendingIds) next.add(id);
+            return next;
+          });
           setEvents((current) => {
             const byId = new Map(current.map((event) => [event.id, event]));
             for (const event of history) byId.set(event.id, event);
@@ -78,7 +103,7 @@ export function useChannelUserInput(channelId: string | null) {
       cancelled = true;
       void dispose?.();
     };
-  }, [channelId]);
+  }, [channelId, currentPubkey]);
 
   const pending = React.useMemo(
     () =>
@@ -91,9 +116,21 @@ export function useChannelUserInput(channelId: string | null) {
     );
   }, [currentPubkey, events, sentRequestIds]);
   const resolved = React.useMemo(
-    () => deriveResolvedUserInputs(events),
-    [events],
+    () =>
+      deriveResolvedUserInputs(events).filter(
+        ({ event }) =>
+          visibleRequestIds.has(event.id) &&
+          !dismissedResolutionIds.has(event.id),
+      ),
+    [dismissedResolutionIds, events, visibleRequestIds],
   );
+  const dismissResolved = React.useCallback((requestEventId: string) => {
+    setDismissedResolutionIds((current) => {
+      const next = new Set(current);
+      next.add(requestEventId);
+      return next;
+    });
+  }, []);
 
   const answer = React.useCallback(
     async (request: UserInputEvent, answers: UserInputAnswers) => {
@@ -151,6 +188,7 @@ export function useChannelUserInput(channelId: string | null) {
     errors,
     answer,
     skip,
+    dismissResolved,
     isLoading: Boolean(channelId) && identityQuery.isLoading,
   };
 }
diff --git a/desktop/src/features/channels/lib/userInput.test.mjs b/desktop/src/features/channels/lib/userInput.test.mjs
index 661b0a773e1..f51fc2f0f89 100644
--- a/desktop/src/features/channels/lib/userInput.test.mjs
+++ b/desktop/src/features/channels/lib/userInput.test.mjs
@@ -133,6 +133,10 @@ test("submit only requires required questions", () => {
   );
 });
 
+test("submit requires at least one answered question", () => {
+  assert.equal(canSubmitUserInput([{ id: "q0", required: false }], {}), false);
+});
+
 test("answer payloads preserve all wire shapes", () => {
   assert.equal(
     serializeUserInputAnswers(
diff --git a/desktop/src/features/channels/lib/userInput.ts b/desktop/src/features/channels/lib/userInput.ts
index 8d306ad35b5..e5852438efd 100644
--- a/desktop/src/features/channels/lib/userInput.ts
+++ b/desktop/src/features/channels/lib/userInput.ts
@@ -87,11 +87,18 @@ export function canSubmitUserInput(
   questions: UserInputQuestion[],
   drafts: Record<string, UserInputDraft>,
 ): boolean {
-  return questions.every((question) => {
-    if (!question.required) return true;
+  const hasAnswer = questions.some((question) => {
     const value = drafts[question.id];
     return Boolean(value?.custom.trim() || value?.selected.length);
   });
+  return (
+    hasAnswer &&
+    questions.every((question) => {
+      if (!question.required) return true;
+      const value = drafts[question.id];
+      return Boolean(value?.custom.trim() || value?.selected.length);
+    })
+  );
 }
 
 export function selectUserInputOption(
diff --git a/desktop/src/features/channels/ui/ChannelPane.tsx b/desktop/src/features/channels/ui/ChannelPane.tsx
index 5f95fcd5191..cc681a54232 100644
--- a/desktop/src/features/channels/ui/ChannelPane.tsx
+++ b/desktop/src/features/channels/ui/ChannelPane.tsx
@@ -754,6 +754,7 @@ export const ChannelPane = React.memo(function ChannelPane({
                     sendingRequestId={userInput.sendingRequestId}
                     onSkip={userInput.skip}
                     onSubmit={userInput.answer}
+                    onDismiss={userInput.dismissResolved}
                   />
                 ) : null}
                 <MessageComposer
diff --git a/desktop/src/features/channels/ui/ChannelUserInputCard.tsx b/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
index 4e5b541ace7..f301c3057ce 100644
--- a/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
+++ b/desktop/src/features/channels/ui/ChannelUserInputCard.tsx
@@ -34,6 +34,7 @@ type Props = {
     answers: Record<string, UserInputAnswerValue>,
   ) => Promise<void>;
   onSkip: (item: UserInputEvent) => Promise<void>;
+  onDismiss?: (requestEventId: string) => void;
 };
 
 export function ChannelUserInputCard({
@@ -46,6 +47,7 @@ export function ChannelUserInputCard({
   sending = false,
   onSubmit,
   onSkip,
+  onDismiss,
 }: Props) {
   const [state, setState] = React.useState<Record<string, UserInputDraft>>({});
   const ownerPubkey = profiles?.[item.event.pubkey]?.ownerPubkey ?? null;
@@ -209,6 +211,18 @@ export function ChannelUserInputCard({
           })}
         </CardContent>
       ) : null}
+      {terminal && onDismiss ? (
+        <CardFooter>
+          <Button
+            data-testid="channel-user-input-dismiss"
+            type="button"
+            variant="ghost"
+            onClick={() => onDismiss(item.event.id)}
+          >
+            Dismiss
+          </Button>
+        </CardFooter>
+      ) : null}
       {!sent && !terminal ? (
         <CardFooter className="gap-2">
           <Button
diff --git a/desktop/src/features/channels/ui/ChannelUserInputStack.tsx b/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
index 9c9ab818b54..e26d5ed3361 100644
--- a/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
+++ b/desktop/src/features/channels/ui/ChannelUserInputStack.tsx
@@ -19,6 +19,7 @@ type Props = {
   sendingRequestId: string | null;
   onSkip: (item: UserInputEvent) => Promise<void>;
   onSubmit: (item: UserInputEvent, answers: UserInputAnswers) => Promise<void>;
+  onDismiss: (requestEventId: string) => void;
 };
 
 type ResolvedUserInputEvent = UserInputEvent & {
@@ -37,6 +38,7 @@ export function ChannelUserInputStack({
   sendingRequestId,
   onSkip,
   onSubmit,
+  onDismiss,
 }: Props) {
   const sentIds = React.useMemo(
     () => new Set(sent.map(({ event }) => event.id)),
@@ -61,6 +63,7 @@ export function ChannelUserInputStack({
             sending={sendingRequestId === item.event.id}
             onSkip={onSkip}
             onSubmit={onSubmit}
+            onDismiss={onDismiss}
           />
         );
       })}
diff --git a/desktop/tests/e2e/channels.spec.ts b/desktop/tests/e2e/channels.spec.ts
index 50ff5f34083..b1edcdd5858 100644
--- a/desktop/tests/e2e/channels.spec.ts
+++ b/desktop/tests/e2e/channels.spec.ts
@@ -595,6 +595,8 @@ test("channel question card accepts an answer", async ({ page }) => {
   await expect(card).toContainText("Question answered");
   await expect(card.getByTestId("channel-user-input-submit")).toHaveCount(0);
   await expect(card.locator("input, textarea")).toHaveCount(0);
+  await card.getByTestId("channel-user-input-dismiss").click();
+  await expect(card).toHaveCount(0);
 });
 
 test("sidebar shows all channel types", async ({ page }) => {