Use targeted refresh after task responses

Co-authored-by: DanielWalnut <hetaoBackend@users.noreply.github.com>

Author: cursoragent

taskboard-electron/src/renderer/App.tsx

@@ -36,10 +36,15 @@ import {
   mergeChannelsStatus,
 } from "./channelsSettings.ts";
 import {
+  attemptTargetedTaskRefresh,
   getTaskResponseUiState,
+  markTaskResponseSubmitted,
+  mergeTargetedTaskDetail,
   prepareTaskResponse,
+  reconcileTasksWithSubmittedAnswers,
   selectTickAfterRefresh,
   startHeartbeatTickPolling,
+  taskNeedsResponse,
   type TaskResponseRefreshResult,
 } from "./operatorUi.ts";
 import { buildExecutionSteps } from "./traceSteps.ts";
@@ -836,6 +841,13 @@ async function fetchTasks() {
   return res.json();
 }
 
+async function fetchTask(id) {
+  const res = await fetch(`${API}/tasks/${id}`);
+  const payload = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(payload.error || `HTTP ${res.status}`);
+  return payload;
+}
+
 async function fetchHeartbeats() {
   const res = await fetch(`${API}/heartbeats`);
   if (!res.ok) throw new Error(`HTTP ${res.status}`);
@@ -5953,6 +5965,7 @@ export default function App() {
   const [forkingTask, setForkingTask] = useState<any>(null);
   const [editingHeartbeat, setEditingHeartbeat] = useState<any>(null);
   const heartbeatDetailId = heartbeatDetail?.id;
+  const submittedTaskAnswersRef = useRef<Record<string, string>>({});
 
   // ─── Color mode ───
   const [colorMode, setColorMode] = useState(() => localStorage.getItem("colorMode") || "system");
@@ -6008,7 +6021,14 @@ export default function App() {
         fetchSkillPatterns(),
         fetchSkills(),
       ]);
-      setTasks(taskData);
+      const reconciled = reconcileTasksWithSubmittedAnswers(
+        taskData,
+        submittedTaskAnswersRef.current,
+      );
+      submittedTaskAnswersRef.current = Object.fromEntries(
+        reconciled.pendingSubmissionIds.map((id) => [id, submittedTaskAnswersRef.current[id]]),
+      );
+      setTasks(reconciled.tasks);
       setHeartbeats(heartbeatData);
       setSkillData(skillRes);
       setSkills(skillsRes.skills || []);
@@ -6195,7 +6215,35 @@ export default function App() {
       setApiError(`Respond failed: ${e.message}`);
       throw e;
     }
-    const refreshed = await poll();
+
+    submittedTaskAnswersRef.current[String(id)] = answer;
+    setTasks((current) => current.map((task) => markTaskResponseSubmitted(task, id, answer)));
+    setDetail((current) =>
+      current?.id === id ? markTaskResponseSubmitted(current, id, answer) : current,
+    );
+
+    const refreshed = await attemptTargetedTaskRefresh({
+      load: () => fetchTask(id),
+      onTask: (refreshedTask) => {
+        const responseStillPending = taskNeedsResponse(
+          refreshedTask.question,
+          refreshedTask.answer,
+        );
+        if (responseStillPending) {
+          submittedTaskAnswersRef.current[String(id)] = answer;
+        } else {
+          delete submittedTaskAnswersRef.current[String(id)];
+        }
+        const safeTask = responseStillPending
+          ? markTaskResponseSubmitted(refreshedTask, id, answer)
+          : refreshedTask;
+        setTasks((current) => current.map((task) => (task.id === id ? safeTask : task)));
+        setDetail((current) => mergeTargetedTaskDetail(current, id, safeTask));
+      },
+      onError: () => {
+        setApiError("Answer submitted, but task details have not refreshed yet.");
+      },
+    });
     return { refreshed };
   };
 

taskboard-electron/src/renderer/operatorUi.test.ts

@@ -1,8 +1,12 @@
 import { expect, test } from "bun:test";
 
 import {
+  attemptTargetedTaskRefresh,
   getTaskResponseUiState,
+  markTaskResponseSubmitted,
+  mergeTargetedTaskDetail,
   prepareTaskResponse,
+  reconcileTasksWithSubmittedAnswers,
   selectTickAfterRefresh,
   startHeartbeatTickPolling,
   taskNeedsResponse,
@@ -37,6 +41,44 @@ test("task response UI hides once the refreshed task is answered", () => {
   expect(getTaskResponseUiState(null, null, { refreshed: false })).toBe("hidden");
 });
 
+test("successful submit remains answered after refresh failure and panel reopen", async () => {
+  const original = { id: 7, question: "Proceed?", answer: null };
+  const submitted = markTaskResponseSubmitted(original, 7, "Yes");
+  const appState = { connected: true, warning: "" };
+
+  const refreshed = await attemptTargetedTaskRefresh({
+    load: async () => {
+      throw new Error("offline");
+    },
+    onTask: () => {},
+    onError: () => {
+      appState.warning = "Answer submitted, but task details have not refreshed yet.";
+    },
+  });
+
+  expect(refreshed).toBe(false);
+  expect(appState.warning).toContain("Answer submitted");
+  expect(appState.connected).toBe(true);
+  expect(getTaskResponseUiState(submitted.question, submitted.answer, null)).toBe("hidden");
+});
+
+test("global task reconciliation cannot restore a submitted response form", () => {
+  const staleTasks = [{ id: 7, question: "Proceed?", answer: null }];
+  const reconciled = reconcileTasksWithSubmittedAnswers(staleTasks, { "7": "Yes" });
+
+  expect(reconciled.tasks[0]).toEqual({ id: 7, question: null, answer: "Yes" });
+  expect(reconciled.pendingSubmissionIds).toEqual(["7"]);
+});
+
+test("stale targeted refresh cannot overwrite a different open detail", () => {
+  const openDetail = { id: 8, question: "Other question", answer: null };
+  const staleResponse = { id: 7, question: null, answer: "Yes" };
+  const updatedResponse = { ...staleResponse, answer: "Updated" };
+
+  expect(mergeTargetedTaskDetail(openDetail, 7, staleResponse)).toBe(openDetail);
+  expect(mergeTargetedTaskDetail(staleResponse, 7, updatedResponse)).toBe(updatedResponse);
+});
+
 test("selectTickAfterRefresh preserves a selected tick still in the refreshed list", () => {
   const ticks = [{ id: 12 }, { id: 11 }, { id: 10 }];
 

taskboard-electron/src/renderer/operatorUi.ts

@@ -14,6 +14,18 @@ type HeartbeatTickPollingOptions<T> = {
   cancelScheduled?: (timer: unknown) => void;
 };
 
+type TaskWithResponse = {
+  id: TickId;
+  question?: unknown;
+  answer?: unknown;
+};
+
+type TargetedTaskRefreshOptions<T> = {
+  load: () => Promise<T>;
+  onTask: (task: T) => void;
+  onError: (error: unknown) => void;
+};
+
 export type TaskResponseRefreshResult = {
   refreshed: boolean;
 };
@@ -34,6 +46,53 @@ export function getTaskResponseUiState(
   return result.refreshed ? "submitted" : "submitted-stale";
 }
 
+export function markTaskResponseSubmitted<T extends TaskWithResponse>(
+  task: T,
+  taskId: TickId,
+  answer: string,
+): T {
+  if (task.id !== taskId) return task;
+  return { ...task, question: null, answer };
+}
+
+export function reconcileTasksWithSubmittedAnswers<T extends TaskWithResponse>(
+  tasks: T[],
+  submittedAnswers: Readonly<Record<string, string>>,
+): { tasks: T[]; pendingSubmissionIds: string[] } {
+  const pendingSubmissionIds: string[] = [];
+  const reconciled = tasks.map((task) => {
+    const key = String(task.id);
+    if (!Object.hasOwn(submittedAnswers, key) || !taskNeedsResponse(task.question, task.answer)) {
+      return task;
+    }
+    pendingSubmissionIds.push(key);
+    return markTaskResponseSubmitted(task, task.id, submittedAnswers[key]);
+  });
+  return { tasks: reconciled, pendingSubmissionIds };
+}
+
+export function mergeTargetedTaskDetail<T extends TaskWithResponse>(
+  currentDetail: T | null,
+  requestedTaskId: TickId,
+  refreshedTask: T,
+): T | null {
+  return currentDetail?.id === requestedTaskId ? refreshedTask : currentDetail;
+}
+
+export async function attemptTargetedTaskRefresh<T>({
+  load,
+  onTask,
+  onError,
+}: TargetedTaskRefreshOptions<T>): Promise<boolean> {
+  try {
+    onTask(await load());
+    return true;
+  } catch (error) {
+    onError(error);
+    return false;
+  }
+}
+
 export function prepareTaskResponse(
   value: string,
 ): { answer: string; error: null } | { answer: null; error: string } {