feat(code): warn on local task branch mismatch

adboio · adboio · commit ab9c711ecabf · 2026-04-09T11:16:15.000-07:00
diff --git a/apps/code/src/renderer/features/task-detail/components/BranchMismatchDialog.tsx b/apps/code/src/renderer/features/task-detail/components/BranchMismatchDialog.tsx
@@ -0,0 +1,122 @@
+import { GitBranch, Warning } from "@phosphor-icons/react";
+import { AlertDialog, Button, Code, Flex, Text } from "@radix-ui/themes";
+
+interface BranchMismatchDialogProps {
+  open: boolean;
+  linkedBranch: string;
+  currentBranch: string;
+  onSwitch: () => void;
+  onContinue: () => void;
+  onCancel: () => void;
+  isSwitching?: boolean;
+}
+
+function BranchLabel({ name }: { name: string }) {
+  return (
+    <Code
+      size="2"
+      variant="ghost"
+      truncate
+      style={{
+        maxWidth: "100%",
+        display: "inline-flex",
+        alignItems: "center",
+        gap: "4px",
+      }}
+    >
+      <GitBranch size={12} style={{ flexShrink: 0 }} />
+      <span
+        style={{
+          overflow: "hidden",
+          textOverflow: "ellipsis",
+          whiteSpace: "nowrap",
+        }}
+      >
+        {name}
+      </span>
+    </Code>
+  );
+}
+
+export function BranchMismatchDialog({
+  open,
+  linkedBranch,
+  currentBranch,
+  onSwitch,
+  onContinue,
+  onCancel,
+  isSwitching,
+}: BranchMismatchDialogProps) {
+  return (
+    <AlertDialog.Root open={open}>
+      <AlertDialog.Content maxWidth="420px" size="2">
+        <AlertDialog.Title size="3">
+          <Flex align="center" gap="2">
+            <Warning size={18} weight="fill" color="var(--orange-9)" />
+            Wrong branch
+          </Flex>
+        </AlertDialog.Title>
+        <AlertDialog.Description size="2">
+          This task is linked to a different branch than the one you're
+          currently on. The agent will make changes on the current branch.
+        </AlertDialog.Description>
+        <Flex direction="column" gap="1" mt="3" style={{ minWidth: 0 }}>
+          <Flex align="center" gap="2" style={{ minWidth: 0 }}>
+            <Text
+              size="1"
+              color="gray"
+              style={{ flexShrink: 0, width: "64px" }}
+            >
+              Linked
+            </Text>
+            <BranchLabel name={linkedBranch} />
+          </Flex>
+          <Flex align="center" gap="2" style={{ minWidth: 0 }}>
+            <Text
+              size="1"
+              color="gray"
+              style={{ flexShrink: 0, width: "64px" }}
+            >
+              Current
+            </Text>
+            <BranchLabel name={currentBranch} />
+          </Flex>
+        </Flex>
+
+        <Flex justify="end" gap="2" mt="4">
+          <AlertDialog.Cancel>
+            <Button
+              variant="soft"
+              color="gray"
+              size="1"
+              onClick={onCancel}
+              disabled={isSwitching}
+            >
+              Cancel
+            </Button>
+          </AlertDialog.Cancel>
+
+          <Button
+            variant="soft"
+            size="1"
+            onClick={onContinue}
+            disabled={isSwitching}
+          >
+            Continue anyway
+          </Button>
+
+          <AlertDialog.Action>
+            <Button
+              variant="solid"
+              size="1"
+              onClick={onSwitch}
+              loading={isSwitching}
+            >
+              Switch branch
+            </Button>
+          </AlertDialog.Action>
+        </Flex>
+      </AlertDialog.Content>
+    </AlertDialog.Root>
+  );
+}
diff --git a/apps/code/src/renderer/features/task-detail/components/TaskLogsPanel.tsx b/apps/code/src/renderer/features/task-detail/components/TaskLogsPanel.tsx
@@ -7,6 +7,7 @@ import {
 } from "@features/git-interaction/hooks/useGitQueries";
 import { computeDiffStats } from "@features/git-interaction/utils/diffStats";
 import { useDraftStore } from "@features/message-editor/stores/draftStore";
+import type { EditorContent } from "@features/message-editor/utils/content";
 import { ProvisioningView } from "@features/provisioning/components/ProvisioningView";
 import { useProvisioningStore } from "@features/provisioning/stores/provisioningStore";
 import { SessionView } from "@features/sessions/components/SessionView";
@@ -15,15 +16,19 @@ import { useSessionConnection } from "@features/sessions/hooks/useSessionConnect
 import { useSessionViewState } from "@features/sessions/hooks/useSessionViewState";
 import { useRestoreTask } from "@features/suspension/hooks/useRestoreTask";
 import { useSuspendedTaskIds } from "@features/suspension/hooks/useSuspendedTaskIds";
+import { BranchMismatchDialog } from "@features/task-detail/components/BranchMismatchDialog";
 import { WorkspaceSetupPrompt } from "@features/task-detail/components/WorkspaceSetupPrompt";
+import { useBranchMismatchGuard } from "@features/workspace/hooks/useBranchMismatch";
 import {
   useCreateWorkspace,
   useWorkspaceLoaded,
 } from "@features/workspace/hooks/useWorkspace";
 import { Box, Flex } from "@radix-ui/themes";
+import { trpcClient } from "@renderer/trpc/client";
 import type { Task } from "@shared/types";
+import { logger } from "@utils/logger";
 import { getTaskRepository } from "@utils/repository";
-import { useCallback, useEffect, useMemo } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 
 interface TaskLogsPanelProps {
   taskId: string;
@@ -47,7 +52,7 @@ export function TaskLogsPanel({ taskId, task, hideInput }: TaskLogsPanelProps) {
 
   const isProvisioning = useProvisioningStore((s) => s.activeTasks.has(taskId));
 
-  const { requestFocus } = useDraftStore((s) => s.actions);
+  const { requestFocus, setPendingContent } = useDraftStore((s) => s.actions);
 
   const {
     session,
@@ -74,13 +79,68 @@ export function TaskLogsPanel({ taskId, task, hideInput }: TaskLogsPanelProps) {
   });
 
   const {
-    handleSendPrompt,
+    handleSendPrompt: rawSendPrompt,
     handleCancelPrompt,
     handleRetry,
     handleNewSession,
     handleBashCommand,
   } = useSessionCallbacks({ taskId, task, session, repoPath });
 
+  // Branch mismatch guard
+  const { shouldWarn, linkedBranch, currentBranch, dismissWarning } =
+    useBranchMismatchGuard(taskId);
+  const [pendingMessage, setPendingMessage] = useState<string | null>(null);
+  const [isSwitchingBranch, setIsSwitchingBranch] = useState(false);
+
+  const handleSendPrompt = useCallback(
+    (text: string) => {
+      if (shouldWarn) {
+        setPendingMessage(text);
+        return;
+      }
+      rawSendPrompt(text);
+    },
+    [shouldWarn, rawSendPrompt],
+  );
+
+  const handleMismatchSwitch = useCallback(async () => {
+    if (!linkedBranch || !repoPath) return;
+    setIsSwitchingBranch(true);
+    try {
+      await trpcClient.git.checkoutBranch.mutate({
+        directoryPath: repoPath,
+        branchName: linkedBranch,
+      });
+      dismissWarning();
+      if (pendingMessage) {
+        rawSendPrompt(pendingMessage);
+      }
+    } catch (error) {
+      logger.scope("task-logs-panel").error("Failed to switch branch", error);
+    } finally {
+      setIsSwitchingBranch(false);
+      setPendingMessage(null);
+    }
+  }, [linkedBranch, repoPath, dismissWarning, pendingMessage, rawSendPrompt]);
+
+  const handleMismatchContinue = useCallback(() => {
+    dismissWarning();
+    if (pendingMessage) {
+      rawSendPrompt(pendingMessage);
+    }
+    setPendingMessage(null);
+  }, [dismissWarning, pendingMessage, rawSendPrompt]);
+
+  const handleMismatchCancel = useCallback(() => {
+    if (pendingMessage) {
+      const content: EditorContent = {
+        segments: [{ type: "text", text: pendingMessage }],
+      };
+      setPendingContent(taskId, content);
+    }
+    setPendingMessage(null);
+  }, [pendingMessage, setPendingContent, taskId]);
+
   const cloudOutput = session?.cloudOutput ?? null;
   const prUrl =
     isCloud && cloudOutput?.pr_url ? (cloudOutput.pr_url as string) : null;
@@ -165,6 +225,18 @@ export function TaskLogsPanel({ taskId, task, hideInput }: TaskLogsPanelProps) {
           </ErrorBoundary>
         </Box>
       </Flex>
+
+      {linkedBranch && currentBranch && (
+        <BranchMismatchDialog
+          open={pendingMessage !== null}
+          linkedBranch={linkedBranch}
+          currentBranch={currentBranch}
+          onSwitch={handleMismatchSwitch}
+          onContinue={handleMismatchContinue}
+          onCancel={handleMismatchCancel}
+          isSwitching={isSwitchingBranch}
+        />
+      )}
     </BackgroundWrapper>
   );
 }
diff --git a/apps/code/src/renderer/features/workspace/hooks/useBranchMismatch.ts b/apps/code/src/renderer/features/workspace/hooks/useBranchMismatch.ts
@@ -0,0 +1,66 @@
+import { useCallback, useEffect, useRef } from "react";
+import { create } from "zustand";
+import { useWorkspace } from "./useWorkspace";
+
+interface BranchWarningState {
+  /** Per-task flag: true if the user dismissed the branch mismatch warning. */
+  dismissed: Record<string, boolean>;
+  dismiss: (taskId: string) => void;
+  reset: (taskId: string) => void;
+}
+
+export const useBranchWarningStore = create<BranchWarningState>()((set) => ({
+  dismissed: {},
+  dismiss: (taskId) =>
+    set((state) => ({
+      dismissed: { ...state.dismissed, [taskId]: true },
+    })),
+  reset: (taskId) =>
+    set((state) => ({
+      dismissed: { ...state.dismissed, [taskId]: false },
+    })),
+}));
+
+export function useBranchMismatch(taskId: string) {
+  const workspace = useWorkspace(taskId);
+  const linkedBranch = workspace?.linkedBranch ?? null;
+  const currentBranch = workspace?.branchName ?? null;
+  const isMismatch =
+    !!linkedBranch && !!currentBranch && linkedBranch !== currentBranch;
+  const isLinked = !!linkedBranch;
+
+  const branchWarningDismissed = useBranchWarningStore(
+    (s) => s.dismissed[taskId] ?? false,
+  );
+  const reset = useBranchWarningStore((s) => s.reset);
+
+  // Reset dismissed state when currentBranch changes
+  const prevBranchRef = useRef(currentBranch);
+  useEffect(() => {
+    if (prevBranchRef.current !== currentBranch) {
+      prevBranchRef.current = currentBranch;
+      reset(taskId);
+    }
+  }, [currentBranch, taskId, reset]);
+
+  const shouldWarn = isMismatch && !branchWarningDismissed;
+
+  return {
+    linkedBranch,
+    currentBranch,
+    isMismatch,
+    isLinked,
+    shouldWarn,
+  };
+}
+
+export function useBranchMismatchGuard(taskId: string) {
+  const { shouldWarn, linkedBranch, currentBranch } = useBranchMismatch(taskId);
+  const dismiss = useBranchWarningStore((s) => s.dismiss);
+
+  const dismissWarning = useCallback(() => {
+    dismiss(taskId);
+  }, [dismiss, taskId]);
+
+  return { shouldWarn, linkedBranch, currentBranch, dismissWarning };
+}
