@young1lin/dsh-ui-gitworkbench 0.1.3 → 0.1.5

package/src/client/active-file.ts

@@ -0,0 +1,83 @@
+/**
+ * Which file a view opens on.
+ *
+ * The drawer keeps ONE selected path across commits, so walking down a
+ * filtered history is meant to be a walk through one file's life. That only
+ * works if the fallback — what happens when the selection is not in the
+ * commit you just clicked — knows about the path filter. It did not: the
+ * fallback was `files[0]`, so filtering by `xx/aa/dd.ts` and clicking a
+ * commit opened whatever sorted first in that commit, and the file the
+ * filter was ABOUT sat unhighlighted somewhere down the tree.
+ *
+ * Pure and React-free so it can be tested; the panel only wires it up.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/active-file
+ */
+
+/** Just the field this module reads off the view's file list. */
+export interface PathLike {
+  readonly path: string
+}
+
+/** No filter — a shared empty so callers keep a stable reference. */
+export const NO_PATHS: readonly string[] = []
+
+/**
+ * Whether a file is what a pathspec selected: the file itself, or anything in
+ * its subtree.
+ *
+ * A pathspec from the picker is either a file path or a directory path with no
+ * trailing slash (`dir.path` / the file's full path — `path-select.ts`), and
+ * the two cases are told apart by the file rather than by the spec: `===` is
+ * the file, `spec + '/'` prefix is the subtree. Guessing which KIND a spec is
+ * from its string alone is what a trailing-slash convention would force, and
+ * it would be wrong for any file without an extension.
+ */
+function covers(spec: string, path: string): boolean {
+  return path === spec || path.startsWith(`${spec}/`)
+}
+
+/**
+ * The file a view should highlight.
+ *
+ * The order of preference, and why it is this order:
+ *
+ * 1. **The selection, if this view has it.** Stepping down a filtered list is
+ *    the whole point of filtering; changing the file under the reader every
+ *    time they move a row would undo it. This also means an explicit click
+ *    outranks the filter — the reader looked somewhere on purpose.
+ * 2. **A file the filter names EXACTLY.** Ticking `xx/aa/dd.ts` is a statement
+ *    about that file; ticking `xx` is a statement about a region. When a
+ *    commit touches both kinds, the named file is the more specific intent, so
+ *    it wins. (The two can only coexist across disjoint trees: the picker's
+ *    invariant is that no ticked path covers another.)
+ * 3. **A file under a filtered directory.**
+ * 4. **The first file.** No filter, or nothing in this commit matched it —
+ *    the behaviour before any of this existed.
+ *
+ * Ties inside 2 and 3 go to the commit's own file order, which is the order
+ * the tree renders: the highlight lands on the topmost matching row, so it is
+ * where the reader is already looking and never needs a scroll to find. The
+ * alternative — first match in FILTER order — would be arbitrary, since that
+ * order is an artifact of the sequence the boxes were ticked in and is never
+ * shown anywhere.
+ *
+ * @param files - the view's files, in the order the tree shows them.
+ * @param filterPaths - active path filter; empty on views that have none.
+ * @param previous - the currently selected path, or null.
+ * @returns the path to highlight, or null when there are no files at all.
+ */
+export function preferredFile(
+  files: readonly PathLike[],
+  filterPaths: readonly string[],
+  previous: string | null,
+): string | null {
+  if (previous !== null && files.some(file => file.path === previous)) return previous
+  if (filterPaths.length > 0) {
+    const exact = files.find(file => filterPaths.some(spec => file.path === spec))
+    if (exact !== undefined) return exact.path
+    const under = files.find(file => filterPaths.some(spec => covers(spec, file.path)))
+    if (under !== undefined) return under.path
+  }
+  return files[0]?.path ?? null
+}

package/src/client/calendar.ts

@@ -0,0 +1,99 @@
+/**
+ * The pure arithmetic of the filter's calendar.
+ *
+ * A month is a fixed 6×7 grid, Monday-first: a stable height whatever the
+ * month (no layout jump when February needs four rows), with neighbouring
+ * months' days filling the lead-in and tail — greyed, still clickable, the
+ * way every modern calendar behaves. Everything here is pure and takes
+ * `todayIso` explicitly so tests are deterministic.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/calendar
+ */
+
+/** One day cell. `null` where the grid has no day at all (never, at 6×7). */
+export interface CalendarCell {
+  /** The day, `yyyy-mm-dd` — the grammar the filter speaks end to end. */
+  readonly iso: string
+  /** Day-of-month number shown in the cell. */
+  readonly day: number
+  /** Whether the cell belongs to the displayed month. */
+  readonly inMonth: boolean
+  /** Whether the cell is the supplied today. */
+  readonly isToday: boolean
+}
+
+const DAY_MS = 86_400_000
+
+function toIso(date: Date): string {
+  const m = String(date.getUTCMonth() + 1).padStart(2, '0')
+  const d = String(date.getUTCDate()).padStart(2, '0')
+  return `${date.getUTCFullYear()}-${m}-${d}`
+}
+
+/**
+ * The 6×7 Monday-first grid for one month.
+ * @param year - displayed year.
+ * @param month - displayed month, 0-based like `Date`.
+ * @param todayIso - what counts as today, for the accent; `''` accents nothing.
+ */
+export function monthGrid(year: number, month: number, todayIso: string): readonly (readonly (CalendarCell | null)[])[] {
+  // Day 1 of the month, at a UTC midnight so arithmetic never drifts an hour.
+  const first = new Date(Date.UTC(year, month, 1))
+  // getUTCDay is Sunday=0; Monday-first offset.
+  const lead = (first.getUTCDay() + 6) % 7
+  const start = new Date(first.getTime() - lead * DAY_MS)
+  const weeks: (CalendarCell | null)[][] = []
+  for (let w = 0; w < 6; w += 1) {
+    const row: (CalendarCell | null)[] = []
+    for (let d = 0; d < 7; d += 1) {
+      const date = new Date(start.getTime() + (w * 7 + d) * DAY_MS)
+      const iso = toIso(date)
+      row.push({ iso, day: date.getUTCDate(), inMonth: date.getUTCMonth() === month, isToday: iso === todayIso })
+    }
+    weeks.push(row)
+  }
+  return weeks
+}
+
+/**
+ * Single-letter weekday header row, Monday-first, via the viewer's own locale
+ * (or an explicit one, which is what the test does).
+ * @param locale - BCP 47 tag; undefined means the runtime default.
+ */
+export function weekdayLabels(locale?: string): readonly string[] {
+  // 2023-01-02..08 is a Monday..Sunday — label those, whatever the locale.
+  const labels: string[] = []
+  for (let d = 2; d <= 8; d += 1) {
+    labels.push(new Intl.DateTimeFormat(locale, { weekday: 'narrow' }).format(new Date(Date.UTC(2023, 0, d))))
+  }
+  return labels
+}
+
+/**
+ * Whether a day falls strictly BETWEEN the two bounds, so the grid can tint
+ * the span the filter admits rather than only its two endpoints.
+ *
+ * Both bounds have to be `yyyy-mm-dd` for a range to exist: the bounds also
+ * accept approxidate text (`1 week ago`), which names no grid day at all, and
+ * lexical comparison on iso dates is the same as chronological. An inverted
+ * pair (after > before) is a range git returns nothing for, and it tints
+ * nothing here for the same reason.
+ *
+ * @param iso - the cell's day.
+ * @param after - lower bound, exclusive here (it renders as an endpoint).
+ * @param before - upper bound, exclusive here.
+ */
+export function inCalRange(iso: string, after: string, before: string): boolean {
+  if (!ISO_DAY.test(after) || !ISO_DAY.test(before)) return false
+  return iso > after && iso < before
+}
+
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/
+
+/** Today as `yyyy-mm-dd` in the viewer's local timezone (for `todayIso`). */
+export function localTodayIso(): string {
+  const now = new Date()
+  const m = String(now.getMonth() + 1).padStart(2, '0')
+  const d = String(now.getDate()).padStart(2, '0')
+  return `${now.getFullYear()}-${m}-${d}`
+}

package/src/client/commit-filter.ts

@@ -0,0 +1,49 @@
+/**
+ * Exact-date rendering for the history hover card.
+ *
+ * The rows stay compact — abbreviated hash, name, "3 weeks ago" — and the
+ * details live in the hover card. An exact date cannot be derived from git's
+ * relative "%cr" prose, so the host log format carries `%cI` alongside
+ * (`src/git-log.ts`); this module renders it in the viewer's own clock.
+ *
+ * (The person-name MATCHING that once lived here is retired: history
+ * filtering is compiled into git log arguments host-side — `log-filter.ts`,
+ * `log-filter-query.ts` — so it runs over all history, not the loaded pages.)
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/commit-filter
+ */
+
+/** Options for {@link formatCommitDate}; both default to the viewer's own. */
+export interface CommitDateOptions {
+  /** BCP 47 locale for the formatter; undefined means the runtime default. */
+  readonly locale?: string
+  /** IANA timezone; undefined means the viewer's local timezone. */
+  readonly timeZone?: string
+}
+
+/**
+ * Render a commit's ISO 8601 date in full — "Aug 4, 2026, 5:30 PM", in the
+ * viewer's locale and timezone (or the overrides, which exist for tests).
+ *
+ * git's relative prose ("3 weeks ago") is right for the row and useless for
+ * the hover card, where the question is exactly WHEN. `%cI` is a strict ISO
+ * timestamp, so `new Date` parses it and the formatter renders local time —
+ * the same moment the viewer's own clock shows, which is the only timezone a
+ * hover card should speak. Unparsable input yields an empty string rather
+ * than a thrown RangeError: the card simply omits the line.
+ * @param iso - `%cI` string from the host log, possibly empty or absent.
+ * @param options - locale/timezone overrides; both optional.
+ */
+export function formatCommitDate(iso: string, options: CommitDateOptions = {}): string {
+  if (iso.length === 0) return ''
+  const date = new Date(iso)
+  if (Number.isNaN(date.getTime())) return ''
+  return new Intl.DateTimeFormat(options.locale, {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    ...(options.timeZone !== undefined ? { timeZone: options.timeZone } : {}),
+  }).format(date)
+}

package/src/client/dir-tree.ts

@@ -0,0 +1,112 @@
+/**
+ * Directory tree for the history filter's path picker, aggregated from a flat
+ * file list.
+ *
+ * The host sends `git ls-tree -r --name-only HEAD` verbatim; this module
+ * folds it into DIRECTORIES with their FILES as leaf rows — "when did this
+ * file change" is the question a file row answers, and it is the most common
+ * one. Everything is pure so the aggregation and the search are testable from
+ * a literal file list.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/dir-tree
+ */
+
+/** One directory in the picker. */
+export interface DirEntry {
+  readonly name: string
+  /** Repo-relative path — also the pathspec a tick produces. */
+  readonly path: string
+  /** Files in this SUBTREE — what ticking this row would match. */
+  readonly fileCount: number
+  /** File NAMES directly in this directory (leaf rows). */
+  readonly files: readonly string[]
+  /** Subdirectories, sorted by name. */
+  readonly children: readonly DirEntry[]
+}
+
+/** A mutable builder node; frozen into the readonly shape at the end. */
+interface BuildNode {
+  name: string
+  path: string
+  files: string[]
+  children: Map<string, BuildNode>
+}
+
+/**
+ * Fold a flat path list into a sorted directory tree carrying its files.
+ * Root-level files live on no directory; the SEARCH ({@link searchPaths}) is
+ * where they surface.
+ * @param paths - repo-relative file paths, any order, no duplicates assumed.
+ * @returns the top-level directories, children and files sorted by name.
+ */
+export function buildDirTree(paths: readonly string[]): readonly DirEntry[] {
+  const rootNode: BuildNode = { name: '', path: '', files: [], children: new Map() }
+  for (const path of paths) {
+    if (path.length === 0) continue
+    const parts = path.split('/')
+    // A trailing part is the file; every part before it must exist as a
+    // directory, whether or not any other file mentioned it.
+    let node = rootNode
+    for (let i = 0; i < parts.length - 1; i += 1) {
+      const name = parts[i]!
+      let child = node.children.get(name)
+      if (child === undefined) {
+        child = { name, path: parts.slice(0, i + 1).join('/'), files: [], children: new Map() }
+        node.children.set(name, child)
+      }
+      node = child
+    }
+    node.files.push(parts[parts.length - 1]!)
+  }
+
+  const freeze = (node: BuildNode): DirEntry => {
+    const children = [...node.children.values()].sort((a, b) => a.name.localeCompare(b.name)).map(freeze)
+    const files = [...node.files].sort((a, b) => a.localeCompare(b))
+    const subtreeCount = files.length + children.reduce((sum, child) => sum + child.fileCount, 0)
+    return { name: node.name, path: node.path, fileCount: subtreeCount, files, children }
+  }
+
+  return freeze(rootNode).children
+}
+
+/** One flat search hit: a directory or a file path, tickable as a pathspec. */
+export interface PathHit {
+  readonly path: string
+  readonly isFile: boolean
+}
+
+/**
+ * Search the repository's paths for a fragment — case-insensitive, over the
+ * full path. Results are FLAT: a search list is not a tree (the same honesty
+ * as the filtered commit list), and each hit ticks as a pathspec directly.
+ *
+ * Directories match too: every directory is some file's prefix, and ticking a
+ * directory covers its subtree — the search takes the raw path list the host
+ * sent, so root-level files and unexpanded directories are all in scope.
+ * @param paths - repo-relative file paths, exactly as `repoTree` returned.
+ * @param needle - raw search text; blank matches nothing (caller shows the tree).
+ */
+export function searchPaths(paths: readonly string[], needle: string): readonly PathHit[] {
+  const n = needle.trim().toLowerCase()
+  if (n.length === 0) return []
+  const hits: PathHit[] = []
+  const seen = new Set<string>()
+  for (const path of paths) {
+    if (path.toLowerCase().includes(n)) {
+      hits.push({ path, isFile: true })
+      seen.add(path)
+    }
+    // Every directory prefix is a candidate too; deduped via `seen`.
+    const parts = path.split('/')
+    for (let i = 1; i < parts.length; i += 1) {
+      const dir = parts.slice(0, i).join('/')
+      if (!seen.has(dir) && dir.toLowerCase().includes(n)) {
+        seen.add(dir)
+        hits.push({ path: dir, isFile: false })
+      }
+    }
+  }
+  // Files first — the common query is a file; the directory that contains it
+  // reads better below it than above.
+  return [...hits.filter(hit => hit.isFile), ...hits.filter(hit => !hit.isFile)]
+}

package/src/client/discard-flow.ts

@@ -0,0 +1,82 @@
+/**
+ * What a roll-back click does with the host's answer.
+ *
+ * The click never acts on its own: it asks the host what rolling this file
+ * back WOULD do, and this decides what the answer means. Four answers are
+ * possible and three of them used to collapse into one — the reader who
+ * clicked saw the same nothing whether the file was already clean, the host
+ * threw, or the request never arrived. "Nothing visibly happened" is the one
+ * outcome a destructive control must never produce ambiguously: it is
+ * indistinguishable from a dead button, and the natural response to a dead
+ * button is to click it again.
+ *
+ * So a failure REPORTS and a stale row REFRESHES, and those are different
+ * things. Refreshing is the honest answer to "git says this file has no
+ * changes": the row disappears, which is both the feedback and the fix, and a
+ * banner reading "nothing happened" would leave the row that caused it sitting
+ * right there. A failure has no such self-explaining fix, so it has to be said.
+ *
+ * Pure so vitest can load it — the panel it serves pulls React and a CSS
+ * module. The panel imports {@link DiscardPreview} from here for the same
+ * reason: a decision about the shape cannot be tested where the shape lives.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/client/discard-flow
+ */
+
+/** What the host says rolling one file back would do. */
+export interface DiscardPreview {
+  /** Absent when git reports nothing to roll back for that path. */
+  readonly effect?: 'restore' | 'delete' | 'recover' | 'unrename'
+  readonly irreversible?: boolean
+  readonly previousPath?: string
+  readonly error?: string
+}
+
+/** The host's reply to `discardPlan`, failure included. */
+export type DiscardAnswer =
+  /** The call returned; the plan may still be empty. */
+  | { readonly kind: 'plan'; readonly plan: DiscardPreview }
+  /** The call did not return a plan — it errored, threw, or was refused. */
+  | { readonly kind: 'failed'; readonly error: string }
+
+/** What the drawer does next. */
+export type DiscardNext =
+  /** Open the confirmation naming this plan's consequence. */
+  | { readonly kind: 'confirm'; readonly plan: DiscardPreview }
+  /** Carry it out with no dialog — nothing is lost. */
+  | { readonly kind: 'run'; readonly effect: string }
+  /** The row was stale; reload the tree and let it go away. */
+  | { readonly kind: 'refresh' }
+  /** Say why nothing was done. */
+  | { readonly kind: 'report'; readonly error: string }
+
+/** Fallback text for a failure that arrived with nothing to say. */
+export const UNKNOWN_DISCARD_ERROR = 'discardPlan failed'
+
+/**
+ * Decide what a roll-back click does with the answer it got.
+ *
+ * @param answer - the host's reply, or the failure that replaced it.
+ * @returns the single next step; never null, because every answer including a
+ *          broken one has to lead somewhere the reader can see.
+ */
+export function nextAfterPlan(answer: DiscardAnswer): DiscardNext {
+  if (answer.kind === 'failed') {
+    const error = answer.error.trim()
+    return { kind: 'report', error: error.length > 0 ? error : UNKNOWN_DISCARD_ERROR }
+  }
+  const plan = answer.plan
+  // The host reports a refusal in-band too, so a plan carrying an error is a
+  // failure that happened to arrive over a successful call.
+  if (typeof plan.error === 'string' && plan.error.trim().length > 0) {
+    return { kind: 'report', error: plan.error.trim() }
+  }
+  if (plan.effect === undefined) return { kind: 'refresh' }
+  // `recover` — a deleted file coming back — loses nothing, and a confirmation
+  // in front of a pure gain is how people learn to dismiss confirmations
+  // without reading them. Only an EXPLICIT `false` skips the dialog: a host
+  // newer than this bundle can name an effect this client has no copy for, and
+  // a missing flag read as "reversible" would act on it silently.
+  if (plan.irreversible === false) return { kind: 'run', effect: plan.effect }
+  return { kind: 'confirm', plan }
+}

package/src/client/file-filter.ts

@@ -0,0 +1,66 @@
+/**
+ * Narrowing a file list by typing at it.
+ *
+ * A commit that touched 140 files is a scroll, not a list, and the drawer's
+ * tree is the same object in every tab — so the rule lives here once and both
+ * the working tree and a commit's contents get it.
+ *
+ * Two decisions worth stating, because both are the kind that get "simplified"
+ * later:
+ *
+ *   - **Terms are ANDed, in any order.** `panel css` finds
+ *     `src/client/GitWorkbenchPanel.module.css` — which is how anyone types
+ *     when they half-remember a path, and is the behaviour a single-substring
+ *     match gets wrong for exactly the paths that are long enough to need
+ *     filtering.
+ *   - **Smart case.** An all-lowercase query ignores case; the moment the
+ *     reader types a capital they mean it. `README` should not match
+ *     `readme-generator`, and `readme` should still find `README.md`.
+ *
+ * The result keeps the caller's order and its element type: the tree is built
+ * from whatever survives, so filtering never has to know what a file is beyond
+ * its path.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/client/file-filter
+ */
+
+/** Split a raw query into the terms every path must contain. */
+function termsOf(query: string): readonly string[] {
+  return query.split(/\s+/).filter(term => term.length > 0)
+}
+
+/**
+ * Whether one path satisfies a query.
+ *
+ * @param path - repo-relative path, as the tree lists it.
+ * @param query - raw text from the filter box; blank matches everything, so a
+ *                caller that renders `filterFiles` unconditionally shows the
+ *                whole list until something is typed.
+ */
+export function matchesPath(path: string, query: string): boolean {
+  const terms = termsOf(query)
+  if (terms.length === 0) return true
+  return terms.every(term => {
+    // Per TERM, not per query: `src README` is a sensible thing to type, and
+    // deciding the whole query's case from one capital would make the `src`
+    // half case-sensitive too.
+    const cased = term.toLowerCase() !== term
+    return cased ? path.includes(term) : path.toLowerCase().includes(term.toLowerCase())
+  })
+}
+
+/**
+ * Keep the files whose path satisfies the query, in the order given.
+ *
+ * @param files - anything carrying a `path`; the tree's own file objects.
+ * @param query - raw text from the filter box.
+ * @returns the same array instance when nothing is filtered out, so a blank
+ *          query costs no re-render downstream.
+ */
+export function filterFiles<T extends { readonly path: string }>(
+  files: readonly T[],
+  query: string,
+): readonly T[] {
+  if (termsOf(query).length === 0) return files
+  return files.filter(file => matchesPath(file.path, query))
+}

package/src/client/index.ts

@@ -19,10 +19,12 @@ import type {} from '@deepseek-ai/dsh-client-runtime' // informational inject ed
 import type {} from '@deepseek-ai/dsh-client-ui-slots' // SlotMap is reused, not extended
 import {
   GitWorkbenchPanel,
-  type GitCommit, type GitOpName, type GitOpPayload, type GitOpResult,
+  type DiscardAnswer, type DiscardPreview, type GitCommit, type GitOpName, type GitOpPayload, type GitOpResult,
   type WorkbenchStats, type SyncStatus, type WorktreeStatus,
 } from './GitWorkbenchPanel.tsx'
 import type { StyleEntry, StyleScope, StyleSettings } from './themes.ts'
+import type { LogFilter } from '../log-filter.ts'
+import type { AuthorEntry } from '../shortlog.ts'
 import { en, zh } from './locales.ts'
 
 /**
@@ -91,14 +93,35 @@ export function apply(ctx: ClientContext): void {
           return result.ok ? result.value : null
         },
         // One page of the commit log past what `stats` bundles, so the history
-        // list can grow instead of stopping at the first page.
-        fetchCommits: async (worktreePath: string | undefined, ref: string, skip: number, limit: number, signal: AbortSignal): Promise<{ commits: GitCommit[]; hasMore: boolean } | null> => {
+        // list can grow instead of stopping at the first page. The filter is
+        // compiled into git log arguments host-side (IDEA-style pushdown).
+        fetchCommits: async (worktreePath: string | undefined, ref: string, skip: number, limit: number, filter: LogFilter, signal: AbortSignal): Promise<{ commits: GitCommit[]; hasMore: boolean } | null> => {
           const result = await connection.rpc.call(
             '/api',
             'gitWorkbench/commits',
-            { args: { worktreePath: worktreePath ?? '', ref, skip, limit } },
+            { args: { worktreePath: worktreePath ?? '', ref, skip, limit, filter } },
             signal,
-          ) as { ok: true; value: { commits: GitCommit[]; hasMore: boolean } } | { ok: false; error: { message?: string } }
+          ) as { ok: true; value: { commits: GitCommit[]; hasMore: boolean; error?: string } } | { ok: false; error: { message?: string } }
+          return result.ok ? result.value : null
+        },
+        // Author roster for the ref the history walks, busiest first.
+        fetchAuthors: async (worktreePath: string | undefined, ref: string, signal: AbortSignal): Promise<{ authors: AuthorEntry[]; truncated: boolean } | null> => {
+          const result = await connection.rpc.call(
+            '/api',
+            'gitWorkbench/authors',
+            { args: { worktreePath: worktreePath ?? '', ref } },
+            signal,
+          ) as { ok: true; value: { authors: AuthorEntry[]; truncated: boolean } } | { ok: false; error: { message?: string } }
+          return result.ok ? result.value : null
+        },
+        // Every path on HEAD — the path picker's raw material.
+        fetchRepoTree: async (worktreePath: string | undefined, signal: AbortSignal): Promise<{ paths: string[]; truncated: boolean } | null> => {
+          const result = await connection.rpc.call(
+            '/api',
+            'gitWorkbench/repoTree',
+            { args: { worktreePath: worktreePath ?? '' } },
+            signal,
+          ) as { ok: true; value: { paths: string[]; truncated: boolean } } | { ok: false; error: { message?: string } }
           return result.ok ? result.value : null
         },
         // Two refs compared as `base...head`, in the same shape as every other
@@ -181,6 +204,30 @@ export function apply(ctx: ClientContext): void {
           ) as { ok: true; value: SyncStatus } | { ok: false; error: { message?: string } }
           return result.ok ? result.value : null
         },
+        // Read-only, and the only reason it is a separate call rather than a
+        // field on the file row: the confirmation must state what discarding
+        // this file would do NOW, not what the last poll saw. A row that says
+        // "modified" while git has since had the file staged, edited or removed
+        // is the difference between "goes back to its committed content" and
+        // "leaves the disk and cannot come back" — which is the entire question
+        // the dialog exists to ask.
+        fetchDiscardPlan: async (worktreePath: string | undefined, path: string, signal: AbortSignal): Promise<DiscardAnswer> => {
+          // A throw here used to be nobody's: the click had already put the
+          // drawer into "asking the host", and an unhandled rejection left it
+          // there with no dialog and no way back except closing the drawer.
+          try {
+            const result = await connection.rpc.call(
+              '/api',
+              'gitWorkbench/discardPlan',
+              { args: { worktreePath: worktreePath ?? '', path } },
+              signal,
+            ) as { ok: boolean; value?: DiscardPreview; error?: { message?: string } }
+            if (result.ok && result.value !== undefined) return { kind: 'plan', plan: result.value }
+            return { kind: 'failed', error: result.error?.message ?? '' }
+          } catch (error) {
+            return { kind: 'failed', error: error instanceof Error ? error.message : String(error) }
+          }
+        },
         runGitOp: async (op: GitOpName, worktreePath: string | undefined, payload: GitOpPayload, signal: AbortSignal): Promise<GitOpResult> => {
           const result = await connection.rpc.call(
             '/api',