🤖 fix heartbeat modal config defaults

Use global heartbeat defaults in the workspace modal when no workspace override exists.

Author: ibetitsmike

src/browser/components/WorkspaceHeartbeatModal/WorkspaceHeartbeatModal.test.tsx

@@ -4,6 +4,8 @@ import type { ReactNode } from "react";
 import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 import { cleanup, fireEvent, render, waitFor } from "@testing-library/react";
 import { installDom } from "../../../../tests/ui/dom";
+import * as APIModule from "@/browser/contexts/API";
+import type { APIClient, UseAPIResult } from "@/browser/contexts/API";
 import * as WorkspaceHeartbeatHookModule from "@/browser/hooks/useWorkspaceHeartbeat";
 import type { HeartbeatFormSettings } from "@/browser/hooks/useWorkspaceHeartbeat";
 import {
@@ -33,6 +35,27 @@ let saveResult = true;
 let hookError: string | null = null;
 let hookIsLoading = false;
 let hookIsSaving = false;
+let useWorkspaceHeartbeatSpy: ReturnType<
+  typeof spyOn<typeof WorkspaceHeartbeatHookModule, "useWorkspaceHeartbeat">
+>;
+
+type ConnectedUseAPIResult = Extract<UseAPIResult, { status: "connected" }>;
+interface WorkspaceHeartbeatTestAPI {
+  workspace: {
+    heartbeat: {
+      get: (input: { workspaceId: string }) => Promise<HeartbeatFormSettings | null>;
+      set: (
+        _input: unknown
+      ) => Promise<{ success: true; data: void } | { success: false; error: string }>;
+    };
+  };
+  config: {
+    getConfig: () => Promise<{
+      heartbeatDefaultIntervalMs?: number;
+      heartbeatDefaultPrompt?: string;
+    }>;
+  };
+}
 
 function createHeartbeatSettings(
   overrides: Partial<HeartbeatFormSettings> = {}
@@ -45,6 +68,16 @@ function createHeartbeatSettings(
   };
 }
 
+function createConnectedUseAPIResult(api: WorkspaceHeartbeatTestAPI): ConnectedUseAPIResult {
+  return {
+    api: api as APIClient,
+    status: "connected",
+    error: null,
+    authenticate: () => undefined,
+    retry: () => undefined,
+  };
+}
+
 const LONG_HEARTBEAT_MESSAGE = "Review pending work and summarize next steps. ".repeat(30).trim();
 
 describe("WorkspaceHeartbeatModal", () => {
@@ -57,7 +90,10 @@ describe("WorkspaceHeartbeatModal", () => {
     hookIsLoading = false;
     hookIsSaving = false;
 
-    spyOn(WorkspaceHeartbeatHookModule, "useWorkspaceHeartbeat").mockImplementation((params) => {
+    useWorkspaceHeartbeatSpy = spyOn(
+      WorkspaceHeartbeatHookModule,
+      "useWorkspaceHeartbeat"
+    ).mockImplementation((params) => {
       const workspaceId = params.workspaceId;
       return {
         settings:
@@ -136,6 +172,59 @@ describe("WorkspaceHeartbeatModal", () => {
     expect(onOpenChange).toHaveBeenCalledWith(false);
   });
 
+  test("loads global heartbeat defaults when the workspace has no saved heartbeat config", async () => {
+    useWorkspaceHeartbeatSpy.mockRestore();
+
+    const globalIntervalMs = 6 * 60_000;
+    const globalPrompt = "test";
+    const workspaceHeartbeatGetMock = mock(() => Promise.resolve(null));
+    const workspaceHeartbeatSetMock = mock(() =>
+      Promise.resolve({ success: true as const, data: undefined })
+    );
+    const getConfigMock = mock(() =>
+      Promise.resolve({
+        heartbeatDefaultIntervalMs: globalIntervalMs,
+        heartbeatDefaultPrompt: globalPrompt,
+      })
+    );
+    const mockApi: WorkspaceHeartbeatTestAPI = {
+      workspace: {
+        heartbeat: {
+          get: workspaceHeartbeatGetMock,
+          set: workspaceHeartbeatSetMock,
+        },
+      },
+      config: {
+        getConfig: getConfigMock,
+      },
+    };
+    spyOn(APIModule, "useAPI").mockImplementation(() => createConnectedUseAPIResult(mockApi));
+
+    const view = render(
+      <WorkspaceHeartbeatModal
+        workspaceId="ws-1"
+        open={true}
+        onOpenChange={mock((_open: boolean) => undefined)}
+      />
+    );
+
+    const intervalField = (await waitFor(() =>
+      view.getByLabelText("Heartbeat interval in minutes")
+    )) as HTMLInputElement;
+    expect(intervalField.value).toBe("6");
+    expect(workspaceHeartbeatGetMock).toHaveBeenCalledWith({ workspaceId: "ws-1" });
+    expect(getConfigMock).toHaveBeenCalled();
+
+    fireEvent.click(view.getByRole("switch", { name: "Enable workspace heartbeats" }));
+
+    const messageField = (await waitFor(() =>
+      view.getByLabelText("Heartbeat message")
+    )) as HTMLTextAreaElement;
+    // Global prompt is not seeded into the form to avoid persisting it as a workspace
+    // override on save. The backend handles prompt fallback at execution time.
+    expect(messageField.value).toBe("");
+  });
+
   test("saves the selected heartbeat context mode and updates helper copy", async () => {
     settingsByWorkspaceId.set(
       "ws-1",

src/browser/features/Settings/Sections/HeartbeatSection.tsx

@@ -154,8 +154,29 @@ export function HeartbeatSection() {
       return;
     }
 
+    if (!heartbeatDefaultIntervalLoadedOk && !heartbeatDefaultIntervalEditedSinceLoadRef.current) {
+      return;
+    }
+
     const parsedMinutes = parseIntervalMinutes(draftIntervalMinutes);
+
+    // Empty or invalid input: clear the global override so the hardcoded default applies.
     if (parsedMinutes == null) {
+      setDraftIntervalMinutes("");
+
+      heartbeatDefaultIntervalUpdateChainRef.current =
+        heartbeatDefaultIntervalUpdateChainRef.current
+          .catch(() => {
+            /* Best-effort. */
+          })
+          .then(() => api.config.updateHeartbeatDefaultIntervalMs({ intervalMs: null }))
+          .then(() => {
+            setHeartbeatDefaultIntervalLoadedOk(true);
+            heartbeatDefaultIntervalEditedSinceLoadRef.current = false;
+          })
+          .catch(() => {
+            /* Best-effort. */
+          });
       return;
     }
 
@@ -165,10 +186,6 @@ export function HeartbeatSection() {
       setDraftIntervalMinutes(clampedMinutesValue);
     }
 
-    if (!heartbeatDefaultIntervalLoadedOk && !heartbeatDefaultIntervalEditedSinceLoadRef.current) {
-      return;
-    }
-
     heartbeatDefaultIntervalUpdateChainRef.current = heartbeatDefaultIntervalUpdateChainRef.current
       .catch(() => {
         // Best-effort only.

src/browser/hooks/useWorkspaceHeartbeat.ts

@@ -8,6 +8,10 @@ import {
 
 type WorkspaceHeartbeatSettings = NonNullable<FrontendWorkspaceMetadata["heartbeat"]>;
 
+interface HeartbeatGlobalDefaults {
+  intervalMs: number;
+}
+
 export type HeartbeatFormSettings = WorkspaceHeartbeatSettings;
 
 interface UseWorkspaceHeartbeatParams {
@@ -22,25 +26,41 @@ export interface UseWorkspaceHeartbeatResult {
   save: (next: HeartbeatFormSettings) => Promise<boolean>;
 }
 
-function getDefaultHeartbeatSettings(): HeartbeatFormSettings {
+function normalizeHeartbeatDefaultMessage(message?: string): string | undefined {
+  const trimmedMessage = message?.trim();
+  return trimmedMessage ?? undefined;
+}
+
+function getDefaultHeartbeatSettings(
+  globalDefaults?: HeartbeatGlobalDefaults
+): HeartbeatFormSettings {
+  // Only seed the interval from global defaults. The message is intentionally left
+  // empty so saving without editing does not persist the global prompt as a
+  // workspace-level override (the backend handles prompt fallback at execution time).
   return {
     enabled: false,
-    intervalMs: HEARTBEAT_DEFAULT_INTERVAL_MS,
+    intervalMs: globalDefaults?.intervalMs ?? HEARTBEAT_DEFAULT_INTERVAL_MS,
     contextMode: HEARTBEAT_DEFAULT_CONTEXT_MODE,
   };
 }
 
 function normalizeHeartbeatSettings(
-  heartbeat: WorkspaceHeartbeatSettings | null
+  heartbeat: WorkspaceHeartbeatSettings | null,
+  globalDefaults?: HeartbeatGlobalDefaults
 ): HeartbeatFormSettings {
   if (!heartbeat) {
-    return getDefaultHeartbeatSettings();
+    return getDefaultHeartbeatSettings(globalDefaults);
   }
 
-  const trimmedMessage = heartbeat.message?.trim();
+  const message = normalizeHeartbeatDefaultMessage(heartbeat.message);
   const contextMode = heartbeat.contextMode ?? HEARTBEAT_DEFAULT_CONTEXT_MODE;
-  return trimmedMessage
-    ? { ...heartbeat, message: trimmedMessage, contextMode }
+  return message
+    ? {
+        enabled: heartbeat.enabled,
+        intervalMs: heartbeat.intervalMs,
+        contextMode,
+        message,
+      }
     : {
         enabled: heartbeat.enabled,
         intervalMs: heartbeat.intervalMs,
@@ -89,13 +109,21 @@ export function useWorkspaceHeartbeat(
     }
 
     let cancelled = false;
-    void api.workspace.heartbeat
-      .get({ workspaceId })
-      .then((result) => {
+    void Promise.all([
+      api.workspace.heartbeat.get({ workspaceId }),
+      api.config.getConfig().catch(() => null),
+    ])
+      .then(([heartbeat, config]) => {
         if (cancelled) return;
         if (currentWorkspaceIdRef.current !== workspaceId) return;
 
-        setSettings(normalizeHeartbeatSettings(result));
+        const globalDefaults = config
+          ? {
+              intervalMs: config.heartbeatDefaultIntervalMs ?? HEARTBEAT_DEFAULT_INTERVAL_MS,
+            }
+          : undefined;
+
+        setSettings(normalizeHeartbeatSettings(heartbeat, globalDefaults));
         setError(null);
         setIsLoading(false);
       })