dsh-coding-sidebar 1.0.7 → 1.0.9

package/src/client/Sidebar.tsx

@@ -25,14 +25,16 @@ import { useSyncExternalStore } from 'react'
 import clsx from 'clsx'
 import { Tooltip } from '@deepseek-ai/dsh-client-ui-primitives'
 import type { Context, SidebarSessionList } from '../context-types.ts'
-import { appendToDraft } from './conversation-draft.ts'
+import { appendToDraft, insertFileReference } from './conversation-draft.ts'
 import {
   PANEL_MIN, activateTab, agentUuidOf, closeFloatByTab, closeTab, dockFloat, firstLeaf, floatTab,
-  isAgentTabId, leafWithTab,
+  isAgentTabId, leafWithTab, allLeaves,
   moveFloat, moveTab, moveTabToEdge, openDiffTab, raiseFloat, reconcileAgentTerminals,
   resizeFloat, resizeSplitIn, setTabPin, setWidth, toggleExpanded, togglePanel,
   type DropZone, type SidebarState, type SidebarStore, type SidebarTab,
 } from './state.ts'
+import { baseName } from './FileTree.tsx'
+import { isWithinWorkspace } from './paths.ts'
 import { collectPinnedTabs, createPinnedVirtualTab, getPinnedHomeScope, injectPinnedIntoTree, isPinnedVirtualId, isPinnedVirtualTab, parsePinnedVirtualId, type PinnedTabEntry } from './pinned.ts'
 import { IconPinOutline16 } from './icons.tsx'
 import { IconPanelRightOutline16 } from './icons.tsx'
@@ -119,18 +121,21 @@ function injectUserCss(attr: string, id: string, cssText: string): HTMLStyleElem
  *  pane; sessionId/cwd cover onReferenceFile). */
 interface TabContentProps extends TabContentMemoKey {
   onToggleDir: (path: string) => void
-  onReferenceFile: (path: string) => void
+  onReferenceFile: (path: string, isDir: boolean) => void
   ctx: Context
   store: SidebarStore
   /** Fired before a topology node jumps to its child session (see Sidebar). */
   onSubagentJump: (childSessionId: string) => void
   /** Open a diff tab from the git panel (placement handled by the store). */
   onOpenDiff: (tab: SidebarTab) => void
+  /** Tree-row mutations (threaded to the file tree; see Sidebar's handlers). */
+  onPathRenamed?: (oldPath: string, newPath: string) => void
+  onPathRemoved?: (path: string) => void
 }
 
 /** Render the content of one tab (dispatched by type). */
 const TabContent = memo(function TabContent(props: TabContentProps) {
-  const { tab, effectiveTabId, sessionId, cwd, expanded, revealed, onToggleDir, onReferenceFile, ctx, store, visible, onSubagentJump, onOpenDiff } = props
+  const { tab, effectiveTabId, sessionId, cwd, expanded, revealed, onToggleDir, onReferenceFile, ctx, store, visible, onSubagentJump, onOpenDiff, onPathRenamed, onPathRemoved } = props
   const scope = { sessionId, cwd }
   const descriptor = ctx.get('betterSidebar')?.getTab(tab.type)
   if (descriptor === undefined) {
@@ -394,7 +399,7 @@ export function Sidebar(props: { ctx: Context; store: SidebarStore }) {
       socket.onmessage = (event) => {
         if (typeof event.data !== 'string') return
         try {
-          const list = JSON.parse(event.data) as Array<{ uuid: string; title: string; command: string; exited: boolean }>
+          const list = JSON.parse(event.data) as Array<{ uuid: string; title: string; command: string; exited: boolean; waiting?: { needle: string; since: number } | null }>
           if (!Array.isArray(list)) return
           store.reduce(s => ctx.get('betterSidebar')?.isTabEnabled('terminal') === false
             ? s
@@ -498,8 +503,10 @@ export function Sidebar(props: { ctx: Context; store: SidebarStore }) {
    * Subagent auto-activation: the moment the current conversation spawns its
    * FIRST direct subagent (a 0 → N transition on the list feed), the "auto
    * open" pref is on, and the Subagent tab type is enabled in settings,
-   * open the panel (if collapsed) and focus the Subagent page
-   * (single-instance: an existing tab is focused, never duplicated).
+   * focus the Subagent page (single-instance: an existing tab is focused,
+   * never duplicated). On wide viewports the right panel also expands; on
+   * narrow viewports background activity never forces the full-screen drawer
+   * open over the chat.
    * Switching to a session that already has subagents never triggers — its
    * baseline starts at the current count — so a deliberate layout is never
    * fought.
@@ -525,9 +532,14 @@ export function Sidebar(props: { ctx: Context; store: SidebarStore }) {
       if (!detectNewDirectSubagent(baseline, ctx.sessions.list.getSnapshot(), sessionId)) return
       if (!store.getPrefs().autoOpenSubagent) return
       if (ctx.get('betterSidebar')?.isTabEnabled('subagent') === false) return
-      store.reduce(s => s.panelOpen ? s : togglePanel(s))
-      // Pin the landing to the first pane: the auto-opened Subagent page
-      // must appear in the panel that just expanded, not wherever the user
+      // Read the viewport when the delayed activation fires: a resize while
+      // the debounce is armed must not let background activity force the
+      // narrow full-screen drawer open over the chat.
+      if (!isNarrowWidth(window.innerWidth)) {
+        store.reduce(s => s.panelOpen ? s : togglePanel(s))
+      }
+      // Pin the landing to the first pane: the auto-activated Subagent page
+      // must be ready in the panel that just expanded, not wherever the user
       // last touched.
       store.reduce(s => ({ ...s, activePane: firstLeaf(s.splits).id }))
       ctx.get('betterSidebar')?.openTab({ type: 'subagent', title: t('subagent') })
@@ -545,11 +557,12 @@ export function Sidebar(props: { ctx: Context; store: SidebarStore }) {
   /**
    * Job auto-activation: the moment a NEW background job appears for the
    * current conversation (a job id the previous snapshot lacked), the
-   * auto-open pref is on, and the Jobs tab type is enabled, open the panel
-   * (if collapsed) and focus the Jobs page. Unlike the subagent trigger
-   * (0 → N only), ANY new job id triggers: the agent may start several
-   * jobs in one session, and each should surface. A fresh page load never
-   * triggers — its baseline starts at the current snapshot.
+   * auto-open pref is on, and the Jobs tab type is enabled, focus the Jobs
+   * page. The right panel expands only on wide viewports — background
+   * activity never forces the narrow full-screen drawer open. Unlike the
+   * subagent trigger (0 → N only), ANY new job id triggers: the agent may
+   * start several jobs in one session, and each should surface. A fresh page
+   * load never triggers — its baseline starts at the current snapshot.
    */
   const jobBaselineRef = useRef<SidebarSessionList | undefined>(undefined)
   useEffect(() => {
@@ -559,7 +572,9 @@ export function Sidebar(props: { ctx: Context; store: SidebarStore }) {
     if (!detectNewJob(prev, sessionList, sessionId)) return
     if (!store.getPrefs().autoOpenJobs) return
     if (ctx.get('betterSidebar')?.isTabEnabled('subagent') === false) return
-    store.reduce(s => s.panelOpen ? s : togglePanel(s))
+    if (!isNarrowWidth(window.innerWidth)) {
+      store.reduce(s => s.panelOpen ? s : togglePanel(s))
+    }
     store.reduce(s => ({ ...s, activePane: firstLeaf(s.splits).id }))
     ctx.get('betterSidebar')?.openTab({ type: 'subagent', title: t('subagent') })
   }, [sessionList, sessionId, store, ctx])
@@ -1128,19 +1143,63 @@ export function Sidebar(props: { ctx: Context; store: SidebarStore }) {
   }, [actions, pinnedVirtualTabs, activePinnedTabId, store])
 
   /**
-   * The explorer's @-reference button: append `@<relative path>` to the
-   * session's composer draft (space-separated). The conversation service is
-   * resolved lazily through `ctx.get` (the inject-free read — the app's own
-   * plugins read 'conversation' the same way); a missing service or scope
-   * degrades to a logged no-op, never a crash. Defined above the no-session
-   * early return — a hook must never sit behind a conditional return
-   * (React counts hooks per render).
+   * The explorer's @-reference button. Directories append the folder mention
+   * (`@dir/`) as plain text so DSH's folder decoration and completion keep
+   * working; files insert a structured chip like the native `@` picker, so
+   * the whole reference stays one link instead of decorating only the
+   * leading folder. Resolves the session-scope ctx and the conversation
+   * input service at click time; a missing service or scope degrades to a
+   * logged no-op, never a crash. Defined above the no-session early return
+   * — a hook must never sit behind a conditional return (React counts hooks
+   * per render).
    */
-  const referenceInChat = useCallback((path: string): void => {
+  const referenceInChat = useCallback((path: string, isDir: boolean): void => {
     if (sessionId === undefined) return
-    appendToDraft(ctx, sessionId, `@${relativeTo(cwd ?? '', path)}`)
+    const rel = relativeTo(cwd ?? '', path)
+    if (isDir) {
+      appendToDraft(ctx, sessionId, `@${rel === '.' ? './' : `${rel}/`}`)
+      return
+    }
+    if (!insertFileReference(ctx, sessionId, rel)) {
+      appendToDraft(ctx, sessionId, `@${rel}`)
+    }
   }, [ctx, sessionId, cwd])
 
+  /** Tree-row rename reconciliation: retarget every open tab whose path was
+   *  the renamed file (the editor content survives and later saves land on
+   *  the new path; the title follows the new base name). */
+  const onPathRenamed = useCallback((oldPath: string, newPath: string): void => {
+    const service = ctx.get('betterSidebar')
+    if (service === undefined) return
+    const snapshot = store.getSnapshot().state
+    if (snapshot === undefined) return
+    for (const leaf of allLeaves(snapshot.splits)) {
+      for (const tab of leaf.tabs) {
+        if (tab.path === oldPath) service.updateTab(tab.id, { path: newPath, title: baseName(newPath) })
+      }
+    }
+    for (const float of snapshot.floats) {
+      if (float.tab.path === oldPath) service.updateTab(float.tab.id, { path: newPath, title: baseName(newPath) })
+    }
+  }, [ctx, store])
+
+  /** Tree-row delete reconciliation: close every open tab at or under the
+   *  removed path (a stale tab's next save would fail against a missing
+   *  path). Floating tabs are as open as docked ones. */
+  const onPathRemoved = useCallback((target: string): void => {
+    const service = ctx.get('betterSidebar')
+    if (service === undefined) return
+    const snapshot = store.getSnapshot().state
+    if (snapshot === undefined) return
+    const tabs: SidebarTab[] = []
+    for (const leaf of allLeaves(snapshot.splits)) tabs.push(...leaf.tabs)
+    for (const float of snapshot.floats) tabs.push(float.tab)
+    for (const tab of tabs) {
+      const path = tab.path
+      if (path !== undefined && (path === target || isWithinWorkspace(target, path))) service.closeTab(tab.id)
+    }
+  }, [ctx, store])
+
   if (state === undefined || sessionId === undefined) {
     // Keep the unavailable controls focusable: touch users have no hover, so
     // focus is the only way the existing Tooltip can explain what is missing.
@@ -1186,6 +1245,15 @@ export function Sidebar(props: { ctx: Context; store: SidebarStore }) {
    * strip must never break because a plugin's badge computation failed.
    */
   const tabBadgeOf = (tab: SidebarTab): ReactNode => {
+    // Agent-terminal wait indicator (sidebar-internal, deliberately NOT a
+    // TabDescriptor.badge — that API is type-keyed and shared with external
+    // plugins, and cannot address one tab): the agent-terminals push mirrors
+    // the model's live terminal_wait_for into state.agentWaits; an agent tab
+    // whose uuid is waiting shows the hourglass pill.
+    if (isAgentTabId(tab.id)) {
+      const wait = state.agentWaits?.[agentUuidOf(tab.id)]
+      if (wait !== undefined) return <span className={css.tabBadge}>{'⏳'}</span>
+    }
     const descriptor = ctx.get('betterSidebar')?.getTab(tab.type)
     if (descriptor?.badge === undefined) return null
     let value: string | number | null | undefined
@@ -1231,6 +1299,8 @@ export function Sidebar(props: { ctx: Context; store: SidebarStore }) {
         revealed={state.revealed ?? []}
         onToggleDir={(path) => { store.reduce(s => toggleExpanded(s, path)) }}
         onReferenceFile={referenceInChat}
+        onPathRenamed={onPathRenamed}
+        onPathRemoved={onPathRemoved}
         ctx={ctx}
         store={store}
         visible={placement === 'float' ? true : state.panelOpen && active}

package/src/client/TerminalView.tsx

@@ -47,6 +47,7 @@ import {
   shouldActivateTerminalLink,
   openTerminalUrl,
 } from './terminal-links.ts'
+import { TerminalWaitBanner } from './TerminalWaitBanner.tsx'
 import css from './sidebar.module.css'
 
 /** How many consecutive unreasoned failures before showing the error banner. */
@@ -60,6 +61,13 @@ const FAILURE_LIMIT = 3
  */
 const PTY_DEPS_MISSING = 'pty-deps-missing'
 
+/**
+ * The WS close-reason prefix the host sends when the CONFIGURED shell was
+ * not found (mirror of src/index.ts wsCloseReasonOf; wire contract, keep the
+ * literal in lockstep). The view renders a localized, actionable banner.
+ */
+const SHELL_NOT_FOUND_PREFIX = 'shell-not-found:'
+
 /** The degraded-mode payload rendered by {@link TerminalDepsBanner}. */
 type TerminalDepsInfo = Extract<TerminalDepsStatus, { ok: false }>
 
@@ -115,6 +123,27 @@ export function TerminalView(props: { scope: SessionScope; tabId: string; store:
   const [fatal, setFatal] = useState<string | null>(null)
   const [depsFatal, setDepsFatal] = useState<TerminalDepsInfo | null>(null)
   const [lastUrl, setLastUrl] = useState<string | null>(null)
+  // Agent terminals only: the model's active terminal_wait_for (mirrored
+  // from the host's agent-terminals push into the store) drives the wait
+  // banner. Read + subscribe like the font prefs above; the banner vanishes
+  // when the host's push drops the waiting field (skip / exit / abort all
+  // converge through the same push). getSnapshot() is {sessionId, state?,
+  // prefs} — the state may be briefly undefined around session switches.
+  const agentUuid = isAgentTabId(tabId) ? agentUuidOf(tabId) : null
+  const [waiting, setWaiting] = useState<{ needle: string; since: number } | undefined>(undefined)
+  useEffect(() => {
+    if (agentUuid === null) return
+    const read = (): void => {
+      const next = store.getSnapshot().state?.agentWaits?.[agentUuid]
+      setWaiting(prev => {
+        const nextValue = next === undefined ? undefined : { needle: next.needle, since: next.since }
+        if (prev?.needle === nextValue?.needle && prev?.since === nextValue?.since) return prev
+        return nextValue
+      })
+    }
+    read()
+    return store.subscribe(read)
+  }, [agentUuid, store])
   const connectRef = useRef<(() => void) | null>(null)
 
   useEffect(() => {
@@ -241,6 +270,12 @@ export function TerminalView(props: { scope: SessionScope; tabId: string; store:
           })
           return
         }
+        // The configured shell could not be found (settings page or yaml):
+        // a localized banner beats the raw English close reason.
+        if (event.code === 1011 && event.reason.startsWith(SHELL_NOT_FOUND_PREFIX)) {
+          setFatal(t('terminalShellNotFound', { name: event.reason.slice(SHELL_NOT_FOUND_PREFIX.length) || '?' }))
+          return
+        }
         // A server-side refusal carries a close code + reason; retrying it
         // forever would only spin the banner, so surface it with a retry.
         if (event.code === 1011 && event.reason !== '') {
@@ -361,6 +396,12 @@ export function TerminalView(props: { scope: SessionScope; tabId: string; store:
 
   return (
     <div className={css.terminalWrap}>
+      {agentUuid !== null && waiting !== undefined && (
+        <TerminalWaitBanner
+          needle={waiting.needle}
+          onSkip={() => { void api.agentSkipWait(agentUuid).catch(() => { /* 跳过失败时 banner 留存，可重试 */ }) }}
+        />
+      )}
       {depsFatal !== null && (
         <TerminalDepsBanner deps={depsFatal} onRetry={() => { setDepsFatal(null); connectRef.current?.() }} />
       )}

package/src/client/TerminalWaitBanner.tsx

@@ -0,0 +1,32 @@
+/**
+ * The "Agent 正在等待 {needle}" wait banner: rendered at the top of an
+ * agent-owned terminal's view while the model blocks in terminal_wait_for.
+ * The skip button asks the host to abort every active wait on the terminal
+ * (`agent-pty.skip-wait`); the banner disappears when the host's next
+ * agent-terminals push drops the waiting field — no optimistic UI. Kept in
+ * its own module (no xterm imports) so jsdom tests can render it directly.
+ */
+import { t } from './locales.ts'
+import css from './sidebar.module.css'
+
+/** Cap the needle shown inline; the full text rides the title tooltip. */
+const NEEDLE_DISPLAY_CAP = 80
+
+/** Truncate one needle for inline display (title attr carries the full text). */
+export function truncateNeedle(needle: string): string {
+  return needle.length > NEEDLE_DISPLAY_CAP ? `${needle.slice(0, NEEDLE_DISPLAY_CAP - 1)}…` : needle
+}
+
+export function TerminalWaitBanner(props: { needle: string; onSkip: () => void }) {
+  const { needle, onSkip } = props
+  return (
+    <div className={css.terminalWaitBanner}>
+      <span className={css.terminalWaitNeedle} title={needle}>
+        {t('terminalWaitBanner', { needle: truncateNeedle(needle) })}
+      </span>
+      <button type="button" className={css.terminalRetry} onClick={onSkip}>
+        {t('terminalSkipWait')}
+      </button>
+    </div>
+  )
+}

package/src/client/TextEditor.tsx

@@ -26,6 +26,7 @@ import { languageForPath } from './lang.ts'
 import { cmSurfaceTheme, CmThemeCompartment } from './cm-themes.ts'
 import { isDarkScheme, subscribeColorScheme } from './theme.ts'
 import { appendToDraft } from './conversation-draft.ts'
+import { useSelectionPopup } from './selection-popup.ts'
 import { buildSelectionInsert } from './selection-payload.ts'
 import { t } from './locales.ts'
 import type { EditorToolbarControls, EditorToolbarState } from './service.ts'
@@ -50,13 +51,6 @@ export interface TextEditorProps {
   onToolbarControls?: (controls: EditorToolbarControls | null) => void
 }
 
-/** The floating "add to conversation" action: payload + viewport anchor. */
-interface SelectionPopup {
-  insert: string
-  left: number
-  top: number
-}
-
 export function TextEditor(props: TextEditorProps) {
   const { ctx, scope, path, content, truncated } = props
   const [dirty, setDirty] = useState(false)
@@ -68,34 +62,21 @@ export function TextEditor(props: TextEditorProps) {
   const themeCompRef = useRef<CmThemeCompartment | null>(null)
   /** The app's resolved color scheme; the editor re-themes in place on flips. */
   const [dark, setDark] = useState(() => isDarkScheme())
-  /** The floating "add to conversation" popup (viewport-anchored; null = hidden). */
-  const [popup, setPopup] = useState<SelectionPopup | null>(null)
-  /** Live mirror of the popup state for click-time reads (no re-render race). */
-  const popupRef = useRef<SelectionPopup | null>(null)
-
-  const hidePopup = (): void => {
-    popupRef.current = null
-    setPopup(null)
-  }
-
-  /** Anchor the popup above the selection center; clamp inside the viewport. */
-  const showPopup = (insert: string, left: number, top: number): void => {
-    const next: SelectionPopup = {
-      insert,
-      left: Math.min(Math.max(left, 80), window.innerWidth - 80),
-      top,
-    }
-    popupRef.current = next
-    setPopup(next)
-  }
-
-  /** The popup button's click: insert the stored payload into the draft. */
-  const commitPopup = (): void => {
-    const current = popupRef.current
-    if (current === null) return
-    appendToDraft(ctx, scope.sessionId, current.insert)
-    hidePopup()
-  }
+  /**
+   * The floating "add to conversation" popup (viewport-anchored; null =
+   * hidden). The hook owns show/hide/commit plus the global dismissal
+   * listeners (outside mousedown, Escape, hidden tab/window, and the editor
+   * surface leaving the viewport — the tab-switch/panel-collapse paths have
+   * no DOM events of their own) — see selection-popup.ts.
+   */
+  const selectionPopup = useSelectionPopup({
+    onCommit: (insert) => { appendToDraft(ctx, scope.sessionId, insert) },
+    // The surface that must stay on screen: the CodeMirror host. This
+    // component has no preview surface (file preview is retired); without
+    // the geometry signal a tab switch (display:none) or a panel collapse
+    // (translated off-screen) would leave the fixed portaled button behind.
+    getSurface: () => hostRef.current,
+  })
 
   useEffect(() => subscribeColorScheme(() => { setDark(isDarkScheme()) }), [])
 
@@ -103,7 +84,7 @@ export function TextEditor(props: TextEditorProps) {
   useEffect(() => {
     setDirty(false)
     setSaveState('idle')
-    hidePopup()
+    selectionPopup.hide()
   }, [content])
 
   // Create the CodeMirror editor once the content is loaded. The view owns
@@ -149,33 +130,33 @@ export function TextEditor(props: TextEditorProps) {
         // selection and hides it too.
         CodeMirrorView.updateListener.of((update) => {
           if (update.geometryChanged || update.viewportChanged) {
-            hidePopup()
+            selectionPopup.hide()
             return
           }
           if (!update.view.hasFocus) {
-            hidePopup()
+            selectionPopup.hide()
             return
           }
           if (!(update.selectionSet || update.docChanged || update.focusChanged)) return
           const sel = update.state.selection.main
           if (sel.empty) {
-            hidePopup()
+            selectionPopup.hide()
             return
           }
           const text = update.state.sliceDoc(sel.from, sel.to)
           if (text.trim() === '') {
-            hidePopup()
+            selectionPopup.hide()
             return
           }
           // Page coordinates (the document root may scroll); the popup is
           // position:fixed, so convert to viewport coordinates.
           const rect = update.view.coordsAtPos(sel.head)
           if (rect === null) {
-            hidePopup()
+            selectionPopup.hide()
             return
           }
           const doc = update.state.doc
-          showPopup(
+          selectionPopup.show(
             buildSelectionInsert(path, scope.cwd, {
               start: doc.lineAt(sel.from).number,
               end: doc.lineAt(sel.to).number,
@@ -272,15 +253,16 @@ export function TextEditor(props: TextEditorProps) {
           <div className={css.editorCm} ref={hostRef} />
         </>
       )}
-      {popup !== null && createPortal(
+      {selectionPopup.popup !== null && createPortal(
         <button
           type="button"
+          ref={selectionPopup.buttonRef}
           className={css.selectionPopup}
-          style={{ left: popup.left, top: popup.top }}
+          style={{ left: selectionPopup.popup.left, top: selectionPopup.popup.top }}
           // Keep the selection (and CodeMirror focus) alive until the click
           // commits — without this the popup unmounts before click lands.
           onMouseDown={(event) => { event.preventDefault() }}
-          onClick={commitPopup}
+          onClick={selectionPopup.commit}
         >
           {t('addToConversation')}
         </button>,

package/src/client/TreePanel.tsx

@@ -59,16 +59,34 @@ export function TreePanel(props: {
   openWithSsh?: boolean
   onOpenWith?: (targetId: string, path: string) => void
   onToggleOpenWithPin?: (targetId: string) => void
-  onReferenceFile: (path: string) => void
+  onReferenceFile: (path: string, isDir: boolean) => void
+  /** Tree-row mutations (passed through to the file tree; absent → hidden). */
+  onPathRenamed?: (oldPath: string, newPath: string) => void
+  onPathRemoved?: (path: string) => void
   /** Full-window presentation: the panel fills its host instead of docking
    *  at a fixed width. */
   full?: boolean
 }) {
-  const { sessionId, cwd, expanded, revealed, onToggle, onOpenFile, onOpenFileNewTab, onOpenFileSide, openWithTargets, openWithPinned, openWithSsh, onOpenWith, onToggleOpenWithPin, onReferenceFile, full } = props
+  const { sessionId, cwd, expanded, revealed, onToggle, onOpenFile, onOpenFileNewTab, onOpenFileSide, openWithTargets, openWithPinned, openWithSsh, onOpenWith, onToggleOpenWithPin, onReferenceFile, onPathRenamed, onPathRemoved, full } = props
   const [query, setQuery] = useState('')
   const [results, setResults] = useState<{ matches: string[]; truncated: boolean } | null>(null)
   const [error, setError] = useState<string | null>(null)
   const [refreshTick, setRefreshTick] = useState(0)
+
+  // The tree caches loaded directories per refresh tick, so content changed
+  // outside DSH (another editor, a sync tool) stays stale until the manual
+  // refresh click. Re-focusing the window bumps the tick automatically, and
+  // integrations can force a refresh by dispatching a bubbling
+  // `dsh-sidebar:refresh-files` event on `window`.
+  useEffect(() => {
+    const bump = (): void => { setRefreshTick(tick => tick + 1) }
+    window.addEventListener('focus', bump)
+    window.addEventListener('dsh-sidebar:refresh-files', bump)
+    return () => {
+      window.removeEventListener('focus', bump)
+      window.removeEventListener('dsh-sidebar:refresh-files', bump)
+    }
+  }, [])
   /** One-line upload status under the search row ('' hides the hint). */
   const [uploadStatus, setUploadStatus] = useState('')
   /** Whether the status line is a failure/cancel (error color, stays visible). */
@@ -233,6 +251,8 @@ export function TreePanel(props: {
           onOpenWith={onOpenWith}
           onToggleOpenWithPin={onToggleOpenWithPin}
           onReferenceFile={onReferenceFile}
+          onPathRenamed={onPathRenamed}
+          onPathRemoved={onPathRemoved}
           refreshTick={refreshTick}
           onUploadRequest={startUpload}
           busy={busy}

package/src/client/api.ts

@@ -212,6 +212,14 @@ export const api = {
     call<FsTextResult | FsBinaryResult>('fs.read', scopePayload(scope, { path }), signal),
   fsWrite: (scope: SessionScope, path: string, content: string) =>
     call<{ ok: true }>('fs.write', scopePayload(scope, { path, content })),
+  /** Rename one tree row within its directory (single-segment name; a
+   *  destination-existence clash is a 409; symlink rows rename the link). */
+  fsRename: (scope: SessionScope, path: string, name: string) =>
+    call<{ path: string }>('fs.rename', scopePayload(scope, { path, name })),
+  /** Delete one tree row permanently (recursive for directories; a symlink
+   *  row unlinks the link only). */
+  fsRemove: (scope: SessionScope, path: string) =>
+    call<{ path: string }>('fs.remove', scopePayload(scope, { path })),
   /** Upload one file's raw bytes into `dir` (keeps the folder tree via
    *  `relativePath`); the host streams it under the session workspace. */
   uploadFile: (scope: SessionScope, dir: string, relativePath: string, body: Blob, signal?: AbortSignal) =>
@@ -241,6 +249,14 @@ export const api = {
   /** Full patch text of one commit (diff display for the history rows). */
   gitCommitDiff: (scope: SessionScope, hash: string, worktree?: string, signal?: AbortSignal) =>
     call<{ diff: string }>('git.commit-diff', gitPayload(scope, worktree, { hash }), signal),
+  /** Both sides' full file contents for a diff-fold expansion; a missing
+   *  side is null (untracked / deleted) and the view degrades the fold. */
+  gitFoldContents: (scope: SessionScope, opts: { path: string; staged?: boolean; hash?: string }, worktree?: string, signal?: AbortSignal) =>
+    call<{ old: string | null; new: string | null }>('git.fold-contents', gitPayload(scope, worktree, {
+      path: opts.path,
+      ...(opts.staged !== undefined ? { staged: opts.staged } : {}),
+      ...(opts.hash !== undefined ? { hash: opts.hash } : {}),
+    }), signal),
   /** Discard the worktree changes of one file (the index is untouched). */
   gitDiscard: (scope: SessionScope, path: string, worktree?: string) =>
     call<{ ok: true }>('git.discard', gitPayload(scope, worktree, { path })),
@@ -258,6 +274,10 @@ export const api = {
   /** Release an agent terminal by uuid (tab closed while WS was down). */
   agentPtyClose: (uuid: string) =>
     call<{ ok: true }>('agent-pty.close', { uuid }),
+  /** Skip every active terminal_wait_for on one agent terminal (the wait
+   *  banner's skip button). Idempotent: {skipped:0} when none is active. */
+  agentSkipWait: (uuid: string) =>
+    call<{ ok: true; skipped: number }>('agent-pty.skip-wait', { uuid }),
   /** Terminal dependency status (issue #140): after a WS close 1011 with
    *  reason `pty-deps-missing` the view fetches the full repair details here
    *  (the close reason itself is capped at 123 bytes). */

package/src/client/chunk-loader.ts

@@ -48,7 +48,7 @@
  * client.js); an edit that does land while a core HMR happens is caught by
  * the ETag comparison on the next activation.
  */
-export type ChunkName = 'terminal' | 'editor'
+export type ChunkName = 'terminal' | 'editor' | 'locale'
 
 /** The module exports a chunk factory provides (namespace-ish record). */
 export type ChunkExports = Record<string, unknown>

package/src/client/chunks/locale.tsx

@@ -0,0 +1,60 @@
+/**
+ * Lazy chunk entry: the 19 non-zh/en dictionaries (ja/de/fr/…/zh-HK/MO/TW —
+ * ~640KB of source). The sidebar's own `t()` only ever consults zh/en plus
+ * the better-locale override store, so these dicts are needed ONLY when
+ * @huanlin/dsh-plugin-better-locale is installed: they register into its
+ * override store from there (see the client apply's better-locale
+ * integration). Built as `lib/client-locale.js` and fetched from the
+ * plugin's /sidebar/bundle route on first need — never import this module
+ * from the core bundle: it would drag every language back into the startup
+ * path.
+ */
+import { ja } from '../locales-ja.ts'
+import { de } from '../locales-de.ts'
+import { fr } from '../locales-fr.ts'
+import { pt } from '../locales-pt.ts'
+import { ko } from '../locales-ko.ts'
+import { ar } from '../locales-ar.ts'
+import { hi } from '../locales-hi.ts'
+import { id } from '../locales-id.ts'
+import { tr } from '../locales-tr.ts'
+import { vi } from '../locales-vi.ts'
+import { th } from '../locales-th.ts'
+import { ru } from '../locales-ru.ts'
+import { it } from '../locales-it.ts'
+import { nl } from '../locales-nl.ts'
+import { sv } from '../locales-sv.ts'
+import { pl } from '../locales-pl.ts'
+import { zhHK } from '../locales-zh-HK.ts'
+import { zhTW } from '../locales-zh-TW.ts'
+import { zhMO } from '../locales-zh-MO.ts'
+import type { CopyKey } from '../locales.ts'
+
+/** Key-set check against zh (type-only import — erased before bundling, so
+ *  this adds no runtime tie to the core bundle): a dictionary missing or
+ *  adding a key fails the build instead of silently falling back to en. */
+const checked = (dict: Record<CopyKey, string>): Record<string, string> => dict
+
+/** Every non-zh/en dictionary keyed by its override id, ready for the
+ *  better-locale store's `register(ns, dicts)`. */
+export const localeDicts: Record<string, Record<string, string>> = {
+  ja: checked(ja),
+  de: checked(de),
+  fr: checked(fr),
+  pt: checked(pt),
+  ko: checked(ko),
+  ar: checked(ar),
+  hi: checked(hi),
+  id: checked(id),
+  tr: checked(tr),
+  vi: checked(vi),
+  th: checked(th),
+  ru: checked(ru),
+  it: checked(it),
+  nl: checked(nl),
+  sv: checked(sv),
+  pl: checked(pl),
+  'zh-HK': checked(zhHK),
+  'zh-TW': checked(zhTW),
+  'zh-MO': checked(zhMO),
+}