dsh-gitbar-lite 0.1.2 → 0.2.1

package/README.en.md

@@ -23,6 +23,7 @@ The column is narrow (300px minimum, and a narrow viewport makes it full-screen)
 | Commit | Commits exactly what is ticked — because ticking wrote the index |
 | Commit and Push | Commits, then pushes. **A failed push never claims the commit failed**: the commit happened, and the panel says "committed `abc1234`, but the push failed" |
 | Context button | **Push** when local commits are unpushed, **Publish** when the branch has no upstream, **Fetch** otherwise |
+| Automatic fetch | Every five minutes while the panel is visible and the repository has a remote (`autoFetchMs`, `0` to disable). Failures are silent — no error banner |
 | Discard | One file or all of them; the diff is archived *before* anything is restored, and the confirmation offers "delete for good" |
 | Trash | Its own tab. Every discard keeps a diff, recorded **against the commit it was taken from** (`abc1234 initial commit`) |
 | Diff preview | Double-click a file, or a trash entry, to open a diff tab in the column — **one tab, ever**, re-navigated in place |
@@ -137,12 +138,14 @@ The order is fixed and cannot be swapped:
 | `maxFileBytes` | `2097152` | Larger untracked files are listed but not read, archived, or diffed |
 | `trashLimit` | `200` | Trash entries kept; the oldest are dropped along with their diff files |
 | `scanDepth` | `3` | Directory depth the picker scans below the workspace root |
+| `autoFetchMs` | `300000` | How often the panel fetches on its own; `0` disables it, leaving the manual button |
 
 Every field is volatile, so a change on the settings page takes effect without a restart.
 
 **Where state lives**: `<DSH_HOME>/dsh-gitbar-lite/` (falling back to `~/.dsh`) — `bindings.json` (workspace →
-repository), `prefs.json` (the two remembered choices), and `trash/index.json` plus `trash/<id>.diff`. Every write
-goes through a temp file and a rename, so a crash mid-write cannot truncate a file.
+repository), `prefs.json` (the two remembered choices), `trash/index.json` plus `trash/<id>.diff`, and
+`trash/<id>.content.json` (the raw contents a restore needs). Every write goes through a temp file and a rename, so a
+crash mid-write cannot truncate a file.
 
 ## How it works
 
@@ -189,7 +192,7 @@ are in [`docs/CONTRACT.md`](./docs/CONTRACT.md).
 
 ```sh
 npm test          # unit + real-git e2e + artifact self-check
-npm run test:e2e  # the real-git suite alone (20 sections building their own fixtures, 241 assertions)
+npm run test:e2e  # the real-git suite alone (21 sections building their own fixtures, 263 assertions)
 npm run check     # artifact self-check alone (catches boot-breaking mistakes without restarting DSH)
 npm run test:live # probe a running DSH (not part of npm test; needs the app running)
 ```

package/README.md

@@ -23,6 +23,7 @@ DSH 的右栏本来就是一个常驻的标签区。Git 面板放这里，意味
 | Commit | 只提交勾上的（因为勾选写进了索引） |
 | Commit and Push | 提交后立刻推送；**推送失败不会说「提交失败」**——提交已经发生了，面板会明说「已提交 xxx，但推送失败」 |
 | 上下文按钮 | 有本地未推送提交时是 **Push**，没有上游时是 **Publish**，否则是 **Fetch** |
+| 自动 Fetch | 面板可见且仓库有远端时，每 5 分钟自己 fetch 一次（`autoFetchMs` 可调，`0` 关掉）。失败是静默的，不弹错误 |
 | 舍弃更改 | 单个文件或「全部舍弃」；动手前先把这次改动的 diff 归档，确认框里可以勾「彻底删除」 |
 | 回收站 | 独立 tab。每次舍弃存一份 diff，并记下**是对哪个提交（`abc1234 初始提交`）取的 diff** |
 | diff 预览 | 双击文件，或点回收站里的一条，在右栏开一个 diff 标签页——**永远只占一个**，再点就复用 |
@@ -132,11 +133,13 @@ dsh plugin --profile <你的 profile> remove dsh-gitbar-lite
 | `maxFileBytes` | `2097152` | 比这大的未跟踪文件只列出来，不读内容、不归档、不出 diff |
 | `trashLimit` | `200` | 回收站保留多少条；超出丢弃最旧的连同它的 diff 文件 |
 | `scanDepth` | `3` | 「不是仓库时」扫描工作区找仓库的目录深度 |
+| `autoFetchMs` | `300000` | 面板自己多久 fetch 一次；`0` = 关掉，只用手动按钮 |
 
 每个字段都是 volatile 的，所以在设置页改了立刻生效、不用重启。
 
 **状态存在哪**：`<DSH_HOME>/dsh-gitbar-lite/`（没有 `DSH_HOME` 就回落 `~/.dsh`）——
-`bindings.json`（工作区 → 仓库）、`prefs.json`（那两个勾选偏好）、`trash/index.json` + `trash/<id>.diff`。
+`bindings.json`（工作区 → 仓库）、`prefs.json`（那两个勾选偏好）、`trash/index.json` + `trash/<id>.diff` +
+`trash/<id>.content.json`（恢复用的原始内容）。
 都是先写临时文件再 rename，所以写到一半崩了也不会把文件截断。
 
 ## 工作原理
@@ -176,7 +179,7 @@ lib/client.js          浏览器半边：三个 tab 类型 + 面板/回收站/di
 
 ```sh
 npm test          # 单测 + 真 git 的 e2e + 产物自检
-npm run test:e2e  # 只跑真 git 的 e2e（20 个小节，各自造自己的夹具，241 项断言）
+npm run test:e2e  # 只跑真 git 的 e2e（21 个小节，各自造自己的夹具，263 项断言）
 npm run check     # 只用产物自检（不启 DSH 也能发现会让 DSH 起不来的问题）
 npm run test:live # 探测一个正在运行的 DSH（不在 npm test 里，需要跑着应用）
 ```

package/docs/CONTRACT.md

@@ -326,7 +326,7 @@ this package on the next upgrade.
 | state files, the binding key, corruption tolerance, write serialization | `test/store.test.mjs` |
 | the route carrier, single registration under a hostile service order, error classification | `test/index.test.mjs` |
 | every registration identity, the wire literals, the dictionaries, and the hook-free components' rendered trees | `test/client.test.mjs` |
-| the whole host stack against **real git**, mutation by mutation | `test/e2e.mjs`, 241 assertions over 20 sections that build their own fixtures |
+| the whole host stack against **real git**, mutation by mutation | `test/e2e.mjs`, 263 assertions over 21 sections that build their own fixtures |
 | the manifest, the patch layer, the tarball's contents, the two copies of the wire contract, the dictionaries, the workflow | `test/check.mjs` |
 | that the client bundle would not abort the Host boot | `scripts/check-client-bundle.mjs` |
 

package/lib/client.js

@@ -74,6 +74,7 @@ window.__ModuleLoader__.load({
       TRASH_DIFF: 'trashDiff',
       TRASH_DELETE: 'trashDelete',
       TRASH_CLEAR: 'trashClear',
+      TRASH_RESTORE: 'trashRestore',
       PREFS: 'prefs',
     }
 
@@ -146,8 +147,17 @@ window.__ModuleLoader__.load({
       'action.cancel': '取消',
       'action.confirm': '舍弃',
       'action.delete': '删除这条记录',
+      'action.restore': '恢复这条更改',
       'action.clear': '清空回收站',
       'action.busy': '处理中…',
+      'fetch.last': '上次 Fetch：{when}',
+      'fetch.never': '还没 Fetch 过',
+
+      'status.added': '新增',
+      'status.modified': '修改',
+      'status.deleted': '删除',
+      'status.renamed': '重命名',
+      'status.conflicted': '冲突',
 
       'changes.title': '更改',
       'changes.empty': '工作区干净，没有要提交的更改。',
@@ -193,6 +203,10 @@ window.__ModuleLoader__.load({
       'trash.clearConfirm': '清空 {n} 条回收站记录？',
       'trash.clearHint': '这只是删掉归档的 diff，不会影响已经还原的工作区。',
       'trash.truncated': '（这条记录在归档时被截断了）',
+      'trash.restoreChanged': '舍弃之后这些文件又改过了，恢复会盖掉后来的改动。',
+      'trash.restoreNoContent': '这条舍弃没留下文件内容，只留了 diff，无法恢复。',
+      'trash.restoreOtherRepo': '这条记录属于另一个仓库。',
+      'trash.restoreNoRepo': '当前工作区没有绑定这个仓库。',
 
       'diff.title': 'Diff',
       'diff.loading': '正在生成 diff…',
@@ -220,6 +234,7 @@ window.__ModuleLoader__.load({
       'err.E_AUTH': '推送认证失败：本机 git 没有可用凭据。先在终端里成功 push 一次。',
       'err.E_PUSH_REJECTED': '推送被拒绝：远端有你本地没有的提交，先 Fetch 再推。',
       'err.E_TRASH_NOT_FOUND': '这条回收站记录已经不在了。',
+      'err.E_TRASH_NOT_RESTORABLE': '这条记录现在不能恢复。',
       'err.E_INTERNAL': '插件内部出错了。',
       'err.E_TRANSPORT': '和 DSH 宿主通信失败。',
       'err.E_BAD_RESPONSE': '宿主返回了无法解析的响应。',
@@ -235,6 +250,7 @@ window.__ModuleLoader__.load({
       'toast.unbound': '已解除绑定',
       'toast.trashCleared': '回收站已清空（{n} 条）',
       'toast.trashDeleted': '已删除那条记录',
+      'toast.trashRestored': '已恢复 {n} 个文件的更改',
       'toast.pushFailed': '已提交 {commit}，但推送失败',
     }
 
@@ -262,8 +278,17 @@ window.__ModuleLoader__.load({
       'action.cancel': 'Cancel',
       'action.confirm': 'Discard',
       'action.delete': 'Delete this entry',
+      'action.restore': 'Restore this change',
       'action.clear': 'Empty the trash',
       'action.busy': 'Working…',
+      'fetch.last': 'Last fetch: {when}',
+      'fetch.never': 'Never fetched',
+
+      'status.added': 'Added',
+      'status.modified': 'Modified',
+      'status.deleted': 'Deleted',
+      'status.renamed': 'Renamed',
+      'status.conflicted': 'Conflicted',
 
       'changes.title': 'Changes',
       'changes.empty': 'The working tree is clean — nothing to commit.',
@@ -309,6 +334,10 @@ window.__ModuleLoader__.load({
       'trash.clearConfirm': 'Empty {n} trash entries?',
       'trash.clearHint': 'This only deletes the archived diffs; the restored working tree is untouched.',
       'trash.truncated': '(this entry was truncated when archived)',
+      'trash.restoreChanged': 'These files changed after the discard; restoring would overwrite newer work.',
+      'trash.restoreNoContent': 'This discard kept only its diff, no file contents, so it cannot be put back.',
+      'trash.restoreOtherRepo': 'This entry belongs to a different repository.',
+      'trash.restoreNoRepo': 'This workspace is not bound to that repository.',
 
       'diff.title': 'Diff',
       'diff.loading': 'Building the diff…',
@@ -336,6 +365,7 @@ window.__ModuleLoader__.load({
       'err.E_AUTH': 'Push authentication failed: the local git has no usable credential. Push once from a terminal first.',
       'err.E_PUSH_REJECTED': 'The push was rejected: the remote has commits you do not. Fetch, then push.',
       'err.E_TRASH_NOT_FOUND': 'That trash entry is gone.',
+      'err.E_TRASH_NOT_RESTORABLE': 'This entry cannot be restored right now.',
       'err.E_INTERNAL': 'The plugin hit an internal error.',
       'err.E_TRANSPORT': 'Could not reach the DSH host.',
       'err.E_BAD_RESPONSE': 'The host returned a response that could not be read.',
@@ -351,6 +381,7 @@ window.__ModuleLoader__.load({
       'toast.unbound': 'Binding cleared',
       'toast.trashCleared': 'Trash emptied ({n} entries)',
       'toast.trashDeleted': 'Entry deleted',
+      'toast.trashRestored': 'Restored the changes to {n} files',
       'toast.pushFailed': 'Committed {commit}, but the push failed',
     }
 
@@ -386,21 +417,31 @@ window.__ModuleLoader__.load({
      * 3. Small pure helpers (covered by the unit tests)
      * ------------------------------------------------------------------ */
 
-    const KIND_LETTER = {
-      added: 'A',
-      deleted: 'D',
-      renamed: 'R',
-      conflicted: '!',
-      untracked: '?',
-      modified: 'M',
+    /**
+     * Which mark the row shows for a change.
+     *
+     * Five kinds, not the seven git reports. GitHub Desktop maps a new file and
+     * an untracked one to the same `diff-added` mark (`iconForStatus` in
+     * `app/src/ui/octicons/status.ts`), and this panel follows it: "tracked or
+     * not" is a distinction git cares about when *staging*, not one worth two
+     * different marks in a list of what changed.
+     */
+    function statusKind(file) {
+      if (file === null || typeof file !== 'object') return 'modified'
+      if (file.conflicted === true) return 'conflicted'
+      if (file.kind === 'deleted') return 'deleted'
+      if (file.kind === 'renamed') return 'renamed'
+      if (file.kind === 'added' || file.kind === 'untracked' || file.untracked === true) return 'added'
+      return 'modified'
     }
 
-    /** The single character git itself would print in `status --short`. */
-    function statusLetter(file) {
-      if (file === null || typeof file !== 'object') return 'M'
-      if (file.conflicted === true) return '!'
-      if (file.untracked === true) return '?'
-      return KIND_LETTER[file.kind] ?? 'M'
+    /** The component that draws one of those marks. */
+    function statusGlyph(kind) {
+      if (kind === 'added') return StatusAddedGlyph
+      if (kind === 'deleted') return StatusDeletedGlyph
+      if (kind === 'renamed') return StatusRenamedGlyph
+      if (kind === 'conflicted') return StatusConflictGlyph
+      return StatusModifiedGlyph
     }
 
     /** Split a repository path into the directory part and the file name. */
@@ -502,6 +543,39 @@ window.__ModuleLoader__.load({
       }
     }
 
+    /**
+     * "Last fetch: 3 min ago", or a plain "never" when there is no fetch to
+     * report.
+     *
+     * The timestamp is git's own — the mtime of `.git/FETCH_HEAD` — not something
+     * this plugin writes down, so a fetch run in a terminal counts too and the
+     * answer survives a restart.
+     *
+     * @param {object | null} state the status payload
+     * @param {number} now epoch milliseconds
+     * @param {(key: string, params?: object) => string} t
+     */
+    function lastFetchLabel(state, now, t) {
+      const at = state === null || typeof state !== 'object' ? null : state.lastFetchAt
+      const when = formatRelative(at, now, t)
+      return when === '' ? t('fetch.never') : t('fetch.last', { when })
+    }
+
+    /**
+     * Why restoring is unavailable for one entry, in one sentence.
+     *
+     * The reasons come from the host (`canRestore`), which is the only side that
+     * can compare the archive against the current tree. Anything unrecognised
+     * falls back to the honest general statement rather than a blank line.
+     */
+    function restoreReasonText(t, reason) {
+      if (reason === 'changed') return t('trash.restoreChanged')
+      if (reason === 'no-content') return t('trash.restoreNoContent')
+      if (reason === 'other-repo') return t('trash.restoreOtherRepo')
+      if (reason === 'no-repo') return t('trash.restoreNoRepo')
+      return t('trash.restoreNoContent')
+    }
+
     /** How many of a status payload's files are ticked and commit-ready. */
     function stagedCount(state) {
       if (state === null || !Array.isArray(state.files)) return 0
@@ -586,6 +660,63 @@ window.__ModuleLoader__.load({
       return Ink
     }
 
+    /**
+     * The same box, for artwork that is filled rather than stroked.
+     *
+     * The status marks are GitHub Desktop's own `diff-*` octicons
+     * (`app/src/ui/octicons/status.ts` `iconForStatus`), and each is a single
+     * filled path whose sub-paths draw both the frame and the mark inside it.
+     * Stroking one would draw the outline of an outline, so this variant puts
+     * `fill="currentColor"` on the path and leaves the box `fill="none"`, which
+     * is the filled twin of the rule above.
+     *
+     * These are deliberately *not* DSH's artwork: DSH has no changed-file status
+     * marks to copy, and the panel is meant to read like GitHub Desktop. The
+     * paths below are the octicon sources verbatim.
+     */
+    function filledArtwork(viewBox, paths) {
+      const Ink = ({ size = 16, className }) =>
+        h(
+          'svg',
+          {
+            width: size,
+            height: size,
+            className,
+            viewBox,
+            fill: 'none',
+            xmlns: 'http://www.w3.org/2000/svg',
+            'aria-hidden': 'true',
+          },
+          paths.map((d, index) => h('path', { key: `f${index}`, d, fill: 'currentColor' })),
+        )
+      return Ink
+    }
+
+    /** `diff-added` — a new file, and an untracked one, exactly as Desktop draws them. */
+    const StatusAddedGlyph = filledArtwork('0 0 16 16', [
+      'M2.75 1h10.5c.966 0 1.75.784 1.75 1.75v10.5A1.75 1.75 0 0 1 13.25 15H2.75A1.75 1.75 0 0 1 1 13.25V2.75C1 1.784 1.784 1 2.75 1Zm10.5 1.5H2.75a.25.25 0 0 0-.25.25v10.5c0 .138.112.25.25.25h10.5a.25.25 0 0 0 .25-.25V2.75a.25.25 0 0 0-.25-.25ZM8 4a.75.75 0 0 1 .75.75v2.5h2.5a.75.75 0 0 1 0 1.5h-2.5v2.5a.75.75 0 0 1-1.5 0v-2.5h-2.5a.75.75 0 0 1 0-1.5h2.5v-2.5A.75.75 0 0 1 8 4Z',
+    ])
+
+    /** `diff-modified`. */
+    const StatusModifiedGlyph = filledArtwork('0 0 16 16', [
+      'M13.25 1c.966 0 1.75.784 1.75 1.75v10.5A1.75 1.75 0 0 1 13.25 15H2.75A1.75 1.75 0 0 1 1 13.25V2.75C1 1.784 1.784 1 2.75 1ZM2.75 2.5a.25.25 0 0 0-.25.25v10.5c0 .138.112.25.25.25h10.5a.25.25 0 0 0 .25-.25V2.75a.25.25 0 0 0-.25-.25ZM8 10a2 2 0 1 1-.001-3.999A2 2 0 0 1 8 10Z',
+    ])
+
+    /** `diff-removed`. */
+    const StatusDeletedGlyph = filledArtwork('0 0 16 16', [
+      'M13.25 1c.966 0 1.75.784 1.75 1.75v10.5A1.75 1.75 0 0 1 13.25 15H2.75A1.75 1.75 0 0 1 1 13.25V2.75C1 1.784 1.784 1 2.75 1ZM2.75 2.5a.25.25 0 0 0-.25.25v10.5c0 .138.112.25.25.25h10.5a.25.25 0 0 0 .25-.25V2.75a.25.25 0 0 0-.25-.25Zm8.5 6.25h-6.5a.75.75 0 0 1 0-1.5h6.5a.75.75 0 0 1 0 1.5Z',
+    ])
+
+    /** `diff-renamed`. */
+    const StatusRenamedGlyph = filledArtwork('0 0 16 16', [
+      'M13.25 1c.966 0 1.75.784 1.75 1.75v10.5A1.75 1.75 0 0 1 13.25 15H2.75A1.75 1.75 0 0 1 1 13.25V2.75C1 1.784 1.784 1 2.75 1ZM2.75 2.5a.25.25 0 0 0-.25.25v10.5c0 .138.112.25.25.25h10.5a.25.25 0 0 0 .25-.25V2.75a.25.25 0 0 0-.25-.25Zm9.03 6.03-3.25 3.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734l1.97-1.97H4.75a.75.75 0 0 1 0-1.5h4.69L7.47 5.28a.751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018l3.25 3.25a.75.75 0 0 1 0 1.06Z',
+    ])
+
+    /** `alert`. */
+    const StatusConflictGlyph = filledArtwork('0 0 16 16', [
+      'M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z',
+    ])
+
     /** `IconBranchOutlineRegular` — the panel's own mark. */
     const GitGlyph = artwork(
       '0 0 16 16',
@@ -612,16 +743,18 @@ window.__ModuleLoader__.load({
       [],
     )
 
-    /** `IconArchiveOutlineRegular`. */
-    const ArchiveGlyph = artwork(
-      '0 0 16 16',
-      [
-        'M13.5 2.5H2.5C1.94772 2.5 1.5 2.94772 1.5 3.5V4.5C1.5 5.05228 1.94772 5.5 2.5 5.5H13.5C14.0523 5.5 14.5 5.05228 14.5 4.5V3.5C14.5 2.94772 14.0523 2.5 13.5 2.5Z',
-        'M2.5 5.5V13.5C2.5 13.7652 2.60536 14.0196 2.79289 14.2071C2.98043 14.3946 3.23478 14.5 3.5 14.5H12.5C12.7652 14.5 13.0196 14.3946 13.2071 14.2071C13.3946 14.0196 13.5 13.7652 13.5 13.5V5.5',
-        'M6.5 9.5H9.5',
-      ],
-      [],
-    )
+    /**
+     * The restore mark: an arc with a head, drawn to the host's own icon
+     * specification (16 box, `stroke` on each path, `Regular` weight).
+     *
+     * DSH ships no undo/restore glyph to copy — `IconTrashOutlineRegular` is as
+     * close as its icon set gets, and that is what the *discard* button already
+     * uses, so reusing it for the opposite verb would be actively confusing.
+     */
+    const RestoreGlyph = artwork('0 0 16 16', [
+      'M2.9 7.4A5.1 5.1 0 1 1 7.1 12.3',
+      'M2.3 3.6V7.4H6.1',
+    ], [])
 
     /** `IconRefreshOutlineRegular`. */
     const RefreshGlyph = artwork(
@@ -716,16 +849,23 @@ window.__ModuleLoader__.load({
       '.gitbar-tick-partial{border-color:var(--dsw-alias-state-business-primary,#4d6bfe)}',
       '.gitbar-tick svg{width:11px;height:11px;display:block}',
       '.gitbar-tick-partial span{display:block;width:7px;height:1.5px;background:var(--dsw-alias-state-business-primary,#4d6bfe)}',
-      '.gitbar-letter{flex:none;width:13px;text-align:center;font-size:10.5px;font-weight:600;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}',
-      '.gitbar-letter-m{color:var(--dsw-alias-state-warn-primary,#b45309)}',
-      '.gitbar-letter-a{color:var(--dsw-alias-state-success-primary,#15803d)}',
-      '.gitbar-letter-d{color:var(--dsw-alias-state-error-primary,#b91c1c)}',
-      '.gitbar-letter-r{color:var(--dsw-alias-state-business-primary,#4d6bfe)}',
-      '.gitbar-letter-u{color:var(--dsw-alias-label-tertiary,#6b7280)}',
-      '.gitbar-letter-c{color:var(--dsw-alias-state-error-primary,#b91c1c)}',
+      '.gitbar-contextBtn{width:auto;height:24px;padding:0 10px;font-size:12px;font-weight:500;border-color:transparent;background:var(--dsw-alias-state-business-primary,#4d6bfe);color:var(--dsw-static-neutral-bluish-00,#fff)}',
+      '.gitbar-contextBtn:hover:not(:disabled){background:var(--dsw-alias-state-business-primary,#4d6bfe);filter:brightness(1.08)}',
+      '.gitbar-lastFetch{flex:none;font-size:10.5px;color:var(--dsw-alias-label-tertiary,#6b7280);white-space:nowrap}',
+      '.gitbar-status{flex:none;display:inline-flex;align-items:center;justify-content:center;width:14px;height:14px}',
+      '.gitbar-status svg{display:block}',
+      '.gitbar-status-added{color:var(--dsw-alias-state-success-primary,#15803d)}',
+      '.gitbar-status-modified{color:var(--dsw-alias-state-warn-primary,#b45309)}',
+      '.gitbar-status-deleted{color:var(--dsw-alias-state-error-primary,#b91c1c)}',
+      '.gitbar-status-renamed{color:var(--dsw-alias-state-business-primary,#4d6bfe)}',
+      '.gitbar-status-conflicted{color:var(--dsw-alias-state-error-primary,#b91c1c)}',
       '.gitbar-path{flex:1 1 auto;min-width:0;display:flex;align-items:baseline;gap:0;overflow:hidden}',
-      '.gitbar-name{flex:0 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
-      '.gitbar-dir{flex:0 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-tertiary,#6b7280)}',
+      '.gitbar-dir{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;direction:rtl;text-align:left;color:var(--dsw-alias-label-tertiary,#6b7280)}',
+      // `direction` is inherited, so the rtl above would otherwise reach the
+      // separator (moving the slash to the wrong end) and the file name (right-
+      // aligning it). Both are spelled back to ltr explicitly.
+      '.gitbar-sep{flex:none;direction:ltr;color:var(--dsw-alias-label-tertiary,#6b7280)}',
+      '.gitbar-name{flex:0 1 auto;min-width:0;direction:ltr;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
       '.gitbar-stats{flex:none;display:flex;gap:3px;font-size:10.5px;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}',
       '.gitbar-plus{color:var(--dsw-alias-state-success-primary,#15803d)}',
       '.gitbar-minus{color:var(--dsw-alias-state-error-primary,#b91c1c)}',
@@ -787,6 +927,7 @@ window.__ModuleLoader__.load({
       '.gitbar-trashFiles{font-size:11px;color:var(--dsw-alias-label-tertiary,#6b7280);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
       '.gitbar-toggle{display:inline-flex;align-items:center;gap:5px;font-size:11px;color:var(--dsw-alias-label-tertiary,#6b7280);cursor:pointer;user-select:none;white-space:nowrap}',
       '.gitbar-toggle input{margin:0;accent-color:var(--dsw-alias-state-business-primary,#4d6bfe)}',
+      '.gitbar-trashWhy{display:block;font-size:10.5px;color:var(--dsw-alias-state-warn-primary,#92400e)}',
       '.gitbar-spacer{flex:1 1 auto}',
       '.gitbar-loading{padding:18px 12px;color:var(--dsw-alias-label-tertiary,#6b7280);font-size:11.5px;display:flex;align-items:center;gap:6px}',
       '.gitbar-spin{display:inline-block;width:13px;height:13px;flex:none;animation:gitbar-spin .9s linear infinite}',
@@ -929,12 +1070,16 @@ window.__ModuleLoader__.load({
      * 8. The panel
      * ------------------------------------------------------------------ */
 
-    /** One changed file. */
+    /** One changed file, laid out the way GitHub Desktop lays one out. */
     function ChangeRow({ file, t, onToggle, onDiscard, onOpen }) {
-      const letter = statusLetter(file)
-      const letterClass =
-        letter === 'M' ? 'm' : letter === 'A' ? 'a' : letter === 'D' ? 'd' : letter === 'R' ? 'r' : letter === '?' ? 'u' : 'c'
+      const kind = statusKind(file)
+      const Mark = statusGlyph(kind)
       const parts = splitPath(file.path)
+      // Desktop renders the directory *before* the name and lets the directory be
+      // the part that truncates, so the name survives. The separator is its own
+      // node because `direction:rtl` (how the directory gets a leading ellipsis)
+      // would move a trailing slash to the other end of the text.
+      const dir = parts.dir.endsWith('/') ? parts.dir.slice(0, -1) : parts.dir
       const display = file.origPath === undefined ? file.path : `${file.origPath} → ${file.path}`
 
       return h(
@@ -943,6 +1088,7 @@ window.__ModuleLoader__.load({
           className: 'gitbar-row',
           'data-gitbar-row': file.path,
           'data-gitbar-staged': file.staged === true ? 'true' : 'false',
+          'data-gitbar-kind': kind,
           title: display,
           onDoubleClick: () => onOpen(file.path),
         },
@@ -964,10 +1110,10 @@ window.__ModuleLoader__.load({
             },
             file.staged === true && !file.partial ? h(CheckGlyph, { size: 11 }) : file.partial === true ? h('span', {}) : null,
           ),
-          h('span', { key: 'letter', className: `gitbar-letter gitbar-letter-${letterClass}` }, letter),
           h('span', { key: 'path', className: 'gitbar-path' }, [
+            dir === '' ? null : h('span', { key: 'dir', className: 'gitbar-dir' }, dir),
+            dir === '' ? null : h('span', { key: 'sep', className: 'gitbar-sep' }, '/'),
             h('span', { key: 'name', className: 'gitbar-name' }, parts.name),
-            parts.dir === '' ? null : h('span', { key: 'dir', className: 'gitbar-dir' }, ` ${parts.dir}`),
           ]),
           h('span', { key: 'stats', className: 'gitbar-stats' }, [
             (file.added ?? 0) > 0 ? h('span', { key: 'p', className: 'gitbar-plus' }, `+${file.added}`) : null,
@@ -989,6 +1135,19 @@ window.__ModuleLoader__.load({
             },
             h(TrashGlyph, { size: 14 }),
           ),
+          // Last in the row, as in Desktop: the checkbox and the path start the
+          // row, the mark ends it.
+          h(
+            'span',
+            {
+              key: 'mark',
+              className: `gitbar-status gitbar-status-${kind}`,
+              'data-gitbar-status': kind,
+              title: t(`status.${kind}`),
+              'aria-label': t(`status.${kind}`),
+            },
+            h(Mark, { size: 13 }),
+          ),
         ],
       )
     }
@@ -1178,6 +1337,50 @@ window.__ModuleLoader__.load({
         }
       }, [tab.visible, sessionId, load])
 
+      // Fetch on a rhythm, unattended, while the panel is actually being looked
+      // at. Three conditions gate it, and each one exists for a reason:
+      //
+      //   * the tab must be visible — a hidden panel has no business touching the
+      //     network every few minutes, and the host may have several sessions;
+      //   * the repository must have a remote — otherwise `fetch` is a guaranteed
+      //     E_NO_REMOTE, and a timer that only ever fails is noise;
+      //   * nothing else may be in flight — a user mid-commit must not have an
+      //     extra git child appear under them.
+      //
+      // A failure is silent. The button stays there, the banner stays quiet, and
+      // the next tick tries again: a fetch that failed once (offline, credential
+      // prompt suppressed) usually succeeds later, and a panel that pops an error
+      // every five minutes for a laptop that was closed is worse than one that
+      // says nothing. Success refreshes the status, which is what moves
+      // ahead/behind and the "last fetch" line.
+      //
+      // The conditions are read through a ref rather than listed as dependencies
+      // on purpose: a dependency on `state` would restart the clock on every
+      // refresh, and a panel the user keeps interacting with would then never
+      // fetch at all.
+      const latest = useRef({ state: null, busy: null })
+      latest.current = { state, busy }
+
+      const autoFetchMs = typeof state?.autoFetchMs === 'number' && state.autoFetchMs > 0 ? state.autoFetchMs : 0
+      useEffect(() => {
+        if (autoFetchMs === 0) return undefined
+        if (tab.visible === false) return undefined
+
+        const timer = setInterval(() => {
+          const current = latest.current
+          if (current.busy !== null) return
+          if (!Array.isArray(current.state?.remotes) || current.state.remotes.length === 0) return
+          void rpc(ACTIONS.FETCH, { sessionId }, tab.signal)
+            .then(() => {
+              if (alive.current) void load({ quiet: true })
+            })
+            .catch(() => {
+              // Deliberately swallowed: see the note above.
+            })
+        }, autoFetchMs)
+        return () => clearInterval(timer)
+      }, [autoFetchMs, tab.visible, tab.signal, sessionId, load])
+
       // The column's refresh shortcut, when it has one.
       useEffect(
         () => (typeof tab.actions?.bindCommands === 'function' ? tab.actions.bindCommands({ refresh: () => void load({ quiet: true }) }) : undefined),
@@ -1234,6 +1437,29 @@ window.__ModuleLoader__.load({
         [run],
       )
 
+      // Everything changed is ticked by default, which is what GitHub Desktop
+      // does and what the panel is asked to match. Our tick *is* the index, so
+      // "ticked by default" has to mean staging every changed path once: the
+      // first time the panel looks at a repository whose index is empty. A file
+      // the user unticks leaves the index non-empty, so this cannot fight a
+      // deliberate choice — and the ref guard means a failure does not loop.
+      //
+      // Conflicted paths are excluded on purpose: `git add` on a conflicted file
+      // records a resolution, and nothing has been resolved at this point.
+      const autoStaged = useRef('')
+      useEffect(() => {
+        if (state === null || phase !== 'ready' || busy !== null) return
+        if (state.repoRoot === null || state.repoRoot === undefined) return
+        const files = Array.isArray(state.files) ? state.files : []
+        const auto = files.filter((file) => file.conflicted !== true).map((file) => file.path)
+        if (auto.length === 0) return
+        if ((state.counts?.staged ?? 0) > 0) return
+        const key = `${state.repoRoot}\u0000${auto.join('\u0000')}`
+        if (autoStaged.current === key) return
+        autoStaged.current = key
+        void run('stage', ACTIONS.STAGE, { paths: auto, staged: true })
+      }, [state, phase, busy, run])
+
       const openDiff = useCallback(
         (path) => {
           setNotice(null)
@@ -1398,16 +1624,21 @@ window.__ModuleLoader__.load({
                 disabled: busy !== null,
                 onClick: runContext,
                 className: 'gitbar-contextBtn',
-                attrs: { 'data-gitbar-context': state.primary ?? 'fetch', style: { width: 'auto', padding: '0 8px', fontWeight: 500 } },
+                attrs: { 'data-gitbar-context': state.primary ?? 'fetch' },
               },
               h('span', { style: { whiteSpace: 'nowrap' } }, t(contextLabelKey(state))),
             ),
+            h(
+              'span',
+              { key: 'last', className: 'gitbar-lastFetch', 'data-gitbar-lastfetch': state.lastFetchAt ?? '' },
+              lastFetchLabel(state, Date.now(), t),
+            ),
             h(
               IconButton,
               { key: 'refresh', label: t('action.refresh'), disabled: busy !== null, onClick: () => void load({ quiet: true }) },
               h(RefreshGlyph, {}),
             ),
-            h(IconButton, { key: 'trash', label: t('action.trash'), onClick: openTrash }, h(ArchiveGlyph, {})),
+            h(IconButton, { key: 'trash', label: t('action.trash'), onClick: openTrash }, h(TrashGlyph, {})),
             h(
               IconButton,
               { key: 'rebind', label: t('action.rebind'), disabled: busy !== null, onClick: () => bind(null) },
@@ -1506,7 +1737,7 @@ window.__ModuleLoader__.load({
               {
                 key: 'commit',
                 type: 'button',
-                className: 'gitbar-btn gitbar-btn-primary',
+                className: 'gitbar-btn',
                 title: canCommit ? '' : commitHint,
                 disabled: !canCommit,
                 'data-gitbar-commit': '',
@@ -1519,7 +1750,7 @@ window.__ModuleLoader__.load({
               {
                 key: 'push',
                 type: 'button',
-                className: 'gitbar-btn',
+                className: 'gitbar-btn gitbar-btn-primary',
                 title: canCommit ? '' : commitHint,
                 disabled: !canCommit,
                 'data-gitbar-commitpush': '',
@@ -1611,6 +1842,25 @@ window.__ModuleLoader__.load({
         [sessionId, load, tab.signal],
       )
 
+      // Restoring is offered only when the working tree still matches what the
+      // discard left behind, which the host decides and reports per entry. The
+      // check is re-run server side inside the action, so a row that renders as
+      // enabled cannot fail and a row that renders as disabled cannot lie.
+      const restoreEntry = useCallback(
+        async (entry) => {
+          setBusy(entry.id)
+          try {
+            await rpc(ACTIONS.TRASH_RESTORE, { sessionId, id: entry.id }, tab.signal)
+            await load({ quiet: true })
+          } catch (failure) {
+            if (failure?.name !== 'AbortError') setError({ code: failure.code ?? 'E_UNKNOWN', message: failure.message })
+          } finally {
+            setBusy(null)
+          }
+        },
+        [sessionId, load, tab.signal],
+      )
+
       const clearAll = useCallback(async () => {
         setConfirmClear(false)
         setBusy('clear')
@@ -1733,8 +1983,28 @@ window.__ModuleLoader__.load({
                         { key: 'files', className: 'gitbar-trashFiles', title: (entry.files ?? []).map((file) => file.path).join('\n') },
                         (entry.files ?? []).map((file) => shortPath(file.path)).slice(0, 3).join(' · '),
                       ),
+                      // Why restoring is off, when it is: the archive outlived the
+                      // state it was taken from.
+                      entry.restorable?.ok === true
+                        ? null
+                        : h('span', { key: 'why', className: 'gitbar-trashWhy' }, restoreReasonText(t, entry.restorable?.reason)),
                     ]),
                   ),
+                  h(
+                    'span',
+                    { key: 'act', style: { flex: 'none', display: 'flex', alignItems: 'flex-start', padding: '7px 4px 0 0' } },
+                    h(
+                      IconButton,
+                      {
+                        key: 'restore',
+                        label: t('action.restore'),
+                        disabled: busy !== null || entry.restorable?.ok !== true,
+                        onClick: () => void restoreEntry(entry),
+                        attrs: { 'data-gitbar-restore': entry.id },
+                      },
+                      h(RestoreGlyph, { size: 14 }),
+                    ),
+                  ),
                   h(
                     'span',
                     { key: 'del', style: { flex: 'none', display: 'flex', alignItems: 'flex-start', padding: '7px 6px 0 0' } },
@@ -1913,7 +2183,7 @@ window.__ModuleLoader__.load({
     function TrashTitle(props) {
       const t = props.t ?? fallbackTranslate()
       return h('span', { className: 'gitbar-tabTitle' }, [
-        h(ArchiveGlyph, { key: 'g', size: 14 }),
+        h(TrashGlyph, { key: 'g', size: 14 }),
         h('span', { key: 'l', className: 'gitbar-tabTitleText' }, t('trash.title')),
       ])
     }
@@ -2129,9 +2399,12 @@ window.__ModuleLoader__.load({
       ZH,
       EN,
       diffRows,
-      statusLetter,
+      statusKind,
+      statusGlyph,
       splitPath,
       formatRelative,
+      lastFetchLabel,
+      restoreReasonText,
       stagedCount,
       hasConflict,
       contextLabelKey,

package/lib/host/repo.js

@@ -20,8 +20,8 @@
  * @module dsh-gitbar-lite/host/repo
  */
 
-import { readFile, readdir, rm, stat } from 'node:fs/promises'
-import { basename, join, resolve, sep } from 'node:path'
+import { mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises'
+import { basename, dirname, join, resolve, sep } from 'node:path'
 
 import { DISCARD_SCOPE, ERROR_CODES, FILE_STATUS, PRIMARY_ACTIONS } from '../shared.js'
 import {
@@ -177,6 +177,28 @@ export function classifyGitFailure(error, fallbackCode = ERROR_CODES.GIT_FAILED)
   return new RepoError(fallbackCode, String(error?.message ?? error))
 }
 
+/**
+ * The mtime of `FETCH_HEAD`, as an ISO string, or `null` when there is none.
+ *
+ * Every `git fetch` and `git pull` writes that file, which makes its mtime the
+ * honest answer to "when did this repository last talk to a remote" — including
+ * for a checkout this plugin has never seen, and including a fetch run in a
+ * terminal. A missing file means nobody has fetched yet, which is not an error.
+ *
+ * @param {{ exitCode: number | null, stdout: string }} gitDirResult the outcome of `rev-parse --absolute-git-dir`
+ * @returns {Promise<string | null>}
+ */
+async function fetchTimeOf(gitDirResult) {
+  if (gitDirResult.exitCode !== 0) return null
+  const dir = gitDirResult.stdout.trim()
+  if (dir === '') return null
+  try {
+    return (await stat(join(dir, 'FETCH_HEAD'))).mtime.toISOString()
+  } catch {
+    return null
+  }
+}
+
 /**
  * Build the repository facade for one plugin instance.
  *
@@ -184,6 +206,13 @@ export function classifyGitFailure(error, fallbackCode = ERROR_CODES.GIT_FAILED)
  * @param {object} config resolved plugin config
  */
 export function createRepo(git, config) {
+  /**
+   * How often the panel should fetch on its own, in milliseconds, or 0 for
+   * "never". Resolved once: the value rides along with every status payload,
+   * because a client bundle cannot read the host's config.
+   */
+  const autoFetchMs = Number.isFinite(config.autoFetchMs) && config.autoFetchMs > 0 ? Math.floor(config.autoFetchMs) : 0
+
   /**
    * Identity, branch and working-tree status of one repository.
    *
@@ -191,14 +220,18 @@ export function createRepo(git, config) {
    * @param {AbortSignal} [signal]
    */
   async function readStatus(repoRoot, signal) {
-    // The four probes are independent, so they share one round of latency.
+    // The probes are independent, so they share one round of latency.
     // `GIT_OPTIONAL_LOCKS=0` (set by the runner) is what makes the index reads
     // safe to overlap.
-    const [statusResult, numstatResult, remotesResult, headResult] = await Promise.all([
+    const [statusResult, numstatResult, remotesResult, headResult, gitDirResult] = await Promise.all([
       git.run(['status', '--porcelain=v2', '--branch', '-z', '--untracked-files=all'], { cwd: repoRoot, signal }),
       git.run(['diff', '--numstat', '-z', '--find-renames', 'HEAD'], { cwd: repoRoot, signal }),
       git.run(['remote'], { cwd: repoRoot, signal }),
       git.run(['log', '-1', '--pretty=%H%x00%h%x00%s'], { cwd: repoRoot, signal }),
+      // Where `.git` really is, so FETCH_HEAD can be found without assuming a
+      // plain directory: a worktree's git directory lives somewhere else, and a
+      // submodule's is inside the parent's.
+      git.run(['rev-parse', '--absolute-git-dir'], { cwd: repoRoot, signal }),
     ])
 
     if (statusResult.exitCode !== 0) {
@@ -263,6 +296,12 @@ export function createRepo(git, config) {
           ? PRIMARY_ACTIONS.PUBLISH
           : PRIMARY_ACTIONS.FETCH
 
+    // When the last fetch happened, asked of git rather than remembered by this
+    // plugin: `git fetch` (and `git pull`) rewrites FETCH_HEAD every time, so a
+    // fetch run in a terminal counts as well, and there is no state of ours to
+    // lose or to disagree with the repository.
+    const lastFetchAt = await fetchTimeOf(gitDirResult)
+
     return {
       repoRoot,
       repoName: basename(repoRoot),
@@ -272,6 +311,11 @@ export function createRepo(git, config) {
       files: enriched,
       counts,
       primary,
+      lastFetchAt,
+      // The panel cannot read the host's config (a client bundle has no access to
+      // it), so the rhythm it should fetch on travels with the status it is
+      // already reading. Zero means "never, on your own".
+      autoFetchMs,
     }
   }
 
@@ -587,6 +631,13 @@ export function createRepo(git, config) {
         }
       })
 
+      // What it would take to put this back. The content is read now, before
+      // anything is destroyed, because the archive is the only copy left: the
+      // diff alone cannot be replayed into a file. A path whose content cannot be
+      // carried (too large, or binary, or the diff was truncated) is recorded as
+      // unrestorable with a reason, so the UI can say why instead of failing.
+      const restorable = await buildRestorable(repoRoot, chosen, detailByPath, signal)
+
       entry = await archive(
         {
           repoRoot,
@@ -600,6 +651,7 @@ export function createRepo(git, config) {
           bytes: Buffer.byteLength(limited.text, 'utf8'),
           truncated: limited.truncated,
           droppedLines: limited.droppedLines,
+          restorable,
         },
         limited.text,
       )
@@ -725,5 +777,171 @@ export function createRepo(git, config) {
     return { scanned: visited, truncated: queue.length > 0, repos: found }
   }
 
-  return { readStatus, statusOf, setStaged, commit, push, fetch, fileDiff, discard, scanRepos }
+  /**
+   * What each discarded path would need in order to be put back.
+   *
+   * The content is carried as base64 because it is bytes, not text: a file with
+   * CRLF endings, a latin-1 comment, or a NUL byte survives a round trip through
+   * a JSON string only by accident, and this is the last copy of it. The size cap
+   * is the same one the diff is capped by, so an archive that says "truncated"
+   * never promises a restore it cannot perform.
+   *
+   * @param {string} repoRoot
+   * @param {readonly object[]} chosen the status entries being discarded
+   * @param {Map<string, object>} detailByPath the already-read untracked details
+   * @param {AbortSignal} [signal]
+   */
+  async function buildRestorable(repoRoot, chosen, detailByPath, signal) {
+    const payload = []
+    for (const file of chosen) {
+      const detail = file.untracked === true ? detailByPath.get(file.path) : undefined
+      const absolute = absoluteIn(repoRoot, file.path)
+
+      let bytes
+      try {
+        bytes = await readFile(absolute)
+      } catch {
+        // The worktree copy is gone (a deletion). There is nothing to carry: the
+        // "before" content lives in HEAD, and restoring means taking it back from
+        // there, which is what `git restore` already did.
+        payload.push({ path: file.path, content: null, mode: null, restorable: false, reason: 'missing' })
+        continue
+      }
+
+      if (bytes.length > config.maxFileBytes) {
+        payload.push({ path: file.path, content: null, mode: null, restorable: false, reason: 'oversized' })
+        continue
+      }
+
+      const binary = file.untracked === true ? detail?.binary === true : looksBinary(bytes)
+      if (binary) {
+        // Binary content is carried too — it is bytes either way — but the panel
+        // will not pretend it can preview it.
+        payload.push({
+          path: file.path,
+          content: bytes.toString('base64'),
+          mode: file.untracked === true ? detail?.mode ?? '100644' : null,
+          restorable: true,
+          binary: true,
+        })
+        continue
+      }
+
+      payload.push({
+        path: file.path,
+        content: bytes.toString('base64'),
+        mode: file.untracked === true ? detail?.mode ?? '100644' : null,
+        restorable: true,
+        binary: false,
+      })
+    }
+    return payload
+  }
+
+  /**
+   * Whether one archived discard could be put back right now.
+   *
+   * The question the user asked is exactly this one: *if the version the archive
+   * was based on is still the current version, restoring is offered; otherwise it
+   * is not.* The comparison is one `git diff --quiet HEAD -- <paths>` per entry,
+   * which is also the first thing `restore` checks — so a button that says it is
+   * enabled cannot turn into a refusal.
+   *
+   * @param {string} repoRoot
+   * @param {object} entry the trash entry
+   * @param {readonly object[]} payload its `restorable` array
+   * @param {AbortSignal} [signal]
+   * @returns {Promise<{ ok: boolean, reason?: string }>}
+   */
+  async function canRestore(repoRoot, entry, payload, signal) {
+    if (!Array.isArray(payload) || payload.length === 0) return { ok: false, reason: 'no-content' }
+    if (payload.every((item) => item.restorable !== true)) return { ok: false, reason: 'no-content' }
+
+    // An entry recorded against a different repository cannot be restored into
+    // this one: the paths mean something else there.
+    if (typeof entry?.repoRoot === 'string' && entry.repoRoot !== '' && resolve(entry.repoRoot) !== resolve(repoRoot)) {
+      return { ok: false, reason: 'other-repo' }
+    }
+
+    const pathspec = payload.map((item) => literal(item.path))
+    const untouched = await git.run(['diff', '--quiet', 'HEAD', '--', ...pathspec], { cwd: repoRoot, signal })
+    if (untouched.exitCode === 0) return { ok: true }
+    if (untouched.exitCode === 1) return { ok: false, reason: 'changed' }
+    return { ok: false, reason: 'unknown' }
+  }
+
+  /**
+   * Put one archived discard back into the working tree.
+   *
+   * Refused, with nothing written, unless the working tree still matches what the
+   * discard produced: every file the archive touched must be identical to its
+   * HEAD version (or, for a file the discard deleted, still absent). Anything
+   * else means work happened after the archive was taken, and writing over it
+   * would be the one operation this plugin must never do.
+   *
+   * A partially matching entry is refused as a whole rather than restored file by
+   * file: an all-or-nothing discard restored half-way is a tree nobody can
+   * reason about.
+   *
+   * @param {string} repoRoot
+   * @param {object} entry the trash entry
+   * @param {readonly object[]} payload its `restorable` array
+   * @param {AbortSignal} [signal]
+   * @returns {Promise<{ restored: string[], skipped: string[] }>}
+   */
+  async function restore(repoRoot, entry, payload, signal) {
+    if (!Array.isArray(payload) || payload.length === 0) {
+      throw new RepoError(ERROR_CODES.TRASH_NOT_RESTORABLE, '这条记录没有可恢复的内容（舍弃时没留下副本）。')
+    }
+
+    const entries = Array.isArray(entry?.files) ? entry.files : []
+    if (entries.length !== payload.length) {
+      throw new RepoError(ERROR_CODES.TRASH_NOT_RESTORABLE, '这条记录的内容和文件列表不一致，无法安全恢复。')
+    }
+
+    // The one check that decides everything: does the working tree still look the
+    // way the discard left it? Reusing `canRestore` means the answer the button
+    // was rendered from is the answer that is enforced here — a disabled button
+    // cannot turn into a refusal, and an enabled one cannot surprise.
+    const eligibility = await canRestore(repoRoot, entry, payload, signal)
+    if (!eligibility.ok) {
+      const message =
+        eligibility.reason === 'changed'
+          ? '这些文件在舍弃之后又被改过了，恢复会盖掉后来的改动。要恢复请先提交或再舍弃一次。'
+          : eligibility.reason === 'other-repo'
+            ? '这条记录属于另一个仓库，不能恢复到当前仓库。'
+            : '这条记录里没有可以恢复的内容。'
+      throw new RepoError(ERROR_CODES.TRASH_NOT_RESTORABLE, message)
+    }
+
+    const restored = []
+    const skipped = []
+    for (const item of payload) {
+      if (item.restorable !== true || typeof item.content !== 'string' || item.content === '') {
+        skipped.push(item.path)
+        continue
+      }
+      const absolute = absoluteIn(repoRoot, item.path)
+      await mkdir(dirname(absolute), { recursive: true })
+      await writeFile(absolute, Buffer.from(item.content, 'base64'))
+
+      // The content is back on disk but the index is not: staging it restores the
+      // tick the user had, which is the state the panel was showing when they
+      // asked to discard. Untracked files are staged as well, because a discard
+      // that archived them removed them entirely.
+      const added = await git.run(['add', '--', literal(item.path)], { cwd: repoRoot, signal })
+      if (added.exitCode !== 0) {
+        throw classifyGitFailure({ ...added, message: `git add failed: ${added.stderr.trim()}` })
+      }
+      restored.push(item.path)
+    }
+
+    if (restored.length === 0) {
+      throw new RepoError(ERROR_CODES.TRASH_NOT_RESTORABLE, '这条记录里没有任何可以恢复的内容。')
+    }
+
+    return { restored, skipped }
+  }
+
+  return { readStatus, statusOf, setStaged, commit, push, fetch, fileDiff, discard, restore, canRestore, scanRepos }
 }

package/lib/host/routes.js

@@ -287,7 +287,7 @@ export function createHandlers({ ctx, git, repo, store }) {
         // The entry id is minted here rather than in `repo.discard` so the git
         // layer stays free of any notion of where archives are stored.
         archive: (entry, diffText) =>
-          store.appendTrash({ ...entry, id: trashId(), at: new Date().toISOString() }, diffText),
+          store.appendTrash({ ...entry, id: trashId(), at: new Date().toISOString() }, diffText, entry.restorable),
       })
 
       // Remember the choice: the confirmation box opens on whatever the user
@@ -317,12 +317,14 @@ export function createHandlers({ ctx, git, repo, store }) {
           ? all
           : all.filter((entry) => typeof entry.repoRoot === 'string' && workspaceKey(entry.repoRoot) === workspaceKey(binding.repoRoot))
 
-      return {
-        workspacePath: workspace.cwd,
-        repoRoot: binding.repoRoot ?? null,
-        showAll,
-        total: all.length,
-        entries: filtered.map((entry) => ({
+      const entries = []
+      for (const entry of filtered) {
+        const restorable = await store.readTrashRestore(entry)
+        // Which repository this entry belongs to: the bound one when we are not
+        // showing every repository, and the entry's own recorded root otherwise.
+        // An entry whose root no longer resolves simply cannot be restored.
+        const root = showAll ? entry.repoRoot : binding.repoRoot
+        entries.push({
           id: entry.id,
           at: entry.at,
           repoRoot: entry.repoRoot,
@@ -345,7 +347,19 @@ export function createHandlers({ ctx, git, repo, store }) {
           bytes: entry.bytes ?? 0,
           truncated: entry.truncated === true,
           droppedLines: entry.droppedLines ?? 0,
-        })),
+          restorable:
+            typeof root === 'string' && root !== ''
+              ? await repo.canRestore(root, entry, restorable, request.signal)
+              : { ok: false, reason: 'no-repo' },
+        })
+      }
+
+      return {
+        workspacePath: workspace.cwd,
+        repoRoot: binding.repoRoot ?? null,
+        showAll,
+        total: all.length,
+        entries,
       }
     },
 
@@ -362,6 +376,28 @@ export function createHandlers({ ctx, git, repo, store }) {
       }
     },
 
+    /**
+     * Put one archived discard back.
+     *
+     * The refusal lives in the repository layer, because that is where the
+     * comparison against the current working tree is made — the route only turns
+     * it into the payload the panel disables the button with.
+     */
+    async [ACTIONS.TRASH_RESTORE](payload, request) {
+      const workspace = await requireWorkspace(ctx, stringField(payload, 'sessionId'))
+      const entry = await store.readTrashEntry(stringField(payload, 'id'))
+      if (entry === undefined) throw new RepoError(ERROR_CODES.TRASH_NOT_FOUND, '这条回收站记录已经不存在了。')
+      if (typeof entry.repoRoot !== 'string' || entry.repoRoot === '') {
+        throw new RepoError(ERROR_CODES.NO_REPO, '这条记录没有记下是哪个仓库的，无法恢复。')
+      }
+
+      const content = await store.readTrashRestore(entry)
+      const restored = await repo.restore(entry.repoRoot, entry, content, request.signal)
+
+      const state = await repo.readStatus(entry.repoRoot, request.signal)
+      return { restored, repoRoot: entry.repoRoot, workspacePath: workspace.cwd, ...state }
+    },
+
     async [ACTIONS.TRASH_DELETE](payload) {
       const id = stringField(payload, 'id')
       const removed = await store.removeTrash(id)

package/lib/host/store.js

@@ -271,27 +271,59 @@ export function createStore(ctx, config) {
      *
      * @param {object} entry
      * @param {string} diffText
+     * @param {object[]} [restorable] the per-path content needed to put it back
      */
-    async appendTrash(entry, diffText) {
+    async appendTrash(entry, diffText, restorable) {
       const blobName = `${entry.id}.diff`
       await mkdir(trashDir(), { recursive: true })
       await writeFile(join(trashDir(), blobName), diffText, 'utf8')
 
+      // The restore payload lives beside the diff, not inside it: the diff is the
+      // human-readable record, and this is machine state with a different shape.
+      // Older archives simply have no such file, which reads as "not restorable"
+      // rather than as a broken entry.
+      const contentName = `${entry.id}.content.json`
+      const carriesContent = Array.isArray(restorable) && restorable.length > 0
+      if (carriesContent) {
+        await writeFile(join(trashDir(), contentName), JSON.stringify({ version: STATE_VERSION, files: restorable }), 'utf8')
+      }
+
       let dropped = []
       await mutateJson(trashIndexPath(), { version: STATE_VERSION, entries: [] }, (document) => {
         const existing = Array.isArray(document?.entries) ? document.entries : []
         const limit = Number.isFinite(config.trashLimit) && config.trashLimit > 0 ? config.trashLimit : 200
-        const combined = [{ ...entry, blob: blobName }, ...existing]
+        const combined = [{ ...entry, blob: blobName, ...(carriesContent ? { content: contentName } : {}) }, ...existing]
         dropped = combined.slice(limit)
         return { version: STATE_VERSION, entries: combined.slice(0, limit) }
       })
 
       for (const stale of dropped) {
         if (typeof stale?.blob === 'string') await this.removeTrashBlob(stale.blob)
+        if (typeof stale?.content === 'string') await this.removeTrashBlob(stale.content)
       }
       return entry
     },
 
+    /**
+     * The per-path content one entry would need to be put back, or `[]` when the
+     * entry carries none (an archive written before this existed, or one whose
+     * content was deliberately not kept).
+     *
+     * @param {object} entry
+     * @returns {Promise<object[]>}
+     */
+    async readTrashRestore(entry) {
+      const name = typeof entry?.content === 'string' && entry.content !== '' ? entry.content : `${entry?.id}.content.json`
+      try {
+        const parsed = JSON.parse(await readFile(join(trashDir(), name), 'utf8'))
+        const files = Array.isArray(parsed?.files) ? parsed.files : []
+        return files.filter((file) => file !== null && typeof file === 'object' && typeof file.path === 'string')
+      } catch (error) {
+        if (error?.code !== 'ENOENT') warn(`dsh-gitbar-lite: reading trash content failed: ${String(error?.message ?? error)}`)
+        return []
+      }
+    },
+
     /** One entry's metadata, or `undefined`. */
     async readTrashEntry(id) {
       const entries = await this.readTrash()
@@ -349,7 +381,7 @@ export function createStore(ctx, config) {
       await writeJson(trashIndexPath(), { version: STATE_VERSION, entries: [] })
       try {
         for (const name of await readdir(trashDir())) {
-          if (name.endsWith('.diff')) await this.removeTrashBlob(name)
+          if (name.endsWith('.diff') || name.endsWith('.content.json')) await this.removeTrashBlob(name)
         }
       } catch (error) {
         if (error?.code !== 'ENOENT') warn(`dsh-gitbar-lite: sweeping trash failed: ${String(error?.message ?? error)}`)

package/lib/index.js

@@ -67,6 +67,15 @@ export const Config = vol(
     trashLimit: z.number().default(200),
     /** Directory depth the repository picker scans below the workspace root. */
     scanDepth: z.number().default(3),
+    /**
+     * How often the panel fetches on its own, in milliseconds.
+     *
+     * A fetch only moves remote refs, never the working tree, so it is safe to
+     * do unattended — but it does hit the network and it does write
+     * `.git/FETCH_HEAD`, which is why it is opt-out rather than opt-in. Set to 0
+     * to disable it; the button still works.
+     */
+    autoFetchMs: z.number().default(300000),
   }),
 )
 

package/lib/shared.js

@@ -46,6 +46,14 @@ export const ACTIONS = {
   TRASH_DELETE: 'trashDelete',
   /** Drop every archived entry. */
   TRASH_CLEAR: 'trashClear',
+  /**
+   * Put one archived entry's changes back into the working tree.
+   *
+   * Refused with `E_TRASH_NOT_RESTORABLE` when the files it touched have moved on
+   * since the discard, because writing back then would silently destroy work
+   * that happened after the archive was taken.
+   */
+  TRASH_RESTORE: 'trashRestore',
   /** Read or write the small persisted UI preferences. */
   PREFS: 'prefs',
 }
@@ -70,6 +78,11 @@ export const ERROR_CODES = {
   AUTH: 'E_AUTH',
   PUSH_REJECTED: 'E_PUSH_REJECTED',
   TRASH_NOT_FOUND: 'E_TRASH_NOT_FOUND',
+  /**
+   * The archive is real but the working tree has moved on since it was taken, so
+   * putting it back would overwrite something newer.
+   */
+  TRASH_NOT_RESTORABLE: 'E_TRASH_NOT_RESTORABLE',
   INTERNAL: 'E_INTERNAL',
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-gitbar-lite",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "A GitHub Desktop-style Git panel for DSH: changed files, tick-to-stage, Summary + Description, Commit and Commit and Push, discard-to-trash, and diff preview, in the built-in right sidebar.",
   "type": "module",
   "license": "MIT",