canopycms 0.0.67 → 0.0.68-int.101

package/dist/editor/hooks/create-branch-request.d.ts

@@ -0,0 +1,20 @@
+import type { BranchListItem, CreateBranchBody } from '../../api/branch.js';
+import { type CanopyApiClient } from '../../api/client.js';
+/** @internal Exported for tests. Past the 60 s a Lambda behind CloudFront gets, so its 504 lands first. */
+export declare const CREATE_BRANCH_DEADLINE_MS = 90000;
+/** @internal Exported for tests. */
+export declare const CREATE_TIMED_OUT_MESSAGE = "Creating the branch didn't finish (the server timed out). It's safe to try again.";
+export type CreateBranchOutcome = {
+    kind: 'created';
+    branch: BranchListItem | undefined;
+} | {
+    kind: 'failed';
+    message: string;
+};
+/**
+ * Create a branch. Past the deadline, after an error page from in front of the API, or after a
+ * busy 503 the branch may exist anyway, so the branch list decides; retrying is safe because a
+ * create publishes the whole branch or nothing. `userId` is the current user, the only creator
+ * whose listed branch can be this create's result.
+ */
+export declare function requestBranchCreate(apiClient: Pick<CanopyApiClient, 'branches'>, body: CreateBranchBody, userId: string | undefined, deadlineMs?: number): Promise<CreateBranchOutcome>;

package/dist/editor/hooks/create-branch-request.js

@@ -0,0 +1,52 @@
+import { isCreatorsRecentBranch } from '../../api/branch-create-window.js';
+import { isNonApiResponse } from '../../api/client.js';
+import { sanitizeBranchName } from '../../paths/branch-name.js';
+/** @internal Exported for tests. Past the 60 s a Lambda behind CloudFront gets, so its 504 lands first. */
+export const CREATE_BRANCH_DEADLINE_MS = 90_000;
+/** @internal Exported for tests. */
+export const CREATE_TIMED_OUT_MESSAGE = "Creating the branch didn't finish (the server timed out). It's safe to try again.";
+const DEADLINE = Symbol('deadline');
+/**
+ * Create a branch. Past the deadline, after an error page from in front of the API, or after a
+ * busy 503 the branch may exist anyway, so the branch list decides; retrying is safe because a
+ * create publishes the whole branch or nothing. `userId` is the current user, the only creator
+ * whose listed branch can be this create's result.
+ */
+export async function requestBranchCreate(apiClient, body, userId, deadlineMs = CREATE_BRANCH_DEADLINE_MS) {
+    let timer;
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(DEADLINE), deadlineMs);
+    });
+    const result = await Promise.race([apiClient.branches.create(body), deadline]).finally(() => clearTimeout(timer));
+    if (result === DEADLINE)
+        return settle(apiClient, body.branch, userId, CREATE_TIMED_OUT_MESSAGE);
+    if (result.ok)
+        return { kind: 'created', branch: result.data?.branch };
+    if (isNonApiResponse(result))
+        return settle(apiClient, body.branch, userId, CREATE_TIMED_OUT_MESSAGE);
+    const message = result.error || 'Failed to create branch';
+    return result.status === 503
+        ? settle(apiClient, body.branch, userId, message)
+        : { kind: 'failed', message };
+}
+/** A same-named branch the server would not answer this create with is a name conflict. */
+async function settle(apiClient, requested, userId, message) {
+    const listed = await findListedBranch(apiClient, requested);
+    if (!listed)
+        return { kind: 'failed', message };
+    if (isCreatorsRecentBranch(listed, userId))
+        return { kind: 'created', branch: listed };
+    return { kind: 'failed', message: `A branch named "${listed.name}" already exists` };
+}
+async function findListedBranch(apiClient, requested) {
+    const name = sanitizeBranchName(requested);
+    try {
+        const listing = await apiClient.branches.list();
+        if (!listing.ok)
+            return undefined;
+        return listing.data?.branches.find((branch) => sanitizeBranchName(branch.name) === name);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/editor/hooks/useBranchActions.d.ts

@@ -1,17 +1,28 @@
+import type { BranchListItem } from '../../api/branch.js';
+import type { UnsavedSummary } from './useDraftManager.js';
 export interface UseBranchActionsOptions {
     branchName: string;
     setBranchName: (name: string) => void;
-    isAnyDirty: () => boolean;
+    /** From useDraftManager's `resolveUnsaved`: what a branch-level action would leave behind. */
+    getUnsaved: () => Promise<UnsavedSummary>;
     onReloadBranches: () => Promise<void>;
+    /** Receives the branch the server just created, so it can be shown before any listing includes it. */
+    onBranchCreated: (branch: BranchListItem) => void;
     onBranchSwitch?: (branch: string) => void;
+    /** The current user; a create the server never answered adopts only a listed branch they made. */
+    userId?: string;
 }
 export interface UseBranchActionsReturn {
     handleBranchChange: (branch: string | null) => Promise<void>;
+    /** True when nothing is unsaved or the user accepted the warning. Run before any in-flight UI. */
+    confirmCreate: () => Promise<boolean>;
     handleCreateBranch: (branch: {
         name: string;
         title?: string;
         description?: string;
-    }) => Promise<void>;
+    }) => Promise<boolean>;
+    /** True while the unsaved-changes confirm is on screen. */
+    confirmOpen: boolean;
 }
 /**
  * Custom hook for branch navigation actions with dirty check support.

package/dist/editor/hooks/useBranchActions.js

@@ -1,13 +1,25 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
 import { modals } from '@mantine/modals';
 import { notifications } from '@mantine/notifications';
 import { Text } from '@mantine/core';
 import { useApiClient } from '../context/index.js';
+import { requestBranchCreate } from './create-branch-request.js';
+const MAX_LISTED_LABELS = 5;
+/** "Unsaved changes in: A, B." */
+const describeUnsaved = ({ labels }) => {
+    if (labels.length === 0)
+        return 'You have unsaved changes.';
+    const shown = labels.slice(0, MAX_LISTED_LABELS).join(', ');
+    const rest = labels.length - MAX_LISTED_LABELS;
+    return `Unsaved changes in: ${shown}${rest > 0 ? ` and ${rest} more` : ''}.`;
+};
 /**
  * Custom hook for branch navigation actions with dirty check support.
  */
 export function useBranchActions(options) {
     const apiClient = useApiClient();
+    const [confirmOpen, setConfirmOpen] = useState(false);
     const performBranchSwitch = (next) => {
         options.setBranchName(next);
         if (typeof window !== 'undefined') {
@@ -17,62 +29,81 @@ export function useBranchActions(options) {
         }
         options.onBranchSwitch?.(next);
     };
-    const confirmIfDirty = async (message) => {
-        if (!options.isAnyDirty())
+    const confirmIfDirty = async (question) => {
+        const unsaved = await options.getUnsaved();
+        if (unsaved.count === 0)
             return true;
         return new Promise((resolve) => {
+            const settle = (value) => {
+                // Mantine calls onClose and onCancel from its modals reducer, which runs while
+                // ModalsProvider renders, so a setState here must be deferred; resolving needs no deferral.
+                queueMicrotask(() => setConfirmOpen(false));
+                resolve(value);
+            };
+            setConfirmOpen(true);
             modals.openConfirmModal({
                 title: 'Unsaved Changes',
-                children: _jsx(Text, { size: "sm", children: message }),
+                // Drafts are stored per branch, so leaving does not lose them.
+                children: (_jsxs(Text, { size: "sm", children: [describeUnsaved(unsaved), " Your drafts stay on \u201C", options.branchName, "\u201D and come back when you return. ", question] })),
                 labels: { confirm: 'Continue Anyway', cancel: 'Cancel' },
                 confirmProps: { color: 'red' },
-                onCancel: () => resolve(false),
-                onConfirm: () => resolve(true),
+                onCancel: () => settle(false),
+                onConfirm: () => settle(true),
+                // Escape and overlay dismissals fire only onClose. Mantine also calls it
+                // right after onConfirm, which is harmless: a promise settles once.
+                onClose: () => settle(false),
             });
         });
     };
     const handleBranchChange = async (next) => {
         if (!next || next === options.branchName)
             return;
-        const confirmed = await confirmIfDirty('You have unsaved changes. Switch branches anyway?');
+        const confirmed = await confirmIfDirty('Switch branches anyway?');
         if (!confirmed)
             throw new Error('User cancelled branch switch');
         performBranchSwitch(next);
     };
+    const confirmCreate = () => confirmIfDirty('Create the new branch anyway?');
+    /** Resolves true when the branch was created and switched to, false when it was not. */
     const handleCreateBranch = async (branch) => {
-        const confirmed = await confirmIfDirty('Create new branch without saving changes?');
-        if (!confirmed)
-            return;
         try {
-            const result = await apiClient.branches.create({
+            const outcome = await requestBranchCreate(apiClient, {
                 branch: branch.name,
                 title: branch.title,
                 description: branch.description,
-            });
-            if (!result.ok) {
-                throw new Error(result.error || 'Failed to create branch');
+            }, options.userId);
+            if (outcome.kind === 'failed') {
+                throw new Error(outcome.message);
             }
+            const created = outcome.branch;
+            if (created)
+                options.onBranchCreated(created);
             // The server sanitizes the branch name (e.g. "feature/x" -> "feature-x")
             // before persisting it. Adopt the canonical name from the response so
             // the client doesn't end up stuck on a name the server never saved.
-            const createdName = result.data?.branch?.name ?? branch.name;
+            const createdName = created?.name ?? branch.name;
             notifications.show({
                 message: createdName === branch.name
                     ? `Branch "${createdName}" created`
                     : `Branch "${createdName}" created (renamed from "${branch.name}")`,
                 color: 'green',
             });
-            await options.onReloadBranches();
-            // Switch to new branch (already confirmed dirty check)
             performBranchSwitch(createdName);
+            // Not awaited: a listing can lag the create, and the switch must not wait
+            // on it. loadBranches reports its own failures and never rejects.
+            void options.onReloadBranches();
+            return true;
         }
         catch (err) {
             const message = err instanceof Error ? err.message : 'Failed to create branch';
             notifications.show({ message, color: 'red' });
+            return false;
         }
     };
     return {
         handleBranchChange,
+        confirmCreate,
         handleCreateBranch,
+        confirmOpen,
     };
 }

package/dist/editor/hooks/useBranchManager.d.ts

@@ -2,6 +2,25 @@ import type { ConflictStatus, PullRequestState, SyncStatus } from '../../types.j
 import type { OperatingMode } from '../../operating-mode/index.js';
 import type { CommentThread } from '../../comment-store.js';
 import type { BranchListItem } from '../../api/branch.js';
+/** What the withdraw and delete dialogs say about the branch's pull request. */
+type BranchPullRequest = Pick<BranchListItem, 'pullRequestNumber' | 'pullRequestState'>;
+/**
+ * The withdraw dialog's pull-request bullet, matching what api/branch-withdraw.ts does: an open
+ * PR becomes a draft; a closed one is left alone and its number dropped from the branch, so a
+ * resubmit opens a new one. A merged PR archives its branch, which withdraw refuses, so that
+ * bullet is only seen on a listing that lags.
+ * @internal Exported for tests.
+ */
+export declare function withdrawPullRequestBullet(pr: BranchPullRequest): string | undefined;
+/**
+ * How long a branch this session created stays overlaid on listings. Each warm
+ * server container caches the shared filesystem separately, so for its
+ * attribute/dentry cache window (~60s, see docs/concurrency.md window A) a
+ * listing can lack the branch even after another container's listing showed
+ * it. Twice that absorbs request latency; past it, listings alone decide.
+ * @internal Exported only for the test that pins it.
+ */
+export declare const CREATED_BRANCH_GRACE_MS = 120000;
 interface BranchSummary {
     name: string;
     status: string;
@@ -58,6 +77,8 @@ export interface UseBranchManagerReturn {
     branches: BranchListItem[];
     branchSummaries: BranchSummary[];
     currentBranch: BranchListItem | undefined;
+    /** Shows a branch the server just created before any listing includes it. */
+    addCreatedBranch: (branch: BranchListItem) => void;
     handleSubmit: (branchName: string) => Promise<void>;
     handleWithdraw: (branchName: string) => Promise<void>;
     handleRequestChanges: (branchName: string) => Promise<void>;

package/dist/editor/hooks/useBranchManager.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useSWRConfig } from 'swr';
 import { Text } from '@mantine/core';
 import { modals } from '@mantine/modals';
@@ -58,30 +58,57 @@ const showSubmitConfirmation = (branchName, onConfirm, onDismiss) => {
         ...confirmModalHandlers(onConfirm, onDismiss),
     });
 };
-const showWithdrawConfirmation = (branchName, onConfirm, onDismiss) => {
+/**
+ * The withdraw dialog's pull-request bullet, matching what api/branch-withdraw.ts does: an open
+ * PR becomes a draft; a closed one is left alone and its number dropped from the branch, so a
+ * resubmit opens a new one. A merged PR archives its branch, which withdraw refuses, so that
+ * bullet is only seen on a listing that lags.
+ * @internal Exported for tests.
+ */
+export function withdrawPullRequestBullet(pr) {
+    if (!pr.pullRequestNumber)
+        return undefined;
+    const label = `pull request #${pr.pullRequestNumber}`;
+    if (pr.pullRequestState === 'closed') {
+        return `Leave the closed ${label} as it is; submitting again opens a new one`;
+    }
+    if (pr.pullRequestState === 'merged')
+        return `Leave the merged ${label} as it is`;
+    return `Convert ${label} to a draft`;
+}
+const showWithdrawConfirmation = (branchName, pr, onConfirm, onDismiss) => {
+    const bullets = [
+        withdrawPullRequestBullet(pr),
+        'Change the branch status back to "editing"',
+        'Remove from review queue',
+    ].filter((b) => b !== undefined);
     modals.openConfirmModal({
         title: 'Withdraw Branch from Review',
-        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Are you sure you want to withdraw "${branchName}" from review?\n\nThis will:\n• Convert the pull request to a draft\n• Change the branch status back to "editing"\n• Remove from review queue` })),
+        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Are you sure you want to withdraw "${branchName}" from review?\n\nThis will:\n${bullets.map((b) => `• ${b}`).join('\n')}` })),
         labels: { confirm: 'Withdraw Branch', cancel: 'Cancel' },
         confirmProps: { color: 'orange' },
         ...confirmModalHandlers(onConfirm, onDismiss),
     });
 };
 /**
- * Unlike submit/withdraw (both reversible), delete is irreversible -- it
- * unlinks branch.json, removes the clone, and removes the branch head from
- * the local git mirror. Before this, `handleDelete` below called
- * `apiClient.branches.delete` immediately on click with no confirmation
- * anywhere in the chain (BranchManager.tsx's delete button calls `onDelete`
- * directly), while submit and withdraw -- both reversible -- each went
- * through this same `modals.openConfirmModal` pattern. This closes that gap;
- * `color: 'red'` marks it as the destructive one, matching the button's own
- * color in BranchManager.tsx.
+ * Delete is the one irreversible branch action: it unlinks branch.json and removes the clone,
+ * the local mirror's head and, for a branch with a PR, the GitHub branch. BranchManager.tsx's
+ * delete button calls `onDelete` directly, so this dialog is the only confirmation; `color:
+ * 'red'` matches that button.
  */
-const showDeleteConfirmation = (branchName, onConfirm, onDismiss) => {
+const showDeleteConfirmation = (branchName, pr, onConfirm, onDismiss) => {
+    // The server deletes the GitHub branch only for a branch with a PR (api/github-sync.ts's
+    // syncDeleteRemoteBranch); GitHub closes a PR whose branch is deleted.
+    const bullets = [
+        'Permanently remove the branch and its clone',
+        pr.pullRequestNumber
+            ? `Delete its branch on GitHub too, which closes pull request #${pr.pullRequestNumber} if it is still open`
+            : undefined,
+        'Discard any unsaved or unmerged changes',
+    ].filter((b) => b !== undefined);
     modals.openConfirmModal({
         title: 'Delete Branch',
-        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Are you sure you want to delete "${branchName}"?\n\nThis will:\n• Permanently remove the branch and its clone\n• Discard any unsaved or unmerged changes\n\nThis cannot be undone.` })),
+        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Are you sure you want to delete "${branchName}"?\n\nThis will:\n${bullets.map((b) => `• ${b}`).join('\n')}\n\nThis cannot be undone.` })),
         labels: { confirm: 'Delete Branch', cancel: 'Cancel' },
         // data-testid is load-bearing, not decoration: the e2e helper
         // (apps/test-app/e2e/fixtures/branch-page.ts's deleteBranch) already
@@ -92,6 +119,46 @@ const showDeleteConfirmation = (branchName, onConfirm, onDismiss) => {
         ...confirmModalHandlers(onConfirm, onDismiss),
     });
 };
+/**
+ * How long a branch this session created stays overlaid on listings. Each warm
+ * server container caches the shared filesystem separately, so for its
+ * attribute/dentry cache window (~60s, see docs/concurrency.md window A) a
+ * listing can lack the branch even after another container's listing showed
+ * it. Twice that absorbs request latency; past it, listings alone decide.
+ * @internal Exported only for the test that pins it.
+ */
+export const CREATED_BRANCH_GRACE_MS = 120_000;
+/** The server listing plus any pending branches it lacks; the server's copy always wins. */
+function mergePendingBranches(listed, pending) {
+    const listedNames = new Set(listed.map((b) => b.name));
+    const missing = pending.filter((p) => !listedNames.has(p.branch.name));
+    return missing.length === 0 ? listed : [...listed, ...missing.map((p) => p.branch)];
+}
+/**
+ * Applies one received listing to the pending branches: drops those it arrived
+ * past the grace window for, and takes the listing's copy of the rest. Written
+ * so a listing with no arrival time (NaN) drops nothing.
+ */
+function reconcilePendingBranches(pending, listed, receivedAt) {
+    const listedByName = new Map(listed.map((b) => [b.name, b]));
+    let changed = false;
+    const next = [];
+    for (const p of pending) {
+        if (receivedAt - p.addedAt > CREATED_BRANCH_GRACE_MS) {
+            changed = true;
+            continue;
+        }
+        const listedCopy = listedByName.get(p.branch.name);
+        if (listedCopy && listedCopy !== p.branch) {
+            changed = true;
+            next.push({ branch: listedCopy, addedAt: p.addedAt });
+        }
+        else {
+            next.push(p);
+        }
+    }
+    return changed ? next : pending;
+}
 /**
  * Custom hook for managing git branches.
  */
@@ -100,7 +167,40 @@ export function useBranchManager(options) {
     const { mutate: globalMutate } = useSWRConfig();
     const [branchName, setBranchName] = useState(options.initialBranch);
     const { data: branchesData, error: branchesError, isValidating: branchesIsValidating, } = useBranchesData(apiClient);
-    const branches = useMemo(() => branchesData?.branches ?? [], [branchesData]);
+    const [pendingBranches, setPendingBranches] = useState([]);
+    const branches = useMemo(() => mergePendingBranches(branchesData?.branches ?? [], pendingBranches), [branchesData, pendingBranches]);
+    const addCreatedBranch = useCallback((branch) => {
+        setPendingBranches((prev) => [
+            ...prev.filter((p) => p.branch.name !== branch.name),
+            { branch, addedAt: Date.now() },
+        ]);
+    }, []);
+    const forgetCreatedBranch = (name) => {
+        setPendingBranches((prev) => {
+            const kept = prev.filter((p) => p.branch.name !== name);
+            return kept.length === prev.length ? prev : kept;
+        });
+    };
+    // After a workflow action, a pending branch's overlaid copy is stale. The
+    // server's returned copy replaces it, so a listing that still lacks the
+    // branch shows its new status instead of hiding it; without one, forgetting
+    // it fails closed rather than showing the pre-action state.
+    const updateCreatedBranch = (name, branch) => {
+        if (!branch) {
+            forgetCreatedBranch(name);
+            return;
+        }
+        setPendingBranches((prev) => prev.some((p) => p.branch.name === name)
+            ? prev.map((p) => (p.branch.name === name ? { ...p, branch } : p))
+            : prev);
+    };
+    // Each received listing is a new `branchesData` (see `BranchesData.receivedAt`);
+    // the grace window is measured to its arrival.
+    useEffect(() => {
+        if (!branchesData)
+            return;
+        setPendingBranches((prev) => reconcilePendingBranches(prev, branchesData.branches, branchesData.receivedAt));
+    }, [branchesData]);
     // Adopt the server's default branch once data arrives, if nothing pinned one.
     useEffect(() => {
         if (!branchName && branchesData?.defaultBranch) {
@@ -190,11 +290,13 @@ export function useBranchManager(options) {
     // bound hook (and anything else reading BRANCHES_KEY) picks it up.
     // Side effects (default-branch adoption, error/success notifications) are
     // driven by the effects above, which react to that same cache write.
-    const loadBranches = async () => {
+    // Resolves to the fresh listing, or undefined when the fetch failed.
+    const reloadBranches = async () => {
         options.setBusy(true);
         try {
             const fresh = await fetchBranches(apiClient);
             await globalMutate(BRANCHES_KEY, fresh, { revalidate: false });
+            return fresh;
         }
         catch (err) {
             console.error(err);
@@ -205,14 +307,61 @@ export function useBranchManager(options) {
                 color: 'red',
                 autoClose: false,
             });
+            return undefined;
         }
         finally {
             options.setBusy(false);
         }
     };
-    const handleSubmit = async (branchNameToSubmit) => {
-        return new Promise((resolve, reject) => {
+    const loadBranches = async () => {
+        await reloadBranches();
+    };
+    // The confirm dialogs' handlers run long after the render that opened them, so they read
+    // these at confirm time rather than from that render's closure.
+    const latest = useRef({ branchName, branches, branchesData });
+    latest.current = { branchName, branches, branchesData };
+    // A legacy deep link can carry the raw form of a listed name; the actions key, look up and
+    // send the listed name, resolved the way `currentBranch` resolves it.
+    const listedName = (name) => latest.current.branches.some((b) => b.name === name) ? name : sanitizeBranchName(name);
+    const pullRequestOf = (name) => {
+        const b = latest.current.branches.find((x) => x.name === name);
+        return { pullRequestNumber: b?.pullRequestNumber, pullRequestState: b?.pullRequestState };
+    };
+    // Keys of the actions whose confirm is open or whose work is in flight.
+    const actionsInFlight = useRef(new Set());
+    /**
+     * Runs `run` unless the same action on the same branch already has its confirm open or its
+     * work in flight; then this request opens nothing and resolves at once. Mantine closes only
+     * the confirm that was confirmed, so a second one opened by a repeated click would stay up
+     * after the action succeeded.
+     */
+    const singleFlight = async (action, branch, run) => {
+        const key = JSON.stringify([action, branch]);
+        if (actionsInFlight.current.has(key))
+            return;
+        actionsInFlight.current.add(key);
+        try {
+            await run();
+        }
+        finally {
+            actionsInFlight.current.delete(key);
+        }
+    };
+    const handleSubmit = (requested) => {
+        const branchNameToSubmit = listedName(requested);
+        return singleFlight('submit', branchNameToSubmit, () => new Promise((resolve, reject) => {
             showSubmitConfirmation(branchNameToSubmit, async () => {
+                // A listing that arrived while the dialog was open may show the branch already
+                // submitted; submitting it again would only fail.
+                const listed = latest.current.branches.find((b) => b.name === branchNameToSubmit);
+                if (listed?.status === 'submitted') {
+                    notifications.show({
+                        message: 'Branch is already submitted for review',
+                        color: 'blue',
+                    });
+                    resolve();
+                    return;
+                }
                 options.setBusy(true);
                 try {
                     const result = await apiClient.workflow.submit({
@@ -225,6 +374,7 @@ export function useBranchManager(options) {
                         message: 'Branch submitted for review',
                         color: 'green',
                     });
+                    updateCreatedBranch(branchNameToSubmit, result.data?.branch);
                     await loadBranches();
                     resolve();
                 }
@@ -237,17 +387,15 @@ export function useBranchManager(options) {
                     options.setBusy(false);
                 }
             }, 
-            // Dismissal is not an error. Rejecting here meant clicking Cancel
-            // logged a console error at the only call site (Editor.tsx catches
-            // these into console.error), which is both noise and a trip hazard
-            // for the CI=1 stray-console gate. Settled once, by onCancel OR
-            // onClose, so an Escape/overlay dismissal can't leave this pending.
+            // Dismissal is not an error: the call sites log rejections to the console. Settled
+            // once, by onCancel OR onClose, so an Escape/overlay dismissal can't leave this pending.
             () => resolve());
-        });
+        }));
     };
-    const handleWithdraw = async (branchNameToWithdraw) => {
-        return new Promise((resolve, reject) => {
-            showWithdrawConfirmation(branchNameToWithdraw, async () => {
+    const handleWithdraw = (requested) => {
+        const branchNameToWithdraw = listedName(requested);
+        return singleFlight('withdraw', branchNameToWithdraw, () => new Promise((resolve, reject) => {
+            showWithdrawConfirmation(branchNameToWithdraw, pullRequestOf(branchNameToWithdraw), async () => {
                 options.setBusy(true);
                 try {
                     const result = await apiClient.workflow.withdraw({
@@ -257,6 +405,7 @@ export function useBranchManager(options) {
                         throw new Error(result.error || 'Failed to withdraw branch');
                     }
                     notifications.show({ message: 'Branch withdrawn', color: 'blue' });
+                    updateCreatedBranch(branchNameToWithdraw, result.data?.branch);
                     await loadBranches();
                     resolve();
                 }
@@ -269,7 +418,7 @@ export function useBranchManager(options) {
                     options.setBusy(false);
                 }
             }, () => resolve());
-        });
+        }));
     };
     const handleRequestChanges = async (branchNameForChanges) => {
         options.setBusy(true);
@@ -279,6 +428,7 @@ export function useBranchManager(options) {
                 throw new Error(result.error || 'Failed to request changes');
             }
             notifications.show({ message: 'Changes requested', color: 'orange' });
+            updateCreatedBranch(branchNameForChanges, result.data?.branch);
             await loadBranches();
         }
         catch (err) {
@@ -289,9 +439,10 @@ export function useBranchManager(options) {
             options.setBusy(false);
         }
     };
-    const handleDelete = async (branchNameToDelete) => {
-        return new Promise((resolve) => {
-            showDeleteConfirmation(branchNameToDelete, async () => {
+    const handleDelete = (requested) => {
+        const branchNameToDelete = listedName(requested);
+        return singleFlight('delete', branchNameToDelete, () => new Promise((resolve) => {
+            showDeleteConfirmation(branchNameToDelete, pullRequestOf(branchNameToDelete), async () => {
                 options.setBusy(true);
                 try {
                     const result = await apiClient.branches.delete({
@@ -300,8 +451,25 @@ export function useBranchManager(options) {
                     if (!result.ok) {
                         throw new Error(result.error || 'Failed to delete branch');
                     }
-                    notifications.show({ message: 'Branch deleted', color: 'green' });
-                    await loadBranches();
+                    const cleanupWarning = result.data?.cleanupWarning;
+                    notifications.show(cleanupWarning
+                        ? {
+                            message: `Branch deleted, with a warning: ${cleanupWarning}`,
+                            color: 'yellow',
+                            autoClose: false,
+                        }
+                        : { message: 'Branch deleted', color: 'green' });
+                    forgetCreatedBranch(branchNameToDelete);
+                    const fresh = await reloadBranches();
+                    // Matched the way `currentBranch` resolves a name, since the deleted branch is
+                    // no longer listed to resolve against.
+                    const open = latest.current.branchName;
+                    if (open === branchNameToDelete ||
+                        sanitizeBranchName(open) === branchNameToDelete) {
+                        // Nothing is left to keep, so no unsaved-changes prompt. With no default known
+                        // yet, the empty name lets the default-branch adoption effect pick it.
+                        setBranchName(fresh?.defaultBranch ?? latest.current.branchesData?.defaultBranch ?? '');
+                    }
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : 'Failed to delete branch';
@@ -309,13 +477,11 @@ export function useBranchManager(options) {
                 }
                 finally {
                     options.setBusy(false);
-                    // Resolve regardless of API success/failure, matching the
-                    // pre-confirmation behavior (errors were shown as a toast, not
-                    // rethrown). Cancellation resolves too -- see below.
+                    // Failures surface as the toast above, never as a rejection; cancelling resolves too.
                     resolve();
                 }
             }, () => resolve());
-        });
+        }));
     };
     const handleReloadBranchData = async () => {
         await loadBranches();
@@ -338,6 +504,7 @@ export function useBranchManager(options) {
         branches,
         branchSummaries,
         currentBranch,
+        addCreatedBranch,
         handleSubmit,
         handleWithdraw,
         handleRequestChanges,

package/dist/editor/hooks/useBranchesData.d.ts

@@ -19,6 +19,12 @@ export declare const BRANCHES_KEY = "canopy:branches";
 export interface BranchesData {
     branches: BranchListItem[];
     defaultBranch?: string;
+    /**
+     * Client clock when this listing arrived. It makes listings fetched at
+     * different moments distinct `data` values even when their branches match,
+     * while a failed fetch (SWR keeps the previous `data`) changes nothing.
+     */
+    receivedAt: number;
 }
 /**
  * Fetch the branches list. Exported for direct testing and for the