@young1lin/dsh-ui-gitworkbench 0.1.3 → 0.1.5

package/lib/discard-ops.js

@@ -0,0 +1,158 @@
+/**
+ * What "discard this file" resolves to, as a plan the host can carry out.
+ *
+ * This is the confirmation design `git-ops.ts` says a destructive button owes
+ * before it may exist. Three rules hold here, and each one closes a way this
+ * feature could quietly destroy the wrong thing:
+ *
+ *   - **The plan is derived from git's OWN report of the file, never from what
+ *     the client said it was.** A client that mislabels a tracked file as
+ *     untracked would otherwise turn a restore into a delete. `planFor` takes
+ *     a porcelain XY pair that the host read itself.
+ *   - **No plan may contain a destructive spelling.** Not `clean`, not
+ *     `reset --hard`, not `checkout -f`, no `--force`. `git restore` scoped to
+ *     one pathspec after `--` is the whole vocabulary; a stray `clean` would
+ *     take out every untracked file in the tree instead of the one named.
+ *     `tests/discard-ops.test.ts` scans every plan this module can produce.
+ *   - **A path that is deleted from disk is checked far harder than a
+ *     pathspec.** git refuses to leave the repository; `fs.rm` does not, so
+ *     `isSafeRelativePath` rejects absolutes, drive letters, UNC prefixes and
+ *     any `..` segment before a delete step can name a file.
+ *
+ * IDEA parity decides the semantics: Rollback there takes a file back to its
+ * committed state in one gesture and does not ask whether the change was
+ * staged, so neither does this. A file that was never committed goes away; a
+ * file that was deleted comes back.
+ *
+ * Pure throughout — no spawning, no fs. `src/index.ts` executes the steps.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/discard-ops
+ */
+import { isSafePathArg, parseStatusLine } from './git-ops.js';
+/**
+ * Whether a path is safe to hand a filesystem delete.
+ *
+ * Stricter than {@link isSafePathArg}, which only has to keep git from reading
+ * a path as an option: git will not step outside the repository whatever it is
+ * given, so a pathspec needs no traversal check. A delete has no such backstop.
+ * Rejected: absolute paths (POSIX and Windows), UNC prefixes, drive letters,
+ * NUL bytes, and any `..` segment — including one buried mid-path, which is
+ * how traversal is usually spelled.
+ * @param path - repo-relative path from a plan step.
+ */
+export function isSafeRelativePath(path) {
+    if (!isSafePathArg(path))
+        return false;
+    if (path.includes('\0'))
+        return false;
+    // Windows accepts both separators, so normalise before splitting or
+    // `a\..\..\b` walks out through a check that only knew about `/`.
+    const unified = path.replace(/\\/g, '/');
+    if (unified.startsWith('/'))
+        return false;
+    if (/^[A-Za-z]:/.test(unified))
+        return false;
+    if (unified.startsWith('//'))
+        return false;
+    return !unified.split('/').includes('..');
+}
+/** Take one file back to HEAD in both the index and the working tree. */
+function restoreBoth(path) {
+    return { kind: 'git', argv: ['restore', '--source=HEAD', '--staged', '--worktree', '--', path] };
+}
+/** Drop a file's index entry, leaving the working tree untouched. */
+function unstage(path) {
+    return { kind: 'git', argv: ['restore', '--staged', '--', path] };
+}
+/**
+ * The plan for one file, from git's own porcelain line.
+ *
+ * @param xy - the two porcelain status columns for this path, e.g. ` M`, `??`,
+ *             `R `. Read by the host from `git status --porcelain`, never
+ *             supplied by the client.
+ * @param path - repo-relative path, as git printed it.
+ * @param previousPath - for a rename, the path HEAD still knows the file by.
+ * @returns the ordered plan, or null when the file has nothing to discard.
+ * @throws if a path is not safe to pass on.
+ */
+export function planFor(xy, path, previousPath) {
+    if (!isSafePathArg(path))
+        throw new Error(`unsafe path argument: ${JSON.stringify(path)}`);
+    const index = xy[0] ?? ' ';
+    const worktree = xy[1] ?? ' ';
+    // Untracked and ignored: git has no copy, so the only way back is the
+    // filesystem's, and there is none.
+    if (xy === '??' || xy === '!!') {
+        if (!isSafeRelativePath(path))
+            throw new Error(`unsafe path to delete: ${JSON.stringify(path)}`);
+        return { steps: [{ kind: 'delete', path }], effect: 'delete', irreversible: true, path };
+    }
+    // A rename: HEAD holds `previousPath`, the index holds `path`. Bring the old
+    // one back first, then retire the new one — doing it the other way round
+    // would leave the tree with neither name for as long as the second step
+    // takes, which a reader watching a file tree would see.
+    if (index === 'R' || index === 'C') {
+        if (previousPath === undefined || !isSafePathArg(previousPath)) {
+            throw new Error(`rename without a usable previous path: ${JSON.stringify(path)}`);
+        }
+        if (!isSafeRelativePath(path))
+            throw new Error(`unsafe path to delete: ${JSON.stringify(path)}`);
+        return {
+            steps: [restoreBoth(previousPath), unstage(path), { kind: 'delete', path }],
+            effect: 'unrename',
+            irreversible: true,
+            path,
+            previousPath,
+        };
+    }
+    // Added to the index but absent from HEAD: rolling back means the file was
+    // never committed, so it leaves. Unstage first — otherwise the index would
+    // still carry an entry for a path that no longer exists on disk.
+    if (index === 'A') {
+        if (!isSafeRelativePath(path))
+            throw new Error(`unsafe path to delete: ${JSON.stringify(path)}`);
+        return {
+            steps: [unstage(path), { kind: 'delete', path }],
+            effect: 'delete',
+            irreversible: true,
+            path,
+        };
+    }
+    // Deleted, either side. HEAD still has the content, so this is recovery:
+    // nothing is lost and nothing needs confirming.
+    if (index === 'D' || worktree === 'D') {
+        return { steps: [restoreBoth(path)], effect: 'recover', irreversible: false, path };
+    }
+    // Everything else that git reported as changed — modified, type-changed,
+    // staged, unstaged, or both — goes back to HEAD wholesale. Content only the
+    // working tree ever held has no object behind it.
+    if (index !== ' ' || worktree !== ' ') {
+        return { steps: [restoreBoth(path)], effect: 'restore', irreversible: true, path };
+    }
+    // Clean: git reported the path with nothing to say about it.
+    return null;
+}
+/**
+ * Find the file in a status report and plan for it.
+ *
+ * The report is the WHOLE tree's, not one narrowed by a pathspec: git detects
+ * a rename by pairing a deletion with an addition, and a pathspec that admits
+ * only one of the pair turns `R old -> new` into an unrelated `D` and `??`.
+ * The plan for those two is delete-and-lose where the truth is un-rename.
+ *
+ * @param stdout - `git status --porcelain=v1` over the whole worktree.
+ * @param path - the file the reader asked about, as the drawer lists it.
+ * @returns the plan, or null when git does not report that path as changed —
+ *          which is also what a stale tree looks like, and is not an error.
+ */
+export function planFromStatus(stdout, path) {
+    if (!isSafePathArg(path))
+        throw new Error(`unsafe path argument: ${JSON.stringify(path)}`);
+    for (const line of stdout.split('\n')) {
+        const parsed = parseStatusLine(line);
+        if (parsed === null || parsed.path !== path)
+            continue;
+        return planFor(parsed.xy, parsed.path, parsed.renamed ? parsed.previousPath : undefined);
+    }
+    return null;
+}

package/lib/fs-remove.js

@@ -0,0 +1,73 @@
+/**
+ * The one filesystem delete in this plugin, and the checks it carries.
+ *
+ * `discard-ops.ts` plans a delete when git has no copy of a file to restore
+ * from — untracked, or added-but-never-committed. git will not carry that out:
+ * `git clean` refuses paths it cannot index, which on Windows includes every
+ * reserved device name (`nul`, `con`, `aux`, `com1`, and the same names with
+ * any extension). So the removal goes through the filesystem, where git's own
+ * refusal to leave the repository does not apply — hence the checks here
+ * rather than a bare `rm`.
+ *
+ * Lives outside `index.ts` so vitest can load it: the class there needs the
+ * dsh runtime, and the property worth testing is "what does this delete, and
+ * what does it refuse" — a question about paths and the disk, not about RPC.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/fs-remove
+ */
+import { rm } from 'node:fs/promises';
+import { resolve, sep } from 'node:path';
+import { isSafeRelativePath } from './discard-ops.js';
+/**
+ * Resolve a repo-relative path against the worktree root, refusing to leave it.
+ *
+ * The second lock rather than the only one: {@link isSafeRelativePath} already
+ * rejected traversal spellings when the plan was made. This re-checks the
+ * RESOLVED path, which is the form the filesystem acts on, so a path that
+ * survives the first check by being spelled unusually still has to land inside
+ * the root to be acted on.
+ *
+ * @param root - the worktree directory, absolute.
+ * @param relative - repo-relative path from a plan step.
+ * @returns the absolute path to act on.
+ * @throws if the path is not a safe relative path, resolves outside the root,
+ *         or IS the root.
+ */
+export function resolveInside(root, relative) {
+    if (!isSafeRelativePath(relative)) {
+        throw new Error(`unsafe path to delete: ${JSON.stringify(relative)}`);
+    }
+    const base = resolve(root);
+    const target = resolve(base, relative);
+    if (target === base)
+        throw new Error('refusing to delete the worktree root');
+    if (!target.startsWith(base + sep)) {
+        throw new Error(`refusing to delete outside the worktree: ${JSON.stringify(relative)}`);
+    }
+    return target;
+}
+/**
+ * Remove one entry from the worktree, having proven it is inside it.
+ *
+ * `recursive` is not a widening of the blast radius: `resolveInside` has
+ * already pinned the target to one path git named, and git names a DIRECTORY
+ * whenever it will not look inside one — an untracked nested repository is
+ * reported as `sub/`, with no per-file lines even under
+ * `--untracked-files=all`. Without `recursive` that row is the only one in the
+ * drawer whose roll-back fails, and it fails as `EISDIR`, which says nothing
+ * to the person who clicked it.
+ *
+ * `force` makes an absent entry a success: the reader asked for it to be gone,
+ * and it is.
+ *
+ * A symlinked directory inside the worktree could still point outward; that is
+ * a repository someone already has write access to, and resolving link targets
+ * per segment on every delete would cost a stat per segment for a case git
+ * itself does not defend against.
+ *
+ * @param root - the worktree directory, absolute.
+ * @param relative - repo-relative path from a plan step.
+ */
+export async function removePathInside(root, relative) {
+    await rm(resolveInside(root, relative), { recursive: true, force: true });
+}

package/lib/git-log.js

@@ -9,13 +9,14 @@
  * cannot carry `undefined`.
  */
 /**
- * Pretty format: RS, hash, when, subject, parents, refs, body.
+ * Pretty format: RS, hash, when, subject, parents, refs, author, committer,
+ * ISO date, body.
  *
  * `body` stays last because it is the only field that may contain newlines;
- * anything after it would have to survive them. Parents (`%p`) and refs (`%D`)
- * are single-line by construction.
+ * anything after it would have to survive them. Parents (`%p`), refs (`%D`),
+ * names (`%an`, `%cn`) and the ISO date (`%cI`) are single-line by construction.
  */
-export const LOG_FORMAT = '%x1e%h%x1f%cr%x1f%s%x1f%p%x1f%D%x1f%b';
+export const LOG_FORMAT = '%x1e%h%x1f%cr%x1f%s%x1f%p%x1f%D%x1f%an%x1f%cn%x1f%cI%x1f%b';
 /**
  * Split `%D` into plain ref names.
  *
@@ -63,9 +64,12 @@ export function parseLog(stdout) {
         const subject = (parts[2] ?? '').replace(/\n+$/g, '');
         const parents = (parts[3] ?? '').trim().split(/\s+/).filter(part => part.length > 0);
         const refs = parseRefs(parts[4] ?? '');
-        const body = (parts[5] ?? '').replace(/^\n+/, '').replace(/\n+$/g, '');
+        const authorName = parts[5] ?? '';
+        const committerName = parts[6] ?? '';
+        const dateIso = parts[7] ?? '';
+        const body = (parts[8] ?? '').replace(/^\n+/, '').replace(/\n+$/g, '');
         if (hash.length > 0)
-            out.push({ hash, subject, when, body, parents, refs });
+            out.push({ hash, subject, when, body, authorName, committerName, dateIso, parents, refs });
     }
     return out;
 }

package/lib/git-ops.js

@@ -13,8 +13,12 @@
  *     of that. A file may legitimately be named `-f`, and passed positionally
  *     it becomes an option instead of a path.
  *   - Nothing here builds a destructive command. There is no `--force`, no
- *     `reset --hard`, no `clean`. Losing committed work needs a confirmation
- *     design of its own, not a button that happens to be adjacent to Push.
+ *     `reset --hard`, no `clean`. The one action that does lose work — rolling
+ *     one file back — lives in `discard-ops.ts` instead, behind the
+ *     confirmation design this rule demanded: git's own reading of the file
+ *     rather than the client's claim, `git restore` scoped to a single
+ *     pathspec as the whole vocabulary, and a dialog that names the
+ *     consequence. It is deliberately not a button adjacent to Push.
  *
  * @module
  */
@@ -254,19 +258,36 @@ export function parseNumstat(stdout) {
     }
     return out;
 }
+/**
+ * Split one `git status --porcelain=v1` line.
+ *
+ * Exported because more than the file list needs it: `discard-ops` plans from
+ * the RAW XY pair, which {@link parseStatus} folds away into a
+ * {@link GitFileStatus}. Sharing this keeps the quoting and `old -> new`
+ * handling in one place — a second implementation of it is how a path with a
+ * non-ASCII name ends up being acted on unescaped.
+ * @param line - one output line, branch header and blanks included.
+ * @returns the split, or null for a line that names no file.
+ */
+export function parseStatusLine(line) {
+    if (line.length === 0 || line.startsWith('##'))
+        return null;
+    if (line.length < 3)
+        return null;
+    const { path, previousPath, renamed } = parsePath(line.slice(3));
+    if (path.length === 0)
+        return null;
+    return { xy: line.slice(0, 2), path, previousPath, renamed };
+}
 /** Parse porcelain lines into a MUTABLE file list — untracked entries get their
  * counts filled in by the synthesis pass afterwards. */
 export function parseStatus(stdout, numstat) {
     const files = [];
     for (const line of stdout.split('\n')) {
-        if (line.length === 0 || line.startsWith('##'))
-            continue;
-        if (line.length < 3)
-            continue;
-        const xy = line.slice(0, 2);
-        const { path, previousPath, renamed } = parsePath(line.slice(3));
-        if (path.length === 0)
+        const parsed = parseStatusLine(line);
+        if (parsed === null)
             continue;
+        const { xy, path, previousPath, renamed } = parsed;
         const counts = numstat.get(path) ?? { added: 0, deleted: 0, binary: false };
         const { staged, unstaged } = stageStateOf(xy);
         const base = {

package/lib/index.js

@@ -83,8 +83,12 @@ import { defineTool } from '@deepseek-ai/dsh-tools';
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { saveJsonAtomic } from './atomic-json.js';
 import { CommitPayloadCache, cacheKey } from './commit-cache.js';
-import { NETWORK_GRACE_MS, NON_INTERACTIVE_ENV, capBranches, classifyFailure, clipDiff, commitArgv, countBufferLines, fetchArgv, isBinaryPrefix, isNoMergeBaseError, parseNameStatus, parseNumstat, parseStatus, parseTracking, pullArgv, pushArgv, stageArgv, unstageArgv, } from './git-ops.js';
+import { NETWORK_GRACE_MS, NON_INTERACTIVE_ENV, capBranches, classifyFailure, clipDiff, commitArgv, countBufferLines, fetchArgv, isBinaryPrefix, isNoMergeBaseError, isSafePathArg, parseNameStatus, parseNumstat, parseStatus, parseTracking, pullArgv, pushArgv, stageArgv, unstageArgv, } from './git-ops.js';
+import { planFromStatus, } from './discard-ops.js';
+import { removePathInside } from './fs-remove.js';
 import { LOG_FORMAT, parseLog } from './git-log.js';
+import { emptyLogFilter, logFilterArgs } from './log-filter.js';
+import { parseShortlog } from './shortlog.js';
 import { isBlankEntry, loadStyle, sanitizeEntry, stylePath, } from './style-store.js';
 import { bindingsPath, findRegisteredWorktree, isRefName, loadBindings, parseWorktreeList, sanitizeName, saveBindings, worktreeDir, } from './worktree.js';
 /** Cap the bundled unified diff so a huge change cannot blow the RPC response. */
@@ -104,6 +108,12 @@ const HISTORY_COMMITS = 20;
 const HISTORY_PAGE = 30;
 /** Upper bound on a caller-supplied page size. */
 const HISTORY_PAGE_MAX = 200;
+/** Author roster cap: the busiest 500 — enough for any real project's people,
+ *  and a list a popup can scroll without choking. */
+const SHORTLOG_CAP = 500;
+/** Path list cap for the picker: a monorepo can outrun any popup; past this
+ *  the tree is cut and the truncation reported, never silent. */
+const TREE_PATH_CAP = 50_000;
 /**
  * Most branch names sent to the browser. `worktreeStatus` is polled, so an
  * unbounded list would repeat on the wire every few seconds; the picker reports
@@ -136,6 +146,8 @@ let GitWorkbenchService = (() => {
     let _fileDiff_decorators;
     let _commitStats_decorators;
     let _commits_decorators;
+    let _authors_decorators;
+    let _repoTree_decorators;
     let _compareRefs_decorators;
     let _sessionWorktree_decorators;
     let _worktreeEnter_decorators;
@@ -146,6 +158,8 @@ let GitWorkbenchService = (() => {
     let _syncStatus_decorators;
     let _stage_decorators;
     let _unstage_decorators;
+    let _discardPlan_decorators;
+    let _discardFile_decorators;
     let _commit_decorators;
     let _fetch_decorators;
     let _pull_decorators;
@@ -157,6 +171,8 @@ let GitWorkbenchService = (() => {
             _fileDiff_decorators = [Remote('fileDiff')];
             _commitStats_decorators = [Remote('commitStats')];
             _commits_decorators = [Remote('commits')];
+            _authors_decorators = [Remote('authors')];
+            _repoTree_decorators = [Remote('repoTree')];
             _compareRefs_decorators = [Remote('compareRefs')];
             _sessionWorktree_decorators = [Remote('sessionWorktree')];
             _worktreeEnter_decorators = [Remote('worktreeEnter')];
@@ -167,6 +183,8 @@ let GitWorkbenchService = (() => {
             _syncStatus_decorators = [Remote('syncStatus')];
             _stage_decorators = [Remote('stage')];
             _unstage_decorators = [Remote('unstage')];
+            _discardPlan_decorators = [Remote('discardPlan')];
+            _discardFile_decorators = [Remote('discardFile')];
             _commit_decorators = [Remote('commit')];
             _fetch_decorators = [Remote('fetch')];
             _pull_decorators = [Remote('pull')];
@@ -175,6 +193,8 @@ let GitWorkbenchService = (() => {
             __esDecorate(this, null, _fileDiff_decorators, { kind: "method", name: "fileDiff", static: false, private: false, access: { has: obj => "fileDiff" in obj, get: obj => obj.fileDiff }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _commitStats_decorators, { kind: "method", name: "commitStats", static: false, private: false, access: { has: obj => "commitStats" in obj, get: obj => obj.commitStats }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _commits_decorators, { kind: "method", name: "commits", static: false, private: false, access: { has: obj => "commits" in obj, get: obj => obj.commits }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _authors_decorators, { kind: "method", name: "authors", static: false, private: false, access: { has: obj => "authors" in obj, get: obj => obj.authors }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _repoTree_decorators, { kind: "method", name: "repoTree", static: false, private: false, access: { has: obj => "repoTree" in obj, get: obj => obj.repoTree }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _compareRefs_decorators, { kind: "method", name: "compareRefs", static: false, private: false, access: { has: obj => "compareRefs" in obj, get: obj => obj.compareRefs }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _sessionWorktree_decorators, { kind: "method", name: "sessionWorktree", static: false, private: false, access: { has: obj => "sessionWorktree" in obj, get: obj => obj.sessionWorktree }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _worktreeEnter_decorators, { kind: "method", name: "worktreeEnter", static: false, private: false, access: { has: obj => "worktreeEnter" in obj, get: obj => obj.worktreeEnter }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -185,6 +205,8 @@ let GitWorkbenchService = (() => {
             __esDecorate(this, null, _syncStatus_decorators, { kind: "method", name: "syncStatus", static: false, private: false, access: { has: obj => "syncStatus" in obj, get: obj => obj.syncStatus }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _stage_decorators, { kind: "method", name: "stage", static: false, private: false, access: { has: obj => "stage" in obj, get: obj => obj.stage }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _unstage_decorators, { kind: "method", name: "unstage", static: false, private: false, access: { has: obj => "unstage" in obj, get: obj => obj.unstage }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _discardPlan_decorators, { kind: "method", name: "discardPlan", static: false, private: false, access: { has: obj => "discardPlan" in obj, get: obj => obj.discardPlan }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _discardFile_decorators, { kind: "method", name: "discardFile", static: false, private: false, access: { has: obj => "discardFile" in obj, get: obj => obj.discardFile }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _commit_decorators, { kind: "method", name: "commit", static: false, private: false, access: { has: obj => "commit" in obj, get: obj => obj.commit }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _fetch_decorators, { kind: "method", name: "fetch", static: false, private: false, access: { has: obj => "fetch" in obj, get: obj => obj.fetch }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _pull_decorators, { kind: "method", name: "pull", static: false, private: false, access: { has: obj => "pull" in obj, get: obj => obj.pull }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -534,16 +556,23 @@ let GitWorkbenchService = (() => {
          * @param ref - ref to walk; empty means the worktree's own HEAD.
          * @param skip - commits to skip, counting back from the ref.
          * @param limit - page size; out-of-range values fall back to the default page.
+         * @param filter - history filter compiled into git log arguments (IDEA-style
+         *   pushdown: matching runs over ALL history, not the loaded pages). Absent
+         *   from older clients — treated as "no filter".
          * @param signal - abort signal.
          * @returns the page, and whether the log continues past it.
          */
-        async commits(worktreePath, ref, skip, limit, signal) {
+        async commits(worktreePath, ref, skip, limit, filter, signal) {
             const cwd = typeof worktreePath === 'string' && worktreePath.length > 0 ? worktreePath : process.cwd();
-            const target = typeof ref === 'string' && ref.length > 0 ? ref : 'HEAD';
-            if (!isRefName(target))
+            // '--all' is the ALL-BRANCHES sentinel (a ref cannot begin with a dash, so
+            // it collides with nothing): "who did what" must not require knowing which
+            // branch holds it — IDEA's All branches, same idea.
+            const target = ref === '--all' ? '--all' : (typeof ref === 'string' && ref.length > 0 ? ref : 'HEAD');
+            if (target !== '--all' && !isRefName(target))
                 return { commits: [], hasMore: false };
             const from = Number.isInteger(skip) && skip >= 0 ? skip : 0;
             const size = Number.isInteger(limit) && limit > 0 && limit <= HISTORY_PAGE_MAX ? limit : HISTORY_PAGE;
+            const effective = filter ?? emptyLogFilter();
             // Reading one row beyond the page answers "is there more" without a second
             // traversal of the log.
             //
@@ -553,10 +582,59 @@ let GitWorkbenchService = (() => {
             // a dozen unrelated rows, and closes far from where it started. Topological
             // order keeps a branch's commits contiguous — it is what `git log --graph`
             // turns on for itself, for the same reason.
-            const log = await this.git(cwd, ['log', target, '--topo-order', `--skip=${from}`, `-${size + 1}`, `--pretty=format:${LOG_FORMAT}`], signal);
+            //
+            // Filter args go LAST: their segment ends with `--` + pathspecs, and
+            // nothing after that separator may be parsed as a flag.
+            const log = await this.git(cwd, ['log', target, '--topo-order', `--skip=${from}`, `-${size + 1}`, `--pretty=format:${LOG_FORMAT}`, ...logFilterArgs(effective)], signal);
+            // A bad filter (unparsable regex, invalid date) dies here, and an empty
+            // page is indistinguishable from "no match" unless the failure speaks —
+            // §6.13: the exit code + stderr tail is the only honest answer.
+            if (log.exitCode !== 0) {
+                const detail = log.stderr.length > 0 ? `: ${log.stderr.slice(-160)}` : '';
+                return { commits: [], hasMore: false, error: `git log failed (exit ${log.exitCode})${detail}` };
+            }
             const page = parseLog(log.stdout);
             return { commits: page.slice(0, size), hasMore: page.length > size };
         }
+        /**
+         * Every author with commits reachable from a ref, busiest first — the
+         * history filter popup's user picker.
+         *
+         * The roster walks the SAME ref the history list walks (`git shortlog -sne
+         * <ref>`), not `--all`: a picker entry is a promise that ticking it yields
+         * commits in the list below. `--all` once listed authors whose commits live
+         * only on other refs — visible in the menu, invisible to every search.
+         * @param worktreePath - worktree whose object store resolves the ref; empty falls back to the host cwd.
+         * @param ref - ref whose history the roster counts; empty means HEAD.
+         * @param signal - abort signal.
+         */
+        async authors(worktreePath, ref, signal) {
+            const cwd = typeof worktreePath === 'string' && worktreePath.length > 0 ? worktreePath : process.cwd();
+            // Same '--all' sentinel as `commits`: when the list walks every ref, the
+            // roster counts every ref — the picker and the list stay one claim.
+            const target = ref === '--all' ? '--all' : (typeof ref === 'string' && ref.length > 0 ? ref : 'HEAD');
+            if (target !== '--all' && !isRefName(target))
+                return { authors: [], truncated: false };
+            const res = await this.git(cwd, ['shortlog', '-sne', target], signal);
+            return parseShortlog(res.stdout, SHORTLOG_CAP);
+        }
+        /**
+         * Every file path on HEAD — the filter popup's path picker, aggregated into
+         * a directory tree client-side.
+         *
+         * `-z` is load-bearing: NUL-separated output is UNQUOTED, while the default
+         * would render non-ASCII names as quoted octal escapes under
+         * `core.quotepath` and hand the picker garbage.
+         * @param worktreePath - worktree whose HEAD is listed; empty falls back to the host cwd.
+         * @param signal - abort signal.
+         */
+        async repoTree(worktreePath, signal) {
+            const cwd = typeof worktreePath === 'string' && worktreePath.length > 0 ? worktreePath : process.cwd();
+            const res = await this.git(cwd, ['ls-tree', '-r', '-z', '--name-only', 'HEAD'], signal);
+            const all = res.stdout.split('\0').filter(path => path.length > 0);
+            const truncated = all.length > TREE_PATH_CAP;
+            return { paths: truncated ? all.slice(0, TREE_PATH_CAP) : all, truncated };
+        }
         /**
          * Compare two refs, in the same {@link WorkbenchStats} shape as every other view.
          *
@@ -876,6 +954,114 @@ let GitWorkbenchService = (() => {
         async unstage(worktreePath, paths, signal) {
             return this.writeOp(worktreePath, () => unstageArgv(asPathList(paths)), signal);
         }
+        /**
+         * What discarding this file WOULD do, without doing it.
+         *
+         * The confirmation has to state the real consequence, and only git knows it:
+         * the drawer's own file list is a poll old, and the difference between "this
+         * goes back to its committed content" and "this file leaves the disk and
+         * cannot come back" is exactly the difference the reader is being asked
+         * about. So the dialog is built from this, read fresh, rather than from the
+         * row that was clicked.
+         * @param worktreePath - directory to run in.
+         * @param path - repository-relative path, as the drawer lists it.
+         * @param signal - abort signal.
+         * @returns the effect and whether it is irreversible; `effect` is absent when
+         *          git reports nothing to discard for that path.
+         */
+        async discardPlan(worktreePath, path, signal) {
+            let plan;
+            try {
+                plan = await this.planDiscard(worktreePath, path, signal);
+            }
+            catch (error) {
+                return { error: error instanceof Error ? error.message : String(error) };
+            }
+            if (plan === null)
+                return {};
+            // JSON-safe: an absent previousPath is an omitted key, never `undefined`.
+            return plan.previousPath !== undefined
+                ? { effect: plan.effect, irreversible: plan.irreversible, previousPath: plan.previousPath }
+                : { effect: plan.effect, irreversible: plan.irreversible };
+        }
+        /**
+         * Take one file back to its committed state — IntelliJ's Rollback.
+         *
+         * One path per call, never a list. Discarding is the only thing the drawer
+         * does that cannot be undone, and a batch entry point is the shape that
+         * turns one mistaken click into a lost afternoon; a caller that wants two
+         * files asks twice, and gets asked twice.
+         *
+         * The plan is re-derived here from a fresh `git status`, so a client that
+         * mislabels a tracked file as untracked cannot talk the host into deleting
+         * it. `expectedEffect` is what the reader was shown and agreed to: if the
+         * file changed underneath the dialog — staged, edited, reverted by someone
+         * else — the freshly derived effect no longer matches and nothing is done.
+         * @param worktreePath - directory to run in.
+         * @param path - repository-relative path, as the drawer lists it.
+         * @param expectedEffect - the effect the confirmation stated; blank skips
+         *                         the agreement check, which only the reversible
+         *                         `recover` path takes (it shows no dialog).
+         * @param signal - abort signal.
+         * @returns the operation result, with the effect actually carried out.
+         */
+        async discardFile(worktreePath, path, expectedEffect, signal) {
+            let plan;
+            try {
+                plan = await this.planDiscard(worktreePath, path, signal);
+            }
+            catch (error) {
+                return { ok: false, failure: 'unknown', error: error instanceof Error ? error.message : String(error) };
+            }
+            // Nothing to discard is not a failure: the row was stale, and the tree the
+            // client refreshes onto will simply no longer carry it.
+            if (plan === null)
+                return { ok: true };
+            if (typeof expectedEffect === 'string' && expectedEffect.length > 0 && expectedEffect !== plan.effect) {
+                return {
+                    ok: false,
+                    failure: 'unknown',
+                    error: `this file changed since you were asked (now: ${plan.effect}); nothing was done`,
+                };
+            }
+            const cwd = this.cwdOf(worktreePath);
+            for (const step of plan.steps) {
+                if (step.kind === 'git') {
+                    const result = await this.git(cwd, step.argv, signal);
+                    const failure = classifyFailure(result.exitCode, result.stderr, result.stdout);
+                    if (failure !== null) {
+                        return { ok: false, failure, error: (result.stderr || result.stdout).trim().slice(-1000) };
+                    }
+                    continue;
+                }
+                try {
+                    await removePathInside(cwd, step.path);
+                }
+                catch (error) {
+                    return { ok: false, failure: 'unknown', error: error instanceof Error ? error.message : String(error) };
+                }
+            }
+            return { ok: true, effect: plan.effect };
+        }
+        /**
+         * Read the worktree's status and plan for one path.
+         *
+         * The status is the WHOLE tree's, deliberately: git pairs a deletion with an
+         * addition to see a rename, and a pathspec that admits only one of the pair
+         * reports `D` plus `??` instead — which plans as "restore one, DELETE the
+         * other" where the truth is "undo the rename".
+         */
+        async planDiscard(worktreePath, path, signal) {
+            if (typeof path !== 'string' || !isSafePathArg(path)) {
+                throw new Error(`unsafe path argument: ${JSON.stringify(path)}`);
+            }
+            const cwd = this.cwdOf(worktreePath);
+            const status = await this.git(cwd, ['status', '--porcelain=v1', '--untracked-files=all'], signal);
+            if (status.exitCode !== 0) {
+                throw new Error((status.stderr || status.stdout).trim().slice(-1000) || 'git status failed');
+            }
+            return planFromStatus(status.stdout, path);
+        }
         /**
          * Commit what is in the index.
          * @param worktreePath - directory to run in.