hermes-agent / apps /desktop /src /store /coding-status.ts

Add files using upload-large-folder tool

28ad89a verified about 1 month ago

18.4 kB

import { atom, computed, type ReadableAtom } from 'nanostores'

import type { HermesGitWorktree, HermesRepoStatus } from '@/global'
import { desktopGit } from '@/lib/desktop-git'

import {
  $projectScope,
  $projectTree,
  $worktreeDialog,
  $worktreeRefreshToken,
  ALL_PROJECTS,
  projectRootCwd
} from './projects'
import {
  $busy,
  $currentCwd,
  $selectedStoredSessionId,
  $workspaceCwdOwner,
  workspaceCwdBelongsToSelectedSession
} from './session'
import { $focusedRuntimeId, $sessionStates } from './session-states'
import { $workspaceChangeTick } from './workspace-events'

// Live working-tree status for every git surface on screen — the data backbone
// of the composer coding rail. Keyed PER CWD: the main pane and each session
// tile can sit in different worktrees, so a single global status would paint
// the primary repo's branch/± onto every rail (the "tile shows main's diff"
// bug). It's the same "cheaply re-read git truth at the right moments" model
// as the sidebar worktree probe: a single bounded `git status --porcelain=v2`
// per on-screen worktree per refresh, driven by structural edges (cwd change,
// turn settle, window focus, worktree mutation), never per-token and never
// touching the conversation/system-prompt cache.

const REPO_STATUS_REFRESH_DEBOUNCE_MS = 100

const normalizeCwd = (cwd?: null | string): null | string => cwd?.trim() || null

const EMPTY_WORKTREES: HermesGitWorktree[] = []

// Status + worktrees per normalized cwd. Entries outlive their surface (the
// map stays bounded by the worktrees touched this run) so re-opening a tile
// paints its last-known status instantly while the fresh probe runs.
export const $repoStatusByCwd = atom<Record<string, HermesRepoStatus | null>>({})
export const $repoWorktreesByCwd = atom<Record<string, HermesGitWorktree[]>>({})

// The PRIMARY (main pane) view — the active session's slice of the per-cwd
// truth. Existing consumers (keybind gate, base-branch picker, file tree) keep
// reading these; only surfaces that can live in ANOTHER worktree (tile rails)
// need the per-cwd accessors below. During a conversation switch `$currentCwd`
// can still name the previous conversation's path, so ownership hides only this
// primary slice; the per-cwd cache stays available to any tile that genuinely
// owns that worktree (#71254).
export const $repoStatus: ReadableAtom<HermesRepoStatus | null> = computed(
  [$repoStatusByCwd, $currentCwd, $selectedStoredSessionId, $workspaceCwdOwner],
  (byCwd, cwd) => (workspaceCwdBelongsToSelectedSession() ? (byCwd[normalizeCwd(cwd) ?? ''] ?? null) : null)
)

export const $repoStatusLoading = atom(false)

// The repo's real worktrees (for the coding rail's "jump to a worktree" menu).
// Refreshed on the same edges as the status probe; empty off a repo.
export const $repoWorktrees: ReadableAtom<HermesGitWorktree[]> = computed(
  [$repoWorktreesByCwd, $currentCwd, $selectedStoredSessionId, $workspaceCwdOwner],
  (byCwd, cwd) =>
    workspaceCwdBelongsToSelectedSession() ? (byCwd[normalizeCwd(cwd) ?? ''] ?? EMPTY_WORKTREES) : EMPTY_WORKTREES
)

// Reference-stable per-cwd slices, so any number of rails can each subscribe
// to their own worktree's status without re-deriving atoms per render.
const statusAtomByCwd = new Map<string, ReadableAtom<HermesRepoStatus | null>>()
const worktreesAtomByCwd = new Map<string, ReadableAtom<HermesGitWorktree[]>>()
const $noRepoStatus = atom<HermesRepoStatus | null>(null)
const $noWorktrees = atom<HermesGitWorktree[]>(EMPTY_WORKTREES)

/** Reactive status for one repo cwd (a tile's worktree). Stable per cwd. */
export function repoStatusForCwd(cwd?: null | string): ReadableAtom<HermesRepoStatus | null> {
  const key = normalizeCwd(cwd)

  if (!key) {
    return $noRepoStatus
  }

  let $slice = statusAtomByCwd.get(key)

  if (!$slice) {
    $slice = computed($repoStatusByCwd, byCwd => byCwd[key] ?? null)
    statusAtomByCwd.set(key, $slice)
  }

  return $slice
}

/**
 * Is this path a git repo? This function reads the probe cache, and probes on
 * demand when the cache has no entry for the path. Use it to validate any repo
 * that was picked out of candidate FOLDERS: a path in a project row is not
 * evidence that git can branch from it. On a remote gateway the probe is
 * backend-routed (`desktopGit()` returns the REST mirror), so a VPS path is
 * judged by the VPS's git — not by this machine's filesystem (#81724).
 */
export async function isGitRepoPath(cwd: string): Promise<boolean> {
  const key = normalizeCwd(cwd)

  if (!key) {
    return false
  }

  if (key in $repoStatusByCwd.get()) {
    return $repoStatusByCwd.get()[key] !== null
  }

  if (!desktopGit()?.repoStatus) {
    return false
  }

  await refreshRepoStatus(key)

  return ($repoStatusByCwd.get()[key] ?? null) !== null
}

/** Reactive worktree list for one repo cwd. Stable per cwd. */
export function repoWorktreesForCwd(cwd?: null | string): ReadableAtom<HermesGitWorktree[]> {
  const key = normalizeCwd(cwd)

  if (!key) {
    return $noWorktrees
  }

  let $slice = worktreesAtomByCwd.get(key)

  if (!$slice) {
    $slice = computed($repoWorktreesByCwd, byCwd => byCwd[key] ?? EMPTY_WORKTREES)
    worktreesAtomByCwd.set(key, $slice)
  }

  return $slice
}

export type RepoChangeKind = 'added' | 'conflicted' | 'modified'

// Absolute file path → its git change kind, for VS Code-style file-tree tinting.
// Reuses the same bounded $repoStatus probe (capped file list); git reports
// repo-root-relative paths, so we join them onto the active cwd. Deletions never
// appear — the file is gone from disk, so there's no tree row to tint.
export const $repoChangeByPath = computed([$repoStatus, $currentCwd], (status, cwd) => {
  const map = new Map<string, RepoChangeKind>()
  const root = (cwd || '').replace(/[/\\]+$/, '')

  if (!status || !root) {
    return map
  }

  for (const file of status.files) {
    const kind: RepoChangeKind = file.conflicted ? 'conflicted' : file.untracked ? 'added' : 'modified'
    map.set(`${root}/${file.path}`, kind)
  }

  return map
})

/**
 * Per-row Git decoration subscription. A visible file row reads one scalar, so
 * a fresh repo-status map only re-renders that row when its own kind changed.
 */
export function repoChangeKindForPath(path: string): ReadableAtom<RepoChangeKind | undefined> {
  return computed($repoChangeByPath, changes => changes.get(path))
}

// Cwds whose rails are on screen right now (refcounted — two tiles in one
// worktree register it twice). Every refresh edge re-probes each registered
// cwd plus the primary workspace, so a tile's rail moves when ITS agent
// touches the tree — not only when main's does.
const registeredCwds = new Map<string, number>()

/** Keep `cwd` in the refresh set while its rail is mounted. Returns a release
 *  (undefined for a blank cwd), kicking off an immediate probe on register. */
export function registerRepoStatusCwd(cwd?: null | string): (() => void) | undefined {
  const key = normalizeCwd(cwd)

  if (!key) {
    return undefined
  }

  registeredCwds.set(key, (registeredCwds.get(key) ?? 0) + 1)
  scheduleRepoStatusRefresh(key)

  let released = false

  return () => {
    if (released) {
      return
    }

    released = true
    const count = registeredCwds.get(key) ?? 0

    if (count <= 1) {
      registeredCwds.delete(key)
    } else {
      registeredCwds.set(key, count - 1)
    }
  }
}

function setRepoStatusEntry(target: string, status: HermesRepoStatus | null): void {
  const byCwd = $repoStatusByCwd.get()

  // Skip the no-op null→null write so a repeated failed probe doesn't churn
  // every rail's computed slice.
  if (target in byCwd && byCwd[target] === status) {
    return
  }

  $repoStatusByCwd.set({ ...byCwd, [target]: status })
}

function setRepoWorktreesEntry(target: string, worktrees: HermesGitWorktree[]): void {
  const byCwd = $repoWorktreesByCwd.get()

  if (target in byCwd && byCwd[target] === worktrees) {
    return
  }

  $repoWorktreesByCwd.set({ ...byCwd, [target]: worktrees })
}

interface RepoStatusRefreshRequest {
  probe: (cwd: string) => Promise<HermesRepoStatus | null>
  seq: number
  target: string
}

// Coalesce overlapping probes: many triggers can fire around a turn boundary
// (busy flip + worktree token + focus), and several worktrees can need a
// re-probe at once. Keep ONE probe in flight and at most one trailing request
// per cwd so a slow `git status` cannot multiply into an unbounded subprocess
// pile-up.
const seqByCwd = new Map<string, number>()
const pendingByCwd = new Map<string, RepoStatusRefreshRequest>()
let repoStatusRefreshInFlight: Promise<void> | null = null
let repoStatusRefreshTimer: ReturnType<typeof setTimeout> | null = null
const scheduledCwds = new Set<string>()
let scheduledAllTargets = false

// A result only lands while it is still the newest request for ITS cwd. The
// debounce below deliberately delays the next probe; without this live check,
// an old probe can land during that gap and briefly make a session look like
// it is on a stale branch.
const isCurrentSeq = (target: string, seq: number): boolean => seqByCwd.get(target) === seq

async function loadWorktrees(target: string, seq: number): Promise<void> {
  const list = desktopGit()?.worktreeList

  if (!list) {
    setRepoWorktreesEntry(target, EMPTY_WORKTREES)

    return
  }

  try {
    const worktrees = await list(target)

    if (isCurrentSeq(target, seq)) {
      setRepoWorktreesEntry(target, worktrees)
    }
  } catch {
    if (isCurrentSeq(target, seq)) {
      setRepoWorktreesEntry(target, EMPTY_WORKTREES)
    }
  }
}

/**
 * Re-probe the working tree for one cwd. Best-effort: a non-repo, a remote
 * backend, or a missing probe clears that cwd's entry so its rail hides
 * rather than showing stale data.
 */
async function runRepoStatusRefresh({ probe, seq, target }: RepoStatusRefreshRequest): Promise<void> {
  try {
    const status = await probe(target)

    // Drop the result if a newer refresh for this cwd started while we were
    // probing — the newer probe owns the entry.
    if (!isCurrentSeq(target, seq)) {
      return
    }

    setRepoStatusEntry(target, status)

    // Worktrees only matter inside a repo; clear them otherwise.
    if (status) {
      void loadWorktrees(target, seq)
    } else {
      setRepoWorktreesEntry(target, EMPTY_WORKTREES)
    }
  } catch {
    if (isCurrentSeq(target, seq)) {
      setRepoStatusEntry(target, null)
      setRepoWorktreesEntry(target, EMPTY_WORKTREES)
    }
  }
}

async function drainRepoStatusRefreshes(): Promise<void> {
  while (pendingByCwd.size > 0) {
    const [target, request] = pendingByCwd.entries().next().value as [string, RepoStatusRefreshRequest]

    pendingByCwd.delete(target)
    await runRepoStatusRefresh(request)
  }

  // This reset is synchronous with the final empty-queue check. A refresh
  // arriving before this continuation runs is drained above; one arriving
  // afterward sees no in-flight promise and starts a new drain.
  repoStatusRefreshInFlight = null
  $repoStatusLoading.set(false)
}

export function refreshRepoStatus(cwd?: null | string): Promise<void> {
  const target = normalizeCwd(cwd ?? $currentCwd.get())
  const probe = desktopGit()?.repoStatus

  if (!probe) {
    // Remote backend / no bridge: there is no local git truth at all — wipe
    // every entry so no rail shows stale local status, and invalidate any
    // in-flight probe results.
    pendingByCwd.clear()
    seqByCwd.clear()
    $repoStatusByCwd.set({})
    $repoWorktreesByCwd.set({})
    $repoStatusLoading.set(false)

    return repoStatusRefreshInFlight || Promise.resolve()
  }

  if (!target) {
    // No cwd (a detached fresh chat). The primary computed already reads null
    // for a blank cwd, and other worktrees' entries stay valid.
    return repoStatusRefreshInFlight || Promise.resolve()
  }

  const seq = (seqByCwd.get(target) ?? 0) + 1

  seqByCwd.set(target, seq)
  pendingByCwd.set(target, { probe, seq, target })
  $repoStatusLoading.set(true)

  if (!repoStatusRefreshInFlight) {
    repoStatusRefreshInFlight = drainRepoStatusRefreshes()
  }

  return repoStatusRefreshInFlight
}

/** Registered (on-screen) worktrees + the primary workspace. */
function refreshTargets(): Set<string> {
  const targets = new Set(registeredCwds.keys())
  const primary = normalizeCwd($currentCwd.get())

  if (primary) {
    targets.add(primary)
  }

  return targets
}

/** Re-probe every on-screen worktree (and the primary). Awaits the drain. */
export async function refreshAllRepoStatuses(): Promise<void> {
  const targets = refreshTargets()

  if (targets.size === 0) {
    return
  }

  // Queue every target, then await the single in-flight drain once.
  let last: Promise<void> = Promise.resolve()

  for (const target of targets) {
    last = refreshRepoStatus(target)
  }

  await last
}

// `cwd` scopes the refresh to one worktree; omit it to re-probe every
// on-screen worktree (turn settle, window focus — the tree may have changed
// under any of them).
function scheduleRepoStatusRefresh(cwd?: null | string): void {
  if (cwd === undefined) {
    scheduledAllTargets = true
  } else {
    const key = normalizeCwd(cwd)

    if (key) {
      scheduledCwds.add(key)
    }
  }

  if (repoStatusRefreshTimer) {
    clearTimeout(repoStatusRefreshTimer)
  }

  repoStatusRefreshTimer = setTimeout(() => {
    repoStatusRefreshTimer = null
    const targets = new Set(scheduledCwds)

    if (scheduledAllTargets) {
      for (const target of refreshTargets()) {
        targets.add(target)
      }
    }

    scheduledCwds.clear()
    scheduledAllTargets = false

    for (const target of targets) {
      void refreshRepoStatus(target)
    }
  }, REPO_STATUS_REFRESH_DEBOUNCE_MS)
}

// ── Triggers ─────────────────────────────────────────────────────────────────
// Wired once at module load (mirrors projects.ts's module-scope subscriptions).
// Each is a structural edge where a working tree may have changed under us.

// The active session's cwd changed (session switch / new chat) → the primary
// computed re-keys instantly (a keyboard action in the switch-to-probe gap can
// only ever see the NEW repo's last-known facts, never the previous
// worktree's), then the debounced probe refreshes that repo's truth.
$currentCwd.subscribe(cwd => scheduleRepoStatusRefresh(cwd))

// Switching sessions can land on the same cwd but a different checked-out
// branch (the agent ran `git checkout` in another session's terminal). The cwd
// subscription above won't fire when the path is identical, so the branch label
// would stay stale until a window focus or turn-settle triggers a refresh.
// Treat the stored-session id as a structural edge in its own right.
$selectedStoredSessionId.subscribe(() => scheduleRepoStatusRefresh())

// A worktree add/remove (desktop op, or the agent's out-of-band git in a settled
// turn / a window refocus — both already bump this token) → re-probe.
$worktreeRefreshToken.subscribe(() => scheduleRepoStatusRefresh())

// A file-mutating tool finished (event-driven, not polled) → re-probe so the
// rails' branch/+/- move exactly when an agent touches a tree. Unscoped on
// purpose: the tool may belong to a background tile's session, so every
// on-screen worktree re-probes, not just the primary.
$workspaceChangeTick.subscribe(() => scheduleRepoStatusRefresh())

// A turn settling is the backstop for changes no tool diff announced (e.g. a
// raw `git` in the terminal): one final refresh when the agent goes idle.
let prevBusy = $busy.get()

$busy.subscribe(busy => {
  if (prevBusy && !busy) {
    scheduleRepoStatusRefresh()
  }

  prevBusy = busy
})

// Window focus: external changes while we were away (an outside terminal).
if (typeof window !== 'undefined') {
  window.addEventListener('focus', () => scheduleRepoStatusRefresh())
}

/** Test-only: drop in-flight / pending / registered state so cases don't leak. */
export function _resetCodingStatusForTests(): void {
  if (repoStatusRefreshTimer) {
    clearTimeout(repoStatusRefreshTimer)
    repoStatusRefreshTimer = null
  }

  scheduledCwds.clear()
  scheduledAllTargets = false
  pendingByCwd.clear()
  seqByCwd.clear()
  registeredCwds.clear()
  repoStatusRefreshInFlight = null
  $repoStatusByCwd.set({})
  $repoWorktreesByCwd.set({})
  $repoStatusLoading.set(false)
}

// ── New-worktree target resolution ───────────────────────────────────────────
// This code lives here and not in projects.ts. To pick the target, it must read
// both the project state and the git truth, and coding-status already depends
// on projects. A dependency in the other direction is a cycle.

// The repo that a new worktree is cut from: the cwd of the focused surface, or
// the root of the project the user entered. Both are things the user points at.
// There is no "use some other project's repo" step, because that branches
// somewhere the user never selected.
//
// A project root is not always a repo, so existence alone is not proof. Each
// candidate is validated against the probe cache. This function is the only
// authority on the target, so the hotkey no longer tests `$repoStatus` first,
// and ⌘⇧B now works from a detached session inside a project. '' means that no
// repo is in reach. That is a no-op and not an error, because a worktree only
// exists inside a repo.
export async function resolveWorktreeRepoPath(): Promise<string> {
  const runtimeId = $focusedRuntimeId.get()
  const scope = $projectScope.get()

  const candidates = [
    runtimeId ? ($sessionStates.get()[runtimeId]?.cwd ?? '') : '',
    scope === ALL_PROJECTS ? '' : projectRootCwd($projectTree.get().find(node => node.id === scope))
  ]

  for (const candidate of candidates) {
    const path = candidate.trim()

    if (path && (await isGitRepoPath(path))) {
      return path
    }
  }

  return ''
}

export async function openWorktreeDialog(options?: { base?: string; repoPath?: string }): Promise<void> {
  const repoPath = options?.repoPath?.trim() || (await resolveWorktreeRepoPath())

  if (repoPath) {
    $worktreeDialog.set({ base: options?.base, repoPath })
  }
}

	import { atom, computed, type ReadableAtom } from 'nanostores'

	import type { HermesGitWorktree, HermesRepoStatus } from '@/global'
	import { desktopGit } from '@/lib/desktop-git'

	import {
	$projectScope,
	$projectTree,
	$worktreeDialog,
	$worktreeRefreshToken,
	ALL_PROJECTS,
	projectRootCwd
	} from './projects'
	import {
	$busy,
	$currentCwd,
	$selectedStoredSessionId,
	$workspaceCwdOwner,
	workspaceCwdBelongsToSelectedSession
	} from './session'
	import { $focusedRuntimeId, $sessionStates } from './session-states'
	import { $workspaceChangeTick } from './workspace-events'

	// Live working-tree status for every git surface on screen — the data backbone
	// of the composer coding rail. Keyed PER CWD: the main pane and each session
	// tile can sit in different worktrees, so a single global status would paint
	// the primary repo's branch/± onto every rail (the "tile shows main's diff"
	// bug). It's the same "cheaply re-read git truth at the right moments" model
	// as the sidebar worktree probe: a single bounded `git status --porcelain=v2`
	// per on-screen worktree per refresh, driven by structural edges (cwd change,
	// turn settle, window focus, worktree mutation), never per-token and never
	// touching the conversation/system-prompt cache.

	const REPO_STATUS_REFRESH_DEBOUNCE_MS = 100

	const normalizeCwd = (cwd?: null \| string): null \| string => cwd?.trim() \|\| null

	const EMPTY_WORKTREES: HermesGitWorktree[] = []

	// Status + worktrees per normalized cwd. Entries outlive their surface (the
	// map stays bounded by the worktrees touched this run) so re-opening a tile
	// paints its last-known status instantly while the fresh probe runs.
	export const $repoStatusByCwd = atom<Record<string, HermesRepoStatus \| null>>({})
	export const $repoWorktreesByCwd = atom<Record<string, HermesGitWorktree[]>>({})

	// The PRIMARY (main pane) view — the active session's slice of the per-cwd
	// truth. Existing consumers (keybind gate, base-branch picker, file tree) keep
	// reading these; only surfaces that can live in ANOTHER worktree (tile rails)
	// need the per-cwd accessors below. During a conversation switch `$currentCwd`
	// can still name the previous conversation's path, so ownership hides only this
	// primary slice; the per-cwd cache stays available to any tile that genuinely
	// owns that worktree (#71254).
	export const $repoStatus: ReadableAtom<HermesRepoStatus \| null> = computed(
	[$repoStatusByCwd, $currentCwd, $selectedStoredSessionId, $workspaceCwdOwner],
	(byCwd, cwd) => (workspaceCwdBelongsToSelectedSession() ? (byCwd[normalizeCwd(cwd) ?? ''] ?? null) : null)
	)

	export const $repoStatusLoading = atom(false)

	// The repo's real worktrees (for the coding rail's "jump to a worktree" menu).
	// Refreshed on the same edges as the status probe; empty off a repo.
	export const $repoWorktrees: ReadableAtom<HermesGitWorktree[]> = computed(
	[$repoWorktreesByCwd, $currentCwd, $selectedStoredSessionId, $workspaceCwdOwner],
	(byCwd, cwd) =>
	workspaceCwdBelongsToSelectedSession() ? (byCwd[normalizeCwd(cwd) ?? ''] ?? EMPTY_WORKTREES) : EMPTY_WORKTREES
	)

	// Reference-stable per-cwd slices, so any number of rails can each subscribe
	// to their own worktree's status without re-deriving atoms per render.
	const statusAtomByCwd = new Map<string, ReadableAtom<HermesRepoStatus \| null>>()
	const worktreesAtomByCwd = new Map<string, ReadableAtom<HermesGitWorktree[]>>()
	const $noRepoStatus = atom<HermesRepoStatus \| null>(null)
	const $noWorktrees = atom<HermesGitWorktree[]>(EMPTY_WORKTREES)

	/** Reactive status for one repo cwd (a tile's worktree). Stable per cwd. */
	export function repoStatusForCwd(cwd?: null \| string): ReadableAtom<HermesRepoStatus \| null> {
	const key = normalizeCwd(cwd)

	if (!key) {
	return $noRepoStatus
	}

	let $slice = statusAtomByCwd.get(key)

	if (!$slice) {
	$slice = computed($repoStatusByCwd, byCwd => byCwd[key] ?? null)
	statusAtomByCwd.set(key, $slice)
	}

	return $slice
	}

	/**
	* Is this path a git repo? This function reads the probe cache, and probes on
	* demand when the cache has no entry for the path. Use it to validate any repo
	* that was picked out of candidate FOLDERS: a path in a project row is not
	* evidence that git can branch from it. On a remote gateway the probe is
	* backend-routed (`desktopGit()` returns the REST mirror), so a VPS path is
	* judged by the VPS's git — not by this machine's filesystem (#81724).
	*/
	export async function isGitRepoPath(cwd: string): Promise<boolean> {
	const key = normalizeCwd(cwd)

	if (!key) {
	return false
	}

	if (key in $repoStatusByCwd.get()) {
	return $repoStatusByCwd.get()[key] !== null
	}

	if (!desktopGit()?.repoStatus) {
	return false
	}

	await refreshRepoStatus(key)

	return ($repoStatusByCwd.get()[key] ?? null) !== null
	}

	/** Reactive worktree list for one repo cwd. Stable per cwd. */
	export function repoWorktreesForCwd(cwd?: null \| string): ReadableAtom<HermesGitWorktree[]> {
	const key = normalizeCwd(cwd)

	if (!key) {
	return $noWorktrees
	}

	let $slice = worktreesAtomByCwd.get(key)

	if (!$slice) {
	$slice = computed($repoWorktreesByCwd, byCwd => byCwd[key] ?? EMPTY_WORKTREES)
	worktreesAtomByCwd.set(key, $slice)
	}

	return $slice
	}

	export type RepoChangeKind = 'added' \| 'conflicted' \| 'modified'

	// Absolute file path → its git change kind, for VS Code-style file-tree tinting.
	// Reuses the same bounded $repoStatus probe (capped file list); git reports
	// repo-root-relative paths, so we join them onto the active cwd. Deletions never
	// appear — the file is gone from disk, so there's no tree row to tint.
	export const $repoChangeByPath = computed([$repoStatus, $currentCwd], (status, cwd) => {
	const map = new Map<string, RepoChangeKind>()
	const root = (cwd \|\| '').replace(/[/\\]+$/, '')

	if (!status \|\| !root) {
	return map
	}

	for (const file of status.files) {
	const kind: RepoChangeKind = file.conflicted ? 'conflicted' : file.untracked ? 'added' : 'modified'
	map.set(`${root}/${file.path}`, kind)
	}

	return map
	})

	/**
	* Per-row Git decoration subscription. A visible file row reads one scalar, so
	* a fresh repo-status map only re-renders that row when its own kind changed.
	*/
	export function repoChangeKindForPath(path: string): ReadableAtom<RepoChangeKind \| undefined> {
	return computed($repoChangeByPath, changes => changes.get(path))
	}

	// Cwds whose rails are on screen right now (refcounted — two tiles in one
	// worktree register it twice). Every refresh edge re-probes each registered
	// cwd plus the primary workspace, so a tile's rail moves when ITS agent
	// touches the tree — not only when main's does.
	const registeredCwds = new Map<string, number>()

	/** Keep `cwd` in the refresh set while its rail is mounted. Returns a release
	* (undefined for a blank cwd), kicking off an immediate probe on register. */
	export function registerRepoStatusCwd(cwd?: null \| string): (() => void) \| undefined {
	const key = normalizeCwd(cwd)

	if (!key) {
	return undefined
	}

	registeredCwds.set(key, (registeredCwds.get(key) ?? 0) + 1)
	scheduleRepoStatusRefresh(key)

	let released = false

	return () => {
	if (released) {
	return
	}

	released = true
	const count = registeredCwds.get(key) ?? 0

	if (count <= 1) {
	registeredCwds.delete(key)
	} else {
	registeredCwds.set(key, count - 1)
	}
	}
	}

	function setRepoStatusEntry(target: string, status: HermesRepoStatus \| null): void {
	const byCwd = $repoStatusByCwd.get()

	// Skip the no-op null→null write so a repeated failed probe doesn't churn
	// every rail's computed slice.
	if (target in byCwd && byCwd[target] === status) {
	return
	}

	$repoStatusByCwd.set({ ...byCwd, [target]: status })
	}

	function setRepoWorktreesEntry(target: string, worktrees: HermesGitWorktree[]): void {
	const byCwd = $repoWorktreesByCwd.get()

	if (target in byCwd && byCwd[target] === worktrees) {
	return
	}

	$repoWorktreesByCwd.set({ ...byCwd, [target]: worktrees })
	}

	interface RepoStatusRefreshRequest {
	probe: (cwd: string) => Promise<HermesRepoStatus \| null>
	seq: number
	target: string
	}

	// Coalesce overlapping probes: many triggers can fire around a turn boundary
	// (busy flip + worktree token + focus), and several worktrees can need a
	// re-probe at once. Keep ONE probe in flight and at most one trailing request
	// per cwd so a slow `git status` cannot multiply into an unbounded subprocess
	// pile-up.
	const seqByCwd = new Map<string, number>()
	const pendingByCwd = new Map<string, RepoStatusRefreshRequest>()
	let repoStatusRefreshInFlight: Promise<void> \| null = null
	let repoStatusRefreshTimer: ReturnType<typeof setTimeout> \| null = null
	const scheduledCwds = new Set<string>()
	let scheduledAllTargets = false

	// A result only lands while it is still the newest request for ITS cwd. The
	// debounce below deliberately delays the next probe; without this live check,
	// an old probe can land during that gap and briefly make a session look like
	// it is on a stale branch.
	const isCurrentSeq = (target: string, seq: number): boolean => seqByCwd.get(target) === seq

	async function loadWorktrees(target: string, seq: number): Promise<void> {
	const list = desktopGit()?.worktreeList

	if (!list) {
	setRepoWorktreesEntry(target, EMPTY_WORKTREES)

	return
	}

	try {
	const worktrees = await list(target)

	if (isCurrentSeq(target, seq)) {
	setRepoWorktreesEntry(target, worktrees)
	}
	} catch {
	if (isCurrentSeq(target, seq)) {
	setRepoWorktreesEntry(target, EMPTY_WORKTREES)
	}
	}
	}

	/**
	* Re-probe the working tree for one cwd. Best-effort: a non-repo, a remote
	* backend, or a missing probe clears that cwd's entry so its rail hides
	* rather than showing stale data.
	*/
	async function runRepoStatusRefresh({ probe, seq, target }: RepoStatusRefreshRequest): Promise<void> {
	try {
	const status = await probe(target)

	// Drop the result if a newer refresh for this cwd started while we were
	// probing — the newer probe owns the entry.
	if (!isCurrentSeq(target, seq)) {
	return
	}

	setRepoStatusEntry(target, status)

	// Worktrees only matter inside a repo; clear them otherwise.
	if (status) {
	void loadWorktrees(target, seq)
	} else {
	setRepoWorktreesEntry(target, EMPTY_WORKTREES)
	}
	} catch {
	if (isCurrentSeq(target, seq)) {
	setRepoStatusEntry(target, null)
	setRepoWorktreesEntry(target, EMPTY_WORKTREES)
	}
	}
	}

	async function drainRepoStatusRefreshes(): Promise<void> {
	while (pendingByCwd.size > 0) {
	const [target, request] = pendingByCwd.entries().next().value as [string, RepoStatusRefreshRequest]

	pendingByCwd.delete(target)
	await runRepoStatusRefresh(request)
	}

	// This reset is synchronous with the final empty-queue check. A refresh
	// arriving before this continuation runs is drained above; one arriving
	// afterward sees no in-flight promise and starts a new drain.
	repoStatusRefreshInFlight = null
	$repoStatusLoading.set(false)
	}

	export function refreshRepoStatus(cwd?: null \| string): Promise<void> {
	const target = normalizeCwd(cwd ?? $currentCwd.get())
	const probe = desktopGit()?.repoStatus

	if (!probe) {
	// Remote backend / no bridge: there is no local git truth at all — wipe
	// every entry so no rail shows stale local status, and invalidate any
	// in-flight probe results.
	pendingByCwd.clear()
	seqByCwd.clear()
	$repoStatusByCwd.set({})
	$repoWorktreesByCwd.set({})
	$repoStatusLoading.set(false)

	return repoStatusRefreshInFlight \|\| Promise.resolve()
	}

	if (!target) {
	// No cwd (a detached fresh chat). The primary computed already reads null
	// for a blank cwd, and other worktrees' entries stay valid.
	return repoStatusRefreshInFlight \|\| Promise.resolve()
	}

	const seq = (seqByCwd.get(target) ?? 0) + 1

	seqByCwd.set(target, seq)
	pendingByCwd.set(target, { probe, seq, target })
	$repoStatusLoading.set(true)

	if (!repoStatusRefreshInFlight) {
	repoStatusRefreshInFlight = drainRepoStatusRefreshes()
	}

	return repoStatusRefreshInFlight
	}

	/** Registered (on-screen) worktrees + the primary workspace. */
	function refreshTargets(): Set<string> {
	const targets = new Set(registeredCwds.keys())
	const primary = normalizeCwd($currentCwd.get())

	if (primary) {
	targets.add(primary)
	}

	return targets
	}

	/** Re-probe every on-screen worktree (and the primary). Awaits the drain. */
	export async function refreshAllRepoStatuses(): Promise<void> {
	const targets = refreshTargets()

	if (targets.size === 0) {
	return
	}

	// Queue every target, then await the single in-flight drain once.
	let last: Promise<void> = Promise.resolve()

	for (const target of targets) {
	last = refreshRepoStatus(target)
	}

	await last
	}

	// `cwd` scopes the refresh to one worktree; omit it to re-probe every
	// on-screen worktree (turn settle, window focus — the tree may have changed
	// under any of them).
	function scheduleRepoStatusRefresh(cwd?: null \| string): void {
	if (cwd === undefined) {
	scheduledAllTargets = true
	} else {
	const key = normalizeCwd(cwd)

	if (key) {
	scheduledCwds.add(key)
	}
	}

	if (repoStatusRefreshTimer) {
	clearTimeout(repoStatusRefreshTimer)
	}

	repoStatusRefreshTimer = setTimeout(() => {
	repoStatusRefreshTimer = null
	const targets = new Set(scheduledCwds)

	if (scheduledAllTargets) {
	for (const target of refreshTargets()) {
	targets.add(target)
	}
	}

	scheduledCwds.clear()
	scheduledAllTargets = false

	for (const target of targets) {
	void refreshRepoStatus(target)
	}
	}, REPO_STATUS_REFRESH_DEBOUNCE_MS)
	}

	// ── Triggers ─────────────────────────────────────────────────────────────────
	// Wired once at module load (mirrors projects.ts's module-scope subscriptions).
	// Each is a structural edge where a working tree may have changed under us.

	// The active session's cwd changed (session switch / new chat) → the primary
	// computed re-keys instantly (a keyboard action in the switch-to-probe gap can
	// only ever see the NEW repo's last-known facts, never the previous
	// worktree's), then the debounced probe refreshes that repo's truth.
	$currentCwd.subscribe(cwd => scheduleRepoStatusRefresh(cwd))

	// Switching sessions can land on the same cwd but a different checked-out
	// branch (the agent ran `git checkout` in another session's terminal). The cwd
	// subscription above won't fire when the path is identical, so the branch label
	// would stay stale until a window focus or turn-settle triggers a refresh.
	// Treat the stored-session id as a structural edge in its own right.
	$selectedStoredSessionId.subscribe(() => scheduleRepoStatusRefresh())

	// A worktree add/remove (desktop op, or the agent's out-of-band git in a settled
	// turn / a window refocus — both already bump this token) → re-probe.
	$worktreeRefreshToken.subscribe(() => scheduleRepoStatusRefresh())

	// A file-mutating tool finished (event-driven, not polled) → re-probe so the
	// rails' branch/+/- move exactly when an agent touches a tree. Unscoped on
	// purpose: the tool may belong to a background tile's session, so every
	// on-screen worktree re-probes, not just the primary.
	$workspaceChangeTick.subscribe(() => scheduleRepoStatusRefresh())

	// A turn settling is the backstop for changes no tool diff announced (e.g. a
	// raw `git` in the terminal): one final refresh when the agent goes idle.
	let prevBusy = $busy.get()

	$busy.subscribe(busy => {
	if (prevBusy && !busy) {
	scheduleRepoStatusRefresh()
	}

	prevBusy = busy
	})

	// Window focus: external changes while we were away (an outside terminal).
	if (typeof window !== 'undefined') {
	window.addEventListener('focus', () => scheduleRepoStatusRefresh())
	}

	/** Test-only: drop in-flight / pending / registered state so cases don't leak. */
	export function _resetCodingStatusForTests(): void {
	if (repoStatusRefreshTimer) {
	clearTimeout(repoStatusRefreshTimer)
	repoStatusRefreshTimer = null
	}

	scheduledCwds.clear()
	scheduledAllTargets = false
	pendingByCwd.clear()
	seqByCwd.clear()
	registeredCwds.clear()
	repoStatusRefreshInFlight = null
	$repoStatusByCwd.set({})
	$repoWorktreesByCwd.set({})
	$repoStatusLoading.set(false)
	}

	// ── New-worktree target resolution ───────────────────────────────────────────
	// This code lives here and not in projects.ts. To pick the target, it must read
	// both the project state and the git truth, and coding-status already depends
	// on projects. A dependency in the other direction is a cycle.

	// The repo that a new worktree is cut from: the cwd of the focused surface, or
	// the root of the project the user entered. Both are things the user points at.
	// There is no "use some other project's repo" step, because that branches
	// somewhere the user never selected.
	//
	// A project root is not always a repo, so existence alone is not proof. Each
	// candidate is validated against the probe cache. This function is the only
	// authority on the target, so the hotkey no longer tests `$repoStatus` first,
	// and ⌘⇧B now works from a detached session inside a project. '' means that no
	// repo is in reach. That is a no-op and not an error, because a worktree only
	// exists inside a repo.
	export async function resolveWorktreeRepoPath(): Promise<string> {
	const runtimeId = $focusedRuntimeId.get()
	const scope = $projectScope.get()

	const candidates = [
	runtimeId ? ($sessionStates.get()[runtimeId]?.cwd ?? '') : '',
	scope === ALL_PROJECTS ? '' : projectRootCwd($projectTree.get().find(node => node.id === scope))
	]

	for (const candidate of candidates) {
	const path = candidate.trim()

	if (path && (await isGitRepoPath(path))) {
	return path
	}
	}

	return ''
	}

	export async function openWorktreeDialog(options?: { base?: string; repoPath?: string }): Promise<void> {
	const repoPath = options?.repoPath?.trim() \|\| (await resolveWorktreeRepoPath())

	if (repoPath) {
	$worktreeDialog.set({ base: options?.base, repoPath })
	}
	}