@kabmo-labs/kabmo 0.1.0 → 0.3.0

package/src/client/hooks/ui/updates/android-download.ts

@@ -0,0 +1,143 @@
+/**
+ * What the sidebar should offer for the Android shell, and why.
+ *
+ * Two DIFFERENT offers, from two different facts:
+ *
+ * - **`update`** — this page is running inside the APK (`shellVersion` from the
+ *   bootstrap) and a newer one is published. An up-to-date app offers nothing:
+ *   a button that downloads the build already installed is worse than no button.
+ * - **`install`** — this page is an Android BROWSER (Chrome, Brave, Firefox) and
+ *   an APK is published. The reader may not know a native shell exists, and
+ *   telling them is the whole point of the offer; there is no installed version
+ *   to compare against, so the newest published one is what it names.
+ *
+ * A desktop browser gets neither: `isAndroid` is false, an APK cannot be
+ * installed there, and the app's own update badge already covers the server.
+ *
+ * The probe is lazy: it runs only on an Android device, never on a desktop, so a
+ * console that can never show the button makes no request for it.
+ */
+
+import { useEffect, useState } from 'preact/hooks';
+import { isNewer } from '@/shared/lib/updates/semver';
+
+/** Which offer this is — the two carry different wording. */
+export type AndroidOfferKind = 'update' | 'install';
+
+export interface AndroidDownload {
+  /** The asset to download. */
+  url: string;
+  /** The version that asset ships. */
+  latest: string;
+  /** The release page, for a "what changed" link. */
+  releaseUrl: string | null;
+  /** An update to an installed APK, or a first install from a browser. */
+  kind: AndroidOfferKind;
+}
+
+interface ReleasePayload {
+  url?: unknown;
+  latest?: unknown;
+  releaseUrl?: unknown;
+}
+
+/**
+ * Read the release payload defensively.
+ *
+ * The route answers `{url: null, latest: null, releaseUrl: null}` on a failed
+ * probe, so a shape check that only looks at the version would offer a button
+ * with no link.
+ */
+export function parseAndroidRelease(payload: unknown): Omit<AndroidDownload, 'kind'> | null {
+  if (typeof payload !== 'object' || payload === null) return null;
+  const body = payload as ReleasePayload;
+  if (typeof body.url !== 'string' || !body.url) return null;
+  if (typeof body.latest !== 'string' || !body.latest) return null;
+  return {
+    url: body.url,
+    latest: body.latest,
+    releaseUrl: typeof body.releaseUrl === 'string' ? body.releaseUrl : null,
+  };
+}
+
+/**
+ * The offer, or null.
+ *
+ * `shellVersion` is null in every browser — that is what makes the two branches
+ * mutually exclusive — and `isAndroid` is the wider fact that admits a browser
+ * ON ANDROID. Both come from the bootstrap rather than a client-side UA sniff:
+ * the server already parsed them for the very request that served the page.
+ *
+ * An `install` needs no version comparison, because nothing is installed. It
+ * does require a published APK: `release` being null is a failed probe, and a
+ * button the console cannot back with a link must not appear.
+ */
+export function shouldOfferAndroidDownload(
+  shellVersion: string | null | undefined,
+  isAndroid: boolean | null | undefined,
+  release: Omit<AndroidDownload, 'kind'> | null,
+): AndroidDownload | null {
+  if (!release) return null;
+
+  // Inside the APK: an update, and only when one exists.
+  if (shellVersion) {
+    return isNewer(release.latest, shellVersion) ? { ...release, kind: 'update' } : null;
+  }
+
+  // A browser on an Android device: the app is something to install.
+  if (isAndroid) return { ...release, kind: 'install' };
+
+  return null;
+}
+
+/**
+ * The wording of the offer, in one place.
+ *
+ * Both layouts draw this control and they must say the same thing: an installed
+ * app that is behind is an UPDATE, and a browser on Android is an INSTALL —
+ * "Download" for both would leave a first-time reader unsure whether they
+ * already have the app. The version is in the label because the asset is a
+ * specific build, not "the app".
+ */
+export function androidDownloadLabel(download: AndroidDownload): string {
+  const verb = download.kind === 'update' ? 'Update' : 'Install';
+  return `${verb} Kabmo ${download.latest} for Android`;
+}
+
+/**
+ * Fetch the published APK and decide what to offer.
+ *
+ * `fetchImpl` is a seam for the tests: the cases that matter (no release, a
+ * failed probe, a version equal to the installed one) cannot be produced by a
+ * live GitHub call.
+ */
+export function useAndroidDownload(
+  shellVersion: string | null | undefined,
+  isAndroid: boolean | null | undefined,
+  fetchImpl: typeof fetch = fetch,
+): AndroidDownload | null {
+  const [release, setRelease] = useState<Omit<AndroidDownload, 'kind'> | null>(null);
+  const wanted = Boolean(shellVersion) || Boolean(isAndroid);
+
+  useEffect(() => {
+    if (!wanted) return;
+
+    let cancelled = false;
+    void (async () => {
+      try {
+        const response = await fetchImpl('/api/updates/android');
+        if (!response.ok) return;
+        const payload: unknown = await response.json();
+        if (!cancelled) setRelease(parseAndroidRelease(payload));
+      } catch {
+        // A probe that cannot answer is a button that must not appear.
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [wanted, fetchImpl]);
+
+  return shouldOfferAndroidDownload(shellVersion, isAndroid, release);
+}

package/src/client/hooks/workspace/file-tabs.test.ts

@@ -0,0 +1,165 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `useFileTabs` — how an "open this file" request resolves to a TAB.
+ *
+ * The bug this pins: the same path can reach the editor under two different
+ * ids, because the explorer passes a row's own `id` (its relative path) while a
+ * search row or a chat link computes `fileTabId(path)`. `handleOpenFile` used
+ * to activate the id it had COMPUTED even when the updater had just matched an
+ * existing tab under another id, so the editor found no active file and drew
+ * "Select a tab to view content" over the file that was already open — while
+ * the tab strip still showed it selected-by-nothing.
+ *
+ * Mounted through the REAL session-state provider, because the store is what
+ * the request is resolved against; a local stub would not exercise the
+ * read-back the fix depends on.
+ *
+ * The Preact modules are imported DYNAMICALLY after the happy-dom globals are
+ * installed: Preact binds its environment at evaluation time, so a static import
+ * would capture Node's globals and render nothing.
+ */
+
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
+import { Window } from 'happy-dom';
+import type { h as PreactH, render as PreactRender } from 'preact';
+import type { act as PreactAct } from 'preact/test-utils';
+import type { useFileTabs as UseFileTabsHook } from '@/client/hooks/workspace/file-tabs';
+import type { OpenFileInput } from '@/client/hooks/workspace/file-tabs';
+import type { OpenedFile } from '@/shared/types/fs';
+import { fileTabId } from '@/shared/lib/workspace/file-tab-id';
+import { forgetSession } from '@/shared/lib/workspace/session-state/store';
+import { installDomGlobals, restoreDomGlobals } from '@/test-support/pristine-globals';
+
+let useFileTabs: typeof UseFileTabsHook;
+let h: typeof PreactH;
+let render: typeof PreactRender;
+let act: typeof PreactAct;
+
+const ROOT = '/ws';
+const SESSION = 'new-file-tabs';
+const nativeFetch = Bun.fetch;
+
+let container: HTMLElement;
+let handleOpenFile: ((file: OpenFileInput) => void) | null = null;
+let openedFiles: OpenedFile[] = [];
+let activeFileId: number | string | null = null;
+
+async function settle() {
+  for (let i = 0; i < 8; i++) {
+    await act(async () => {
+      for (let turn = 0; turn < 8; turn++) await Promise.resolve();
+    });
+  }
+}
+
+/** Mount the hook inside the provider, with `stored` as the session's blob. */
+async function mount(stored: Record<string, unknown> = {}) {
+  globalThis.fetch = (async () => ({
+    ok: true,
+    json: async () => ({ sessionId: SESSION, state: stored }),
+    text: async () => JSON.stringify({ sessionId: SESSION, state: stored }),
+  })) as unknown as typeof fetch;
+  const { SessionStateProvider } = await import('@/client/components/common/session-state-provider/index');
+  const Probe = () => {
+    const tabs = useFileTabs(ROOT, SESSION);
+    handleOpenFile = tabs.handleOpenFile;
+    openedFiles = tabs.openedFiles;
+    activeFileId = tabs.activeFileId;
+    return null;
+  };
+  await act(async () => {
+    render(h(SessionStateProvider, { sessionId: SESSION, children: h(Probe, {}) }), container);
+  });
+  await settle();
+}
+
+beforeAll(async () => {
+  installDomGlobals(new Window({ url: 'http://localhost' }));
+  ({ useFileTabs } = await import('@/client/hooks/workspace/file-tabs'));
+  ({ h, render } = await import('preact'));
+  ({ act } = await import('preact/test-utils'));
+});
+
+afterAll(() => {
+  globalThis.fetch = nativeFetch;
+  restoreDomGlobals();
+});
+
+beforeEach(() => {
+  handleOpenFile = null;
+  openedFiles = [];
+  activeFileId = null;
+  globalThis.fetch = (async () => ({
+    ok: true,
+    json: async () => ({ state: {} }),
+    text: async () => JSON.stringify({ state: {} }),
+  })) as unknown as typeof fetch;
+  container = document.createElement('div');
+  document.body.appendChild(container);
+});
+
+afterEach(() => {
+  if (container) render(null, container);
+  container?.remove();
+  forgetSession(SESSION);
+});
+
+/** What the explorer sends: the row's own id, which is its relative path. */
+function explorerPayload(path: string): OpenFileInput {
+  return { id: path, name: path.split('/').pop() ?? path, path, root: ROOT, repo: '.' };
+}
+
+/** What a search row sends: no id, so the hook computes `fileTabId(path)`. */
+function searchPayload(path: string): OpenFileInput {
+  return { name: path.split('/').pop() ?? path, path, root: ROOT, repo: '.' };
+}
+
+describe('useFileTabs open resolution', () => {
+  test('opening a file the explorer already has open keeps ITS id active', async () => {
+    await mount({ 'layout.openedFiles': [explorerPayload('notes.md')], 'layout.activeFileId': 'notes.md' });
+
+    await act(async () => {
+      handleOpenFile?.(searchPayload('notes.md'));
+    });
+    await settle();
+
+    // The id the search row computed names no tab; activating it is what blanked
+    // the editor. The existing tab's own id must stay the active one.
+    expect(activeFileId).toBe('notes.md');
+    expect(activeFileId).not.toBe(fileTabId('notes.md'));
+    expect(openedFiles).toHaveLength(1);
+  });
+
+  test('a file opened from the search panel alone gets the computed id', async () => {
+    await mount();
+
+    await act(async () => {
+      handleOpenFile?.(searchPayload('src/a.ts'));
+    });
+    await settle();
+
+    expect(openedFiles).toHaveLength(1);
+    expect(openedFiles[0]?.id).toBe(fileTabId('src/a.ts'));
+    expect(activeFileId).toBe(fileTabId('src/a.ts'));
+  });
+
+  test('reopening under the computed id activates the tab rather than adding one', async () => {
+    await mount();
+
+    await act(async () => {
+      handleOpenFile?.(searchPayload('src/a.ts'));
+    });
+    await settle();
+    await act(async () => {
+      handleOpenFile?.(explorerPayload('src/a.ts'));
+    });
+    await settle();
+
+    expect(openedFiles).toHaveLength(1);
+    expect(activeFileId).toBe(fileTabId('src/a.ts'));
+  });
+});

package/src/client/hooks/workspace/file-tabs.ts

@@ -79,19 +79,32 @@ export function useFileTabs(
       id: file.id ?? fileTabId(file.path),
       root: file.root ?? activeProjectPath ?? undefined,
     };
-    setOpenedFiles(prev => {
-      const existing = prev.find(
-        f => f.id === fileEntry.id || (!f.isDiff && f.path && fileEntry.path && f.path === fileEntry.path)
-      );
-      if (existing) {
-        setActiveFileId(existing.id);
-        return prev;
-      }
-      return [...prev, fileEntry];
-    });
+    // Resolved against the STORE, outside the updater: a state updater may run
+    // more than once, and activating a tab is not something that may be applied
+    // twice. The store is the authoritative copy (every write goes through
+    // `setSessionKey`), and reading it instead of the hook's own value keeps
+    // this callback's identity stable — a caller that memoizes on it (the
+    // search panel's rows do) would otherwise re-render on every tab change.
+    const current = getSessionValue<OpenedFile[]>(sessionId, 'layout.openedFiles') ?? [];
+    const existing = current.find(
+      f => f.id === fileEntry.id || (!f.isDiff && f.path && fileEntry.path && f.path === fileEntry.path)
+    );
+    if (existing) {
+      // The tab on screen may carry a DIFFERENT id for the same path — the
+      // explorer hands a row's own `id` (its relative path) through, while a
+      // search row or a chat link computes `fileTabId(path)`. Activating the
+      // computed id here is what blanked the editor: the id named no tab, so
+      // `Editor` found no active file and drew "Select a tab to view content"
+      // over the file that was already open. Only a tab that is CREATED can be
+      // activated by the id it was created with.
+      setActiveFileId(existing.id);
+      onOpenTab?.();
+      return;
+    }
+    setOpenedFiles(prev => [...prev, fileEntry]);
     setActiveFileId(fileEntry.id);
     onOpenTab?.();
-  }, [activeProjectPath, onOpenTab, setOpenedFiles, setActiveFileId]);
+  }, [activeProjectPath, onOpenTab, sessionId, setOpenedFiles, setActiveFileId]);
 
   const handleOpenDiff = useCallback((diffInfo: {
     file: string;

package/src/client/hooks/workspace/session-state/index.ts

@@ -1,6 +1,6 @@
 import { useEffect, useRef, useState } from 'preact/hooks';
 import { getSessionValue, hydrateSession, setSessionKey } from '@/shared/lib/workspace/session-state/store';
-import { subscribeSessionKey } from '@/shared/lib/workspace/session-state/listeners';
+import { subscribeSessionKey, subscribeSessionReplaced } from '@/shared/lib/workspace/session-state/listeners';
 import { useSessionStateContext } from '@/client/hooks/workspace/session-state/context';
 
 type LoadedState = Record<string, unknown>;
@@ -13,6 +13,16 @@ type LoadedState = Record<string, unknown>;
  * Returns `[value, setValue, ready]` — `ready` lets panels defer their first
  * fetch/render until restore completed (mirrors the DesktopLayout editor
  * "blip" concern).
+ *
+ * The copy is PRIVATE by design: two callers of the same key never observe
+ * each other's writes (a panel width is owned by one component). It is NOT
+ * private about the store being replaced wholesale — a blob landing, or a
+ * spawn adoption migrating the pending slot onto the real id — because there
+ * the value the copy holds was never written by anyone, it is the fallback
+ * this component read on the commit the session id changed. `ready` does not
+ * move across an adoption (it was already true), so without the second
+ * subscription a pending chat's opened panels and picked view were reset to
+ * their defaults at the exact moment the spawn renamed the session.
  */
 export function useSessionState<T>(key: string, fallback: T): [T, (value: T | ((prev: T) => T)) => void, boolean] {
   const { sessionId, ready } = useSessionStateContext();
@@ -32,6 +42,19 @@ export function useSessionState<T>(key: string, fallback: T): [T, (value: T | ((
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [sessionId, ready, key]);
 
+  // The store replaced this session's blob under the copy (a load landing, an
+  // adoption migrate, a delete). `ready` may not move, so re-read on the event.
+  useEffect(
+    () =>
+      subscribeSessionReplaced(sessionId, () => {
+        const next = getSessionValue<T>(sessionId, key);
+        setLocal(next === undefined ? fallback : next);
+      }),
+    // `key` and `fallback` are stable per call site.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [sessionId, key],
+  );
+
   const setValue = (value: T | ((prev: T) => T)) => {
     const resolved = typeof value === 'function' ? (value as (prev: T) => T)(getSessionValue<T>(sessionId, key) ?? local) : value;
     setLocal(resolved);

package/src/client/hooks/workspace/toolbar-row-width.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The toolbar row's CONTENT width, kept current as its container is resized.
+ *
+ * Both session-sidebar toolbars decide their visible set from measured width
+ * rather than a media query — the desktop sidebar is dragged, and the phone's
+ * drawer is whatever the device gives it — so both need the same measurement.
+ * A `@container` breakpoint cannot answer this: it would keep hiding controls
+ * after the user widened the panel.
+ *
+ * The width is a LAYOUT effect, so the first measure lands BEFORE paint: with a
+ * passive effect the row drew every control and then dropped the ones that did
+ * not fit on the next frame.
+ */
+
+import { useLayoutEffect, useRef, useState } from 'preact/hooks';
+
+/**
+ * @param paddingPx Padding the row's `clientWidth` includes but the capacity
+ *   budget must not (the desktop row's own `px-1`). Pass `0` for a row that is
+ *   padded by its container instead, which is what the phone's drawer does.
+ */
+export function useToolbarRowWidth(paddingPx: number) {
+  const ref = useRef<HTMLDivElement>(null);
+  const [width, setWidth] = useState(0);
+
+  useLayoutEffect(() => {
+    const element = ref.current;
+    if (!element) return;
+    const measure = () => setWidth(Math.max(0, element.clientWidth - paddingPx));
+    measure();
+    if (typeof ResizeObserver === 'undefined') return;
+    const observer = new ResizeObserver(measure);
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, [paddingPx]);
+
+  return { ref, width };
+}

package/src/client/lib/native/back.test.ts

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import { Window } from 'happy-dom';
+
+import {
+  BACK_PROPERTY,
+  dispatchBack,
+  installBackDispatcher,
+  registerBackHandler,
+} from '@/client/lib/native/back';
+
+/**
+ * The stack is module state, so every case unregisters what it added. The
+ * shell's contract is exactly two facts: last-registered wins, and the first
+ * handler that answers `true` stops the walk.
+ */
+const cleanups: Array<() => void> = [];
+
+function onBack(handler: () => boolean): () => boolean {
+  const remove = registerBackHandler(handler);
+  cleanups.push(remove);
+  return handler;
+}
+
+afterEach(() => {
+  while (cleanups.length > 0) cleanups.pop()!();
+});
+
+describe('dispatchBack', () => {
+  test('reports false when nothing is registered', () => {
+    expect(dispatchBack()).toBe(false);
+  });
+
+  test('the last registered handler runs first', () => {
+    const order: string[] = [];
+    onBack(() => {
+      order.push('first');
+      return false;
+    });
+    onBack(() => {
+      order.push('second');
+      return true;
+    });
+
+    expect(dispatchBack()).toBe(true);
+    expect(order).toEqual(['second']);
+  });
+
+  test('the first true stops the walk', () => {
+    const order: string[] = [];
+    onBack(() => {
+      order.push('inner');
+      return true;
+    });
+    onBack(() => {
+      order.push('outer');
+      return false;
+    });
+
+    expect(dispatchBack()).toBe(true);
+    expect(order).toEqual(['outer', 'inner']);
+  });
+
+  test('a throwing handler is skipped, and the next one still gets the press', () => {
+    onBack(() => {
+      throw new Error('broken handler');
+    });
+    onBack(() => true);
+
+    expect(dispatchBack()).toBe(true);
+  });
+
+  test('unregistering removes the handler', () => {
+    let calls = 0;
+    const remove = registerBackHandler(() => {
+      calls += 1;
+      return false;
+    });
+    remove();
+
+    expect(dispatchBack()).toBe(false);
+    expect(calls).toBe(0);
+  });
+});
+
+describe('installBackDispatcher', () => {
+  test('exposes window.__kabmoBack and is idempotent', () => {
+    const win = new Window({ url: 'http://localhost/' });
+    const target = globalThis as unknown as Record<string, unknown>;
+    const previous = target.window;
+    target.window = win;
+    try {
+      installBackDispatcher();
+      installBackDispatcher();
+
+      const installed = (win as unknown as Record<string, unknown>)[BACK_PROPERTY];
+      expect(typeof installed).toBe('function');
+      expect((installed as () => boolean)()).toBe(false);
+    } finally {
+      target.window = previous;
+      win.close();
+    }
+  });
+});

package/src/client/lib/native/back.ts

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The Android hardware back button, delegated to the page.
+ *
+ * The shell asks `window.__kabmoBack()` before it walks WebView history, and
+ * that indirection exists because of a real mismatch: Kabmo's phone layout keeps
+ * its screens in React state (`MobileLayoutWrapper`'s `currentScreen`), not in
+ * the URL. `history.back()` therefore reopens a previous session while leaving
+ * the drawer that opened it on screen — the user presses back and the app
+ * appears to do something unrelated.
+ *
+ * Handlers are a STACK, last-registered first: a settings dialog mounted over the
+ * layout gets the press before the layout does, which is the order the user sees.
+ * Each handler answers whether it consumed the press; the first `true` wins.
+ */
+
+export type BackHandler = () => boolean;
+
+/** The property the shell calls. Named once so both sides agree. */
+export const BACK_PROPERTY = '__kabmoBack';
+
+const handlers: BackHandler[] = [];
+
+/** Register a handler; the returned function removes it. */
+export function registerBackHandler(handler: BackHandler): () => void {
+  handlers.push(handler);
+  return () => {
+    const index = handlers.indexOf(handler);
+    if (index >= 0) handlers.splice(index, 1);
+  };
+}
+
+/**
+ * Ask the page to consume a back press.
+ *
+ * Exported for tests and for a caller that wants the same precedence without the
+ * native shell (a keyboard shortcut). Reverse order is the whole contract, and a
+ * throwing handler is skipped rather than allowed to strand the user in a screen
+ * they cannot leave.
+ */
+export function dispatchBack(): boolean {
+  for (let index = handlers.length - 1; index >= 0; index -= 1) {
+    try {
+      if (handlers[index]()) return true;
+    } catch {
+      // Fall through to the next handler; history is the final fallback.
+    }
+  }
+  return false;
+}
+
+/** Install `window.__kabmoBack`. Idempotent — a hot reload re-runs it. */
+export function installBackDispatcher(): void {
+  if (typeof window === 'undefined') return;
+  (window as unknown as Record<string, unknown>)[BACK_PROPERTY] = dispatchBack;
+}

package/src/client/main.tsx

@@ -8,6 +8,7 @@ import { installAuthFetchBridge, primeAuthState } from '@/client/hooks/ui/auth';
 import { installPluginRuntime } from '@/client/lib/plugins/runtime';
 import { installUiKit } from '@/client/lib/plugins/kit';
 import { installScrollbarActivity } from '@/client/lib/scrollbar-activity';
+import { installBackDispatcher } from '@/client/lib/native/back';
 import { installFileLaunchHandler } from '@/client/lib/launch/file-handlers';
 
 import '@/client/tailwind.css';
@@ -53,6 +54,11 @@ installUiKit();
 // already covered.
 installScrollbarActivity();
 
+// The native shell asks `window.__kabmoBack()` before walking WebView history.
+// Installed before the first render for the same reason the listener above is:
+// a back press during hydration must find the dispatcher, not `undefined`.
+installBackDispatcher();
+
 // A file the OS handed to Kabmo (PWA File Handling) arrives as a
 // `FileSystemFileHandle` on `launchQueue`, and the consumer must be installed
 // before the first render: launches that happened before the script ran are

package/src/server/lib/fs/git-actions-branch.ts

@@ -102,8 +102,25 @@ export const GIT_BRANCH_ACTIONS: Record<string, GitActionHandler> = {
   },
 
   async sync({ targetDir }) {
+    // A merge/rebase already stopped on a conflict is a state the operation
+    // bar owns: a pull there is refused by git ("You have not concluded your
+    // merge"), and letting that refusal through would report the conflict as
+    // a failed sync. Naming it points the user at the bar instead.
+    const before = await readGitState(targetDir);
+    if (before.operation) {
+      throw new Error(
+        `Finish the ${OPERATION_LABELS[before.operation]} first — Sync is unavailable while an operation is in progress.`,
+      );
+    }
     await pullBranch(targetDir);
-    await pushBranch(targetDir);
+    // A pull that stopped on a conflict has nothing to push yet: the merge is
+    // unresolved, so `git push` refuses ("Updates were rejected because the
+    // remote contains work…") and the route would report a failed Sync over a
+    // conflict the panel is about to offer to resolve. The operation bar is
+    // the surface that has to be reached, so the push is skipped and the
+    // working tree is left exactly as the pull left it.
+    const after = await readGitState(targetDir);
+    if (!after.operation) await pushBranch(targetDir);
     // Both commands already moved the tracking ref; the next read must not
     // fetch again to see a state it just produced.
     markRemoteRefsFresh(targetDir);