dsh-remote-vs 0.9.2 → 0.10.0

package/src/client/i18n.ts

@@ -115,6 +115,10 @@ const zh: Record<string, string> = {
   'tab.git': 'Git',
   'git.hint': '请选择远端路径为 git 仓库的工作区。',
   'scm.loadingSlow': '正在读取仓库状态…大仓库首次读取可能需要数分钟',
+  'scm.cached': '缓存',
+  'scm.cachedRefreshing': '缓存 · 后台刷新中',
+  'scm.cachedHint': '显示的是该工作区上次读取的结果，正在后台刷新；更改列表与暂存/提交等操作仍作用于这个工作区。',
+  'scm.refreshFailed': '刷新失败：',
   'common.close': '关闭',
   'common.loading': '加载中…',
   'flow.title': '添加工作区',
@@ -134,7 +138,7 @@ const zh: Record<string, string> = {
   'route.off': '关闭（直通本地）',
   'route.shadow': '影子（记日志仍走本地）',
   'route.enforce': '强制（真路由）',
-  'route.hint': '切换即时生效并写入 profile，无需重启',
+  'route.hint': '切换即时生效并写入 profile，无需重启；默认「强制（真路由）」。',
   'route.saving': '保存中…',
   'route.tombstones': '墓碑',
   'route.aliasPath': '本地别名目录（原生工作区入口）',
@@ -467,6 +471,10 @@ const en: Record<string, string> = {
   'tab.git': 'Git',
   'git.hint': 'Pick a workspace whose remote path is a git repository.',
   'scm.loadingSlow': 'Reading repository state… a large repo can take minutes on first read',
+  'scm.cached': 'cached',
+  'scm.cachedRefreshing': 'cached · refreshing',
+  'scm.cachedHint': 'Showing this workspace’s last read while it refreshes in the background; the change list and stage/commit actions still target this workspace.',
+  'scm.refreshFailed': 'Refresh failed:',
   'common.close': 'Close',
   'common.loading': 'Loading…',
   'flow.title': 'Add workspace',
@@ -486,7 +494,7 @@ const en: Record<string, string> = {
   'route.off': 'Off (local passthrough)',
   'route.shadow': 'Shadow (log only, still local)',
   'route.enforce': 'Enforce (real routing)',
-  'route.hint': 'Applies immediately and persists to the profile; no restart needed.',
+  'route.hint': 'Applies immediately and persists to the profile; no restart needed. Default: enforce (real routing).',
   'route.saving': 'Saving…',
   'route.tombstones': 'tombstones',
   'route.aliasPath': 'Local alias dir (native workspace entry)',

package/src/client/scm/HistoryPanel.tsx

@@ -7,13 +7,20 @@
  * repository shows the newest GIT_LOG_MAX commits and is filtered client-side.
  * The docstring here used to promise scroll-triggered paging that does not
  * exist, which is worse than no comment: a reader trusts it.
+ *
+ * Each repository's last answer is kept in memory (`./panel-cache.ts`), so a
+ * switch back to a workspace repaints its commit list at once and the log is
+ * re-read behind it — the tab used to blank on every switch, and worse, kept the
+ * PREVIOUS repository's rows until the new log arrived.
  */
 import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from 'react'
 import type { GitCommit, GitCommitFile } from '../../protocol.ts'
 import { GIT_LOG_MAX } from '../../git-format.ts'
 import { api } from '../api.ts'
-import { useExplorer } from '../store.tsx'
+import { gitReadSettleMs, useExplorer } from '../store.tsx'
 import { checkoutCommit, loadCommitFiles } from './actions.ts'
+import { ReadQueue } from './read-queue.ts'
+import { readHistorySnapshot, repoCacheKey, writeHistorySnapshot } from './panel-cache.ts'
 import {
   IconButton,
   IconChevronDown,
@@ -32,6 +39,16 @@ const LANE_W = 13
 const PAD_X = 9
 const LANE_COLORS = ['#e2b714', '#4ec9b0', '#58a6ff', '#d2a8ff', '#ff7b72', '#79c0ff', '#7ee787', '#ffa657']
 
+/**
+ * One log read per repository at a time.
+ *
+ * Same contracts as the git status queue (`./read-queue.ts`): the automatic
+ * read on entering the tab `join`s one in flight, and the ⟳ button asks for a
+ * `fresh` one. Without it, flipping tabs while a log read runs could start a
+ * second `git log` of the same repository and let the slower answer repaint.
+ */
+const logReads = new ReadQueue()
+
 /**
  * Ref badge decoration for one `%D` entry. Extracted from a pair of nested
  * ternaries (forbidden by this project's review checklist) that were doing two
@@ -120,10 +137,22 @@ function laneColor(lane: number): string {
   return LANE_COLORS[lane % LANE_COLORS.length] as string
 }
 
+/** A stable empty list: the "this repository was never read" fallback. */
+const EMPTY_COMMITS: GitCommit[] = []
+
 export function HistoryPanel(): ReactNode {
   const store = useExplorer()
   const { t, lang, alias, repoRoot } = store
   const [commits, setCommits] = useState<GitCommit[]>([])
+  /**
+   * The repository `commits` belongs to.
+   *
+   * A state update lands one paint AFTER the repository changes, so without this
+   * key the first frame after a switch would still show the PREVIOUS repository's
+   * rows — whose checkout buttons would then point those hashes at the new
+   * repository. The render-time arbitration below (`rows`) closes that frame.
+   */
+  const [commitsKey, setCommitsKey] = useState('')
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<string | undefined>(undefined)
   const [expanded, setExpanded] = useState<string | undefined>(undefined)
@@ -138,23 +167,43 @@ export function HistoryPanel(): ReactNode {
    */
   const loadSeq = useRef(0)
 
-  const load = useCallback(async (): Promise<void> => {
+  const repoKey = alias === '' || repoRoot === undefined ? '' : repoCacheKey(alias, repoRoot)
+  /** The cached log of the repository being shown, when it was read before. */
+  const cachedCommits = useMemo(
+    () => (repoKey === '' ? undefined : readHistorySnapshot(repoKey)?.commits),
+    [repoKey],
+  )
+  /** What THIS frame may show: rows of this repository, or none. */
+  const rows = commitsKey === repoKey ? commits : (cachedCommits ?? EMPTY_COMMITS)
+
+  const load = useCallback(async (mode: 'join' | 'fresh' = 'join'): Promise<void> => {
     if (alias === '' || repoRoot === undefined) {
       loadSeq.current += 1
-      setCommits([])
+      setCommitsKey('')
+      setCommits(EMPTY_COMMITS)
       setLoading(false)
       return
     }
+    const key = repoCacheKey(alias, repoRoot)
     const ticket = ++loadSeq.current
+    // The cached log of THIS repository (when it was read before) replaces the
+    // rows at once, so a switch back is instant instead of a blank tab; a
+    // repository never read gets an empty list, never the previous one's.
+    const cached = readHistorySnapshot(key)
+    setCommitsKey(key)
+    setCommits(cached?.commits ?? EMPTY_COMMITS)
     setLoading(true)
     setError(undefined)
     try {
-      const list = await api.git.log(alias, repoRoot, GIT_LOG_MAX)
+      const list = await logReads.run(key, () => api.git.log(alias, repoRoot, GIT_LOG_MAX), mode, gitReadSettleMs())
+      writeHistorySnapshot(key, { commits: list, at: Date.now() })
       if (loadSeq.current !== ticket) return
+      setCommitsKey(key)
       setCommits(list)
     } catch (caught) {
       if (loadSeq.current !== ticket) return
-      setCommits([])
+      // A failed re-read keeps what is on screen (it was a real read) and says
+      // why: blanking the tab would hide that anything went wrong.
       setError(caught instanceof Error ? caught.message : String(caught))
     } finally {
       if (loadSeq.current === ticket) setLoading(false)
@@ -166,13 +215,13 @@ export function HistoryPanel(): ReactNode {
   }, [load])
 
   const visible = useMemo(() => {
-    if (filter.trim() === '') return commits
+    if (filter.trim() === '') return rows
     const needle = filter.trim().toLowerCase()
-    return commits.filter(commit =>
+    return rows.filter(commit =>
       commit.subject.toLowerCase().includes(needle)
       || commit.author.toLowerCase().includes(needle)
       || commit.hash.startsWith(needle))
-  }, [commits, filter])
+  }, [rows, filter])
 
   const graph = useMemo(() => layoutLanes(visible), [visible])
 
@@ -199,7 +248,8 @@ export function HistoryPanel(): ReactNode {
       <div className="rvs-header">
         <span className="rvs-title">{t('tab.history')}</span>
         {head !== '' && <span className="rvs-pill">⑂ {store.head?.detached === true ? t('scm.detached') : head}</span>}
-        <IconButton title={t('scm.refresh')} onClick={() => { void load() }} disabled={loading}>
+        {loading && <MiniSpinner />}
+        <IconButton title={t('scm.refresh')} onClick={() => { void load('fresh') }} disabled={loading}>
           <IconRefresh size={14} />
         </IconButton>
       </div>
@@ -214,8 +264,8 @@ export function HistoryPanel(): ReactNode {
       </div>
       {error !== undefined && <div className="rvs-banner error">{error}</div>}
       <div className="rvs-scroll">
-        {loading && commits.length === 0 && <div className="rvs-empty"><MiniSpinner /> {t('common.loading')}</div>}
-        {!loading && commits.length === 0 && error === undefined && <div className="rvs-empty">{t('scm.logEmpty')}</div>}
+        {loading && rows.length === 0 && <div className="rvs-empty"><MiniSpinner /> {t('common.loading')}</div>}
+        {!loading && rows.length === 0 && error === undefined && <div className="rvs-empty">{t('scm.logEmpty')}</div>}
         {graph.rows.map((row, index) => {
           const commit = row.commit
           const isOpen = expanded === commit.hash

package/src/client/scm/ScmPanel.tsx

@@ -10,7 +10,7 @@
  */
 import { Fragment, useCallback, useEffect, useMemo, useRef, useState, type MouseEvent as ReactMouseEvent, type ReactNode } from 'react'
 import type { GitBranch, GitRemote, GitStash } from '../../protocol.ts'
-import { useExplorer } from '../store.tsx'
+import { gitReadSettleMs, useExplorer } from '../store.tsx'
 import {
   branchOp,
   commitAll,
@@ -26,6 +26,8 @@ import {
 } from './actions.ts'
 import type { ChangeEntry } from './status-map.ts'
 import { rowVerb } from './status-map.ts'
+import { ReadQueue } from './read-queue.ts'
+import { readScmExtras, repoCacheKey, writeScmExtras, type ScmExtrasSnapshot } from './panel-cache.ts'
 import { RepoPicker } from './RepoPicker.tsx'
 import {
   IconBranch,
@@ -55,6 +57,22 @@ import {
 
 const MSG_KEY = 'dsh-remote-vs.commitMsg'
 
+/**
+ * One extras read per repository at a time.
+ *
+ * The panel can ask for the same three lists twice at once — the visibility
+ * effect when it comes back on screen and the ⟳ refresh — and two identical
+ * `for-each-ref` / `stash list` walks of a monorepo are pure waste. Same
+ * contracts as the git reads (`scm/read-queue.ts`): `join` for the automatic
+ * path, `fresh` for a manual refresh.
+ */
+const extrasReads = new ReadQueue()
+
+/** Stable empty lists: "this repository's side lists are not loaded (yet)". */
+const NO_STASHES: GitStash[] = []
+const NO_BRANCHES: GitBranch[] = []
+const NO_REMOTES: GitRemote[] = []
+
 function messageOf(error: unknown): string {
   return error instanceof GitOpError || error instanceof Error ? error.message : String(error)
 }
@@ -74,6 +92,15 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
   const [stashes, setStashes] = useState<GitStash[]>([])
   const [branches, setBranches] = useState<GitBranch[]>([])
   const [remotes, setRemotes] = useState<GitRemote[]>([])
+  /**
+   * The repository the three lists above belong to (`repoCacheKey`).
+   *
+   * The setState that adopts a repository's lists lands one paint AFTER the
+   * switch, so a render-time merge (see `extras` below) is what keeps the
+   * PREVIOUS repository's stash rows off the screen — their buttons act through
+   * the CURRENT `repoRoot`, i.e. on the wrong repository.
+   */
+  const [listedRepoKey, setListedRepoKey] = useState('')
   const [branchOpen, setBranchOpen] = useState(false)
   const [remoteOpen, setRemoteOpen] = useState(false)
   const [newBranch, setNewBranch] = useState('')
@@ -92,22 +119,45 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
     }
   }, [message])
 
-  const loadExtras = useCallback(async (): Promise<void> => {
+  /**
+   * The repository the extras on screen belong to (`repoCacheKey`).
+   *
+   * A read that is still in flight when the workspace changes must not paint its
+   * answer over the new repository's lists: the panel is kept alive across
+   * switches, so the response needs to be checked against where the panel is
+   * NOW, not where it was when the request went out.
+   */
+  const extrasKeyRef = useRef('')
+
+  const loadExtras = useCallback(async (mode: 'join' | 'fresh' = 'join'): Promise<void> => {
     if (alias === '' || repoRoot === undefined) {
-      setStashes([])
-      setBranches([])
-      setRemotes([])
+      extrasKeyRef.current = ''
+      setListedRepoKey('')
+      setStashes(NO_STASHES)
+      setBranches(NO_BRANCHES)
+      setRemotes(NO_REMOTES)
       return
     }
+    const repoKey = repoCacheKey(alias, repoRoot)
+    extrasKeyRef.current = repoKey
     try {
-      const [stashList, branchList, remoteList] = await Promise.all([
-        loadStashes(alias, repoRoot),
-        loadBranches(alias, repoRoot, head?.branch ?? ''),
-        loadRemotes(alias, repoRoot),
-      ])
-      setStashes(stashList)
-      setBranches(branchList)
-      setRemotes(remoteList)
+      const snapshot = await extrasReads.run(repoKey, async (): Promise<ScmExtrasSnapshot> => {
+        const [stashList, branchList, remoteList] = await Promise.all([
+          loadStashes(alias, repoRoot),
+          loadBranches(alias, repoRoot, head?.branch ?? ''),
+          loadRemotes(alias, repoRoot),
+        ])
+        const answer: ScmExtrasSnapshot = { stashes: stashList, branches: branchList, remotes: remoteList, at: Date.now() }
+        // Remember the answer: coming back to this repository repaints these
+        // lists immediately instead of blanking three sections again.
+        writeScmExtras(repoKey, answer)
+        return answer
+      }, mode, gitReadSettleMs())
+      if (extrasKeyRef.current !== repoKey) return
+      setListedRepoKey(repoKey)
+      setStashes(snapshot.stashes)
+      setBranches(snapshot.branches)
+      setRemotes(snapshot.remotes)
     } catch {
       // The panel degrades: status stays usable without the extras.
     }
@@ -130,12 +180,46 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
     // change made while parked still reads as pending.
     if (props.visible === false || listedExtras.current === extrasKey) return
     listedExtras.current = extrasKey
-    void loadExtras()
-  }, [extrasKey, loadExtras, props.visible])
+    const repoKey = repoRoot === undefined ? '' : repoCacheKey(alias, repoRoot)
+    extrasKeyRef.current = repoKey
+    // Repaint the cached lists of this repository BEFORE the read: a switch back
+    // must not blank the stash / branch / remote sections while their own three
+    // git commands run (see `scm/panel-cache.ts`).
+    const cached = repoKey === '' ? undefined : readScmExtras(repoKey)
+    if (cached !== undefined) {
+      setListedRepoKey(repoKey)
+      setStashes(cached.stashes)
+      setBranches(cached.branches)
+      setRemotes(cached.remotes)
+    }
+    void loadExtras('join')
+  }, [extrasKey, loadExtras, props.visible, alias, repoRoot])
+
+  /** The repository the panel is showing the side lists of. */
+  const extrasRepoKey = repoRoot === undefined ? '' : repoCacheKey(alias, repoRoot)
+  /** Its cached lists, when it was read before (stable across paints). */
+  const cachedExtras = useMemo(
+    () => (extrasRepoKey === '' ? undefined : readScmExtras(extrasRepoKey)),
+    [extrasRepoKey],
+  )
+  /**
+   * What THIS frame may show.
+   *
+   * A setState adopting a repository's lists lands one paint after the switch, so
+   * the merge is what stops the PREVIOUS repository's stash/branch rows (whose
+   * buttons run against the CURRENT `repoRoot`) from ever appearing under the
+   * new repository. This repository's cache, when present, fills that frame;
+   * otherwise the sections are simply empty until its own read adopts them.
+   */
+  const extras = listedRepoKey === extrasRepoKey
+    ? { stashes, branches, remotes }
+    : (cachedExtras ?? { stashes: NO_STASHES, branches: NO_BRANCHES, remotes: NO_REMOTES })
 
   const refreshAll = useCallback(async (): Promise<void> => {
+    // The ⟳ / post-verb refresh must describe the state as of NOW: `afterWrite`
+    // runs a `fresh` status read and the extras are forced to re-read as well.
     await store.afterWrite()
-    await loadExtras()
+    await loadExtras('fresh')
   }, [store, loadExtras])
 
   /**
@@ -459,6 +543,17 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
       <div className="rvs-header">
         <span className="rvs-title">{t('scm.title')}</span>
         {store.gitBusy && <MiniSpinner />}
+        {/*
+          A cached slice is shown so the switch is instant, and the background
+          read can take minutes on a monorepo: saying so is what stops an old
+          change list from being read as the current one. The actions stay
+          enabled — they target this binding's repository, cache or not.
+        */}
+        {store.gitCached && (
+          <span className="rvs-pill rvs-pill-cached" title={t('scm.cachedHint')}>
+            {store.gitBusy ? t('scm.cachedRefreshing') : t('scm.cached')}
+          </span>
+        )}
         <IconButton title={t('scm.refresh')} onClick={() => { void refreshAll() }} disabled={store.gitBusy}>
           <IconRefresh size={14} />
         </IconButton>
@@ -503,6 +598,12 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
           }}
         />
       )}
+      {/* A failed background read keeps the last good / cached list on screen
+          (see `paintGit`); the reason has to be visible, or the panel would look
+          current while nothing is being refreshed. */}
+      {repoRoot !== undefined && store.gitError !== undefined && (
+        <div className="rvs-banner error">{t('scm.refreshFailed')} {store.gitError}</div>
+      )}
       <div className="rvs-scroll">
         {repoRoot === undefined && (
           <div className="rvs-empty">
@@ -642,20 +743,20 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
             {section(
               'stash',
               t('scm.stashes'),
-              stashes.length,
+              extras.stashes.length,
               <>
                 <IconButton title={t('scm.stashSave')} disabled={busy !== undefined} onClick={() => { void saveStash() }}>
                   <IconPlus size={13} />
                 </IconButton>
-                <IconButton title={t('scm.refresh')} disabled={busy !== undefined} onClick={() => { void loadExtras() }}>
+                <IconButton title={t('scm.refresh')} disabled={busy !== undefined} onClick={() => { void loadExtras('fresh') }}>
                   <IconRefresh size={13} />
                 </IconButton>
               </>,
-              () => (stashes.length === 0
+              () => (extras.stashes.length === 0
                 ? <div className="rvs-empty">{t('scm.noStash')}</div>
                 : (
                   <div>
-                    {stashes.map(item => (
+                    {extras.stashes.map(item => (
                       <div key={item.ref} className="rvs-scm-item" style={{ cursor: 'default' }} title={`${item.ref}  ${fullTime(item.date)}`}>
                         <span className="rvs-node-icon"><IconCheck size={13} /></span>
                         <span className="rvs-scm-path">{item.message === '' ? item.ref : item.message}</span>
@@ -745,7 +846,7 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
                       </button>
                     </div>
                     <div style={{ marginTop: 6, maxHeight: 200, overflow: 'auto' }}>
-                      {branches.map(branch => (
+                      {extras.branches.map(branch => (
                         <div key={branch.name} className="rvs-scm-item" style={{ cursor: 'default', paddingLeft: 4 }} title={branch.short}>
                           <span className="rvs-node-icon">{branch.head ? '➤' : ''}</span>
                           <span className="rvs-scm-path">
@@ -830,7 +931,7 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
                       <span className="rvs-einfo-spacer" />
                       <IconButton title={t('common.close')} onClick={() => setRemoteOpen(false)}><IconClose size={11} /></IconButton>
                     </div>
-                    {remotes.map(remote => (
+                    {extras.remotes.map(remote => (
                       <div key={`${remote.name}:${remote.kind}`} className="rvs-scm-item" style={{ cursor: 'default', paddingLeft: 4 }}>
                         <span className="rvs-scm-path" title={remote.url}>{remote.name} <span className="rvs-scm-dir">{remote.kind}</span></span>
                         {remote.kind === 'fetch' && (

package/src/client/scm/actions.ts

@@ -42,6 +42,8 @@ import {
   renameBranchCommand,
   repoDiscoveryCommand,
   repoProbeCommand,
+  repoProbeDetailCommand,
+  parseRepoProbe,
   restoreWorktreeCommand,
   setRemoteUrlCommand,
   stageCommand,
@@ -81,16 +83,21 @@ export function joinRemote(dir: string, rel: string): string {
 const normalTimeoutMs = (): number => gitTimeoutMs()
 const longTimeoutMs = (): number => Math.min(MAX_TIMEOUT_MS, Math.max(DEFAULT_GIT_TIMEOUT_MS, gitTimeoutMs() * 2))
 
-/** Run one command, raising a readable error on a non-zero exit. */
-async function run(alias: string, command: string, timeoutMs = normalTimeoutMs()): Promise<RemoteExecResult> {
-  const result = await api.exec(alias, command, timeoutMs)
-  if (result.success) return result
+/** The readable error for a failed exec result (`run` and the strict probe share it). */
+function failureOf(result: RemoteExecResult, timeoutMs: number): GitOpError {
   if (result.timedOut) {
-    throw new GitOpError(`git timed out after ${timeoutSeconds(timeoutMs)} — the repository may be large or the host busy; raise gitTimeoutMs in the plugin settings`)
+    return new GitOpError(`git timed out after ${timeoutSeconds(timeoutMs)} — the repository may be large or the host busy; raise gitTimeoutMs in the plugin settings`)
   }
   const hint = gitErrorHint(result.stderr) ?? gitErrorHint(result.stdout)
   const detail = result.stderr.trim() !== '' ? result.stderr.trim() : (result.stdout.trim() !== '' ? result.stdout.trim() : '')
-  throw new GitOpError(hint ?? detail ?? result.error ?? `git failed [exit code: ${result.exitCode ?? '?'}]`)
+  return new GitOpError(hint ?? detail ?? result.error ?? `git failed [exit code: ${result.exitCode ?? '?'}]`)
+}
+
+/** Run one command, raising a readable error on a non-zero exit. */
+async function run(alias: string, command: string, timeoutMs = normalTimeoutMs()): Promise<RemoteExecResult> {
+  const result = await api.exec(alias, command, timeoutMs)
+  if (result.success) return result
+  throw failureOf(result, timeoutMs)
 }
 
 /** Run one command tolerating failure (returns '' instead). */
@@ -111,6 +118,42 @@ export async function resolveRepoRoot(alias: string, workspaceRoot: string): Pro
   return parseRepoRoot(out)
 }
 
+/**
+ * The same probe, telling "not a repository" apart from "the probe failed".
+ *
+ * `git rev-parse --show-toplevel` exits non-zero BOTH when the directory is not
+ * inside a work tree and for every way a remote command can fail (host gone,
+ * budget blown, sshd refusing, no answer at all). `resolveRepoRoot` folds the two
+ * into `undefined`, which is right for the workspace wizard — there "unknown" and
+ * "none" both mean "nothing to offer". The SCM panel cannot take that shortcut:
+ * treating a failed probe as "no repository" writes an EMPTY snapshot over the
+ * cached change list and tells the user their workspace has no git repository.
+ * That is exactly the blank state the snapshot cache exists to prevent, so this
+ * variant asks a command that KEEPS the answer (`repoProbeDetailCommand`: exit
+ * code + merged streams, `LC_ALL=C`) and reports the failure to the caller.
+ */
+export type RepoRootProbe =
+  | { kind: 'repo'; root: string }
+  | { kind: 'none' }
+  | { kind: 'failed'; error: string }
+
+/** The repository root, or WHY the probe could not answer. */
+export async function probeRepoRoot(alias: string, workspaceRoot: string): Promise<RepoRootProbe> {
+  let result: RemoteExecResult
+  try {
+    result = await api.exec(alias, repoProbeDetailCommand(workspaceRoot), normalTimeoutMs())
+  } catch (error) {
+    // The transport/route failed before any git exit code existed.
+    return { kind: 'failed', error: error instanceof Error ? error.message : String(error) }
+  }
+  if (!result.success) {
+    // The exec route itself failed (timeout, transport, no answer): the command
+    // never produced its status line, so nothing about the repository is known.
+    return { kind: 'failed', error: failureOf(result, normalTimeoutMs()).message }
+  }
+  return parseRepoProbe(result.stdout)
+}
+
 /** Repositories under a workspace root (the workspace itself sorts first). */
 export async function findRepos(alias: string, workspaceRoot: string): Promise<string[]> {
   const direct = await resolveRepoRoot(alias, workspaceRoot)

package/src/client/scm/git-cache.ts

@@ -0,0 +1,159 @@
+/**
+ * Last-read git state, remembered per workspace AND per repository directory.
+ *
+ * The complaint this module answers: switching between two remote workspaces
+ * blanked the source-control panel. The store dropped `status` / `head` /
+ * `repoRoot` on the switch and started a full `git status` again — minutes of
+ * "Loading…" on a large repository — even though BOTH workspaces had just been
+ * read, so the very data the panel needed was already in memory. It simply had
+ * no home: the store keeps one git slice, describing whatever is on screen.
+ *
+ * A snapshot is that home. It holds everything the panel paints from, keyed by
+ * the binding id AND the workspace-relative directory git ran in, because one
+ * workspace can carry several repositories and their states must never
+ * overwrite each other (the repo picker switches between them). The store
+ * hydrates a snapshot the moment a workspace is selected — in the same frame as
+ * the dropdown change — and refreshes it in the background; the read replaces
+ * the snapshot and repaints only when it is still the current binding's answer.
+ *
+ * MEMORY ONLY, on purpose: a `-u normal -z --ignored=matching` status of a
+ * monorepo is hundreds of kilobytes, and after a page reload it would describe
+ * a tree that may have moved on. The cache is an accelerator for switching, not
+ * a second source of truth — every value in it was read by a real command.
+ */
+import type { GitStatusDetail } from '../../protocol.ts'
+import type { DirExpansions } from './untracked-dirs.ts'
+
+/**
+ * Branch header, structurally identical to the store's `HeadInfo`.
+ *
+ * Declared here instead of imported from `store.tsx` so this module stays a
+ * standalone leaf: `store` imports it, and a type-only back-import would pull
+ * the whole store into the module graph of every gate that touches the cache.
+ */
+export interface GitHead {
+  branch: string
+  detached: boolean
+  ahead: number
+  behind: number
+}
+
+/** Everything one git read answered, as the panels need it. */
+export interface GitSnapshot {
+  /** Enclosing repository root, or undefined when the directory is no repo. */
+  repoRoot: string | undefined
+  /** Workspace-relative directory git ran in (the settled one). */
+  repoSubdir: string
+  status: GitStatusDetail
+  head: GitHead | undefined
+  /** git answered "not a repository" — a fact, not a failure. */
+  repoMissing: boolean
+  /** Expanded untracked directories, repository-relative. */
+  untrackedDirs: DirExpansions
+  /** `Date.now()` when the read that produced this snapshot finished. */
+  at: number
+}
+
+/**
+ * Separator between the binding id and the repository directory.
+ *
+ * NUL cannot appear in either half: a binding id comes from the host's table
+ * and a workspace-relative sub-directory is a path. The key must be reversible
+ * because `retainGitSnapshots` deletes everything whose binding is gone.
+ */
+const KEY_SEP = '\u0000'
+
+/** Cache key for one (workspace, repository directory) pair. */
+export function gitCacheKey(bindingId: string, repoSubdir: string): string {
+  return `${bindingId}${KEY_SEP}${repoSubdir}`
+}
+
+/** Split a cache key back into its two halves (undefined when it is not one). */
+export function parseGitCacheKey(key: string): { bindingId: string; repoSubdir: string } | undefined {
+  const at = key.indexOf(KEY_SEP)
+  if (at < 0) return undefined
+  return { bindingId: key.slice(0, at), repoSubdir: key.slice(at + 1) }
+}
+
+/**
+ * How many (workspace, repository) pairs stay cached.
+ *
+ * Bindings are few (the workspace table is hand-managed) and each snapshot is
+ * the panel's whole change list, so a small bound is plenty; the LRU trim only
+ * exists so a long-lived page cannot grow without limit.
+ */
+const SNAPSHOT_LIMIT = 12
+
+/** Snapshots by cache key, in recency order (oldest insertion first). */
+const snapshots = new Map<string, GitSnapshot>()
+
+/** The cached read for one (workspace, repository directory), if any. */
+export function readGitSnapshot(key: string): GitSnapshot | undefined {
+  const snapshot = snapshots.get(key)
+  if (snapshot === undefined) return undefined
+  // Touch: keep the LRU honest without changing the snapshot's own `at`.
+  snapshots.delete(key)
+  snapshots.set(key, snapshot)
+  return snapshot
+}
+
+/**
+ * Remember one read.
+ *
+ * Called even when the read is no longer the binding on screen: the walk has
+ * already been paid for, and caching it is what makes the NEXT switch back
+ * instant instead of another minutes-long wait.
+ *
+ * An answer OLDER than the one already cached is dropped. Two reads of one
+ * workspace can overlap when the repo picker changes the directory mid-read (the
+ * settled directory is a second key, see the store's `readGit`), and the older
+ * walk may finish last — letting it win would hand the user a change list that
+ * predates the one already shown.
+ */
+export function writeGitSnapshot(key: string, snapshot: GitSnapshot): void {
+  const previous = snapshots.get(key)
+  if (previous !== undefined && previous.at > snapshot.at) return
+  snapshots.delete(key)
+  snapshots.set(key, snapshot)
+  while (snapshots.size > SNAPSHOT_LIMIT) {
+    const oldest = snapshots.keys().next()
+    if (oldest.done === true) break
+    snapshots.delete(oldest.value)
+  }
+}
+
+/** Drop every snapshot whose workspace left the binding table. */
+export function retainGitSnapshots(bindingIds: ReadonlySet<string>): void {
+  for (const key of [...snapshots.keys()]) {
+    const parsed = parseGitCacheKey(key)
+    if (parsed === undefined || !bindingIds.has(parsed.bindingId)) snapshots.delete(key)
+  }
+}
+
+/**
+ * Write a locally-known status into a cached snapshot.
+ *
+ * The plotted stage/unstage move is applied to the store's status WITHOUT a
+ * repository-wide read (see `applyLocalStage`). Without this write-through the
+ * cache would keep the pre-click list, so switching away and back would flip
+ * the row back — the panel would show a change the user already staged.
+ * A different `repoRoot` means the snapshot is not that repository: refusing is
+ * what keeps one workspace's rows out of another's cache.
+ */
+export function patchCachedGitStatus(key: string, repoRoot: string | undefined, status: GitStatusDetail): void {
+  const snapshot = snapshots.get(key)
+  if (snapshot === undefined || snapshot.repoRoot !== repoRoot) return
+  snapshots.set(key, { ...snapshot, status })
+}
+
+/** Same write-through for the expanded untracked directories. */
+export function patchCachedUntrackedDirs(key: string, repoRoot: string | undefined, dirs: DirExpansions): void {
+  const snapshot = snapshots.get(key)
+  if (snapshot === undefined || snapshot.repoRoot !== repoRoot) return
+  snapshots.set(key, { ...snapshot, untrackedDirs: dirs })
+}
+
+/** Test hook: forget every snapshot (the cache gate drives this module alone). */
+export function clearGitSnapshots(): void {
+  snapshots.clear()
+}