ompchamber 3.1.1 → 3.2.0

package/src/client/components/workspace/diff-panel/SplitView.tsx

@@ -6,9 +6,11 @@ import { useSyntaxReady } from '@/client/hooks/ui/syntax-ready';
 interface SplitViewProps {
   rows: SplitDiffRow[];
   language: string;
+  /** Wrap long lines instead of scrolling horizontally. */
+  wordWrap: boolean;
 }
 
-export function SplitView({ rows, language }: SplitViewProps) {
+export function SplitView({ rows, language, wordWrap }: SplitViewProps) {
   const syntaxReady = useSyntaxReady();
 
   const htmlByIndex = useMemo(() => {
@@ -47,7 +49,7 @@ export function SplitView({ rows, language }: SplitViewProps) {
       {/* The room under the last row belongs to the content, not the scroller:
           a scroll container's own bottom padding is not part of its scrollable
           overflow, so the padding has to sit inside it to have any effect. */}
-      <div className="w-max min-w-full min-w-[700px] pb-4">
+      <div className={`pb-4 ${wordWrap ? 'w-full' : 'w-max min-w-full min-w-[700px]'}`}>
         <div className="grid grid-cols-2 sticky top-0 z-10 bg-canvas border-b border-ink/10 text-[11px] text-ink/70 font-sans select-none shadow-xs">
           <div className="px-3 py-1 font-medium border-r border-ink/10 flex items-center justify-between">
             <span>Original (HEAD / Base)</span>
@@ -57,7 +59,23 @@ export function SplitView({ rows, language }: SplitViewProps) {
           </div>
         </div>
 
-        <table className="w-full border-collapse">
+        {/* Wrap needs `table-fixed`: auto layout sizes a column by its widest
+            cell's UNAMBIGUOUS minimum (`overflow-wrap: break-word` does not
+            lower it), so a long line would widen the table and scroll instead of
+            wrapping. Fixed layout takes its widths from the FIRST row — which
+            here is the `colSpan={4}` meta row, so every column came out equal
+            (measured 99px) and the line-number gutters grew to the width of a
+            code column. The colgroup states them instead: two 48px gutters and
+            the two content columns sharing the rest. */}
+        <table className={`border-collapse ${wordWrap ? 'table-fixed w-full' : 'w-full'}`}>
+          {wordWrap && (
+            <colgroup>
+              <col className="w-12" />
+              <col />
+              <col className="w-12" />
+              <col />
+            </colgroup>
+          )}
           <tbody>
             {rows.map((row, idx) => {
               if (row.isMeta) {
@@ -81,6 +99,8 @@ export function SplitView({ rows, language }: SplitViewProps) {
                   {/* Left Line Number */}
                   <td
                     className={`w-12 py-0.5 px-2 text-right text-[10px] select-none border-r border-ink/10 font-mono ${
+                      wordWrap ? 'align-top' : ''
+                    } ${
                       isLeftDel
                         ? 'bg-error/15 text-error font-semibold'
                         : left
@@ -93,7 +113,9 @@ export function SplitView({ rows, language }: SplitViewProps) {
 
                   {/* Left Content (Original) */}
                   <td
-                    className={`min-w-[320px] py-0.5 px-2 whitespace-pre border-r border-ink/10 text-ink ${
+                    className={`py-0.5 px-2 border-r border-ink/10 text-ink ${
+                      wordWrap ? 'whitespace-pre-wrap break-words align-top' : 'min-w-[320px] whitespace-pre'
+                    } ${
                       isLeftDel
                         ? 'bg-error/10'
                         : left
@@ -121,6 +143,8 @@ export function SplitView({ rows, language }: SplitViewProps) {
                   {/* Right Line Number */}
                   <td
                     className={`w-12 py-0.5 px-2 text-right text-[10px] select-none border-r border-ink/10 font-mono ${
+                      wordWrap ? 'align-top' : ''
+                    } ${
                       isRightAdd
                         ? 'bg-success/15 text-success font-semibold'
                         : right
@@ -133,7 +157,9 @@ export function SplitView({ rows, language }: SplitViewProps) {
 
                   {/* Right Content (Modified) */}
                   <td
-                    className={`min-w-[320px] py-0.5 px-2 whitespace-pre text-ink ${
+                    className={`py-0.5 px-2 text-ink ${
+                      wordWrap ? 'whitespace-pre-wrap break-words align-top' : 'min-w-[320px] whitespace-pre'
+                    } ${
                       isRightAdd
                         ? 'bg-success/10'
                         : right

package/src/client/components/workspace/diff-panel/Toolbar.tsx

@@ -1,14 +1,24 @@
-import { AlignJustify, Check, Code2, Columns, Copy, Minus, Plus, RefreshCw, Space, Undo2 } from 'lucide-preact';
+import { AlignJustify, Check, Code2, Columns, Copy, Diff, FileCode, Minus, Plus, RefreshCw, Space, Undo2, WrapText } from 'lucide-preact';
 import { FileIcon } from '@/client/components/common/file-icon';
 import { getGitStatusInfo } from '@/shared/lib/fs/git-status';
 
 export type DiffViewMode = 'unified' | 'split';
 
+/**
+ * How much of the file the diff shows. `full` is the default: the whole file
+ * with the changes marked inside it, which is what a reader wants when the
+ * hunks alone leave the edit without context. `diff` asks git for its own
+ * default context and shows only the changed regions.
+ */
+export type DiffContentMode = 'full' | 'diff';
+
 interface DiffToolbarProps {
   filePath: string;
   status: string;
   isStaged: boolean;
   viewMode: DiffViewMode;
+  contentMode: DiffContentMode;
+  wordWrap: boolean;
   ignoreWhitespace: boolean;
   additions: number;
   deletions: number;
@@ -17,6 +27,8 @@ interface DiffToolbarProps {
   /** A stage/unstage/discard write is in flight; the toolbar locks its actions. */
   isBusy?: boolean;
   onSetViewMode: (mode: DiffViewMode) => void;
+  onSetContentMode: (mode: DiffContentMode) => void;
+  onToggleWordWrap: () => void;
   onToggleWhitespace: () => void;
   onStageUnstage: () => void;
   onDiscard: () => void;
@@ -33,6 +45,8 @@ export function DiffToolbar({
   status,
   isStaged,
   viewMode,
+  contentMode,
+  wordWrap,
   ignoreWhitespace,
   additions,
   deletions,
@@ -40,6 +54,8 @@ export function DiffToolbar({
   isCopied,
   isBusy = false,
   onSetViewMode,
+  onSetContentMode,
+  onToggleWordWrap,
   onToggleWhitespace,
   onStageUnstage,
   onDiscard,
@@ -73,11 +89,15 @@ export function DiffToolbar({
       </div>
 
       {/* Right: Controls & actions. `ml-auto` keeps them right-aligned where the
-          identity block is hidden. This strip scrolls on its own when the panel
-          is too narrow, so no action is ever clipped out of reach. Each segment
-          sets its OWN mode — toggling meant clicking the already-active segment
-          flipped the view to the other one. */}
-      <div className="flex items-center space-x-0.5 @[440px]:space-x-1 text-ink/70 ml-auto min-w-0 overflow-x-auto no-scrollbar">
+          identity block is hidden. This strip WRAPS rather than scrolls: a
+          320px panel cannot hold ten actions in one row, and the previous
+          `overflow-x-auto no-scrollbar` clipped the overflow invisibly —
+          measured 361px of content in a 296px box, with `Stage` entirely
+          outside it and no scrollbar to say so. Wrapping costs one extra row on
+          a narrow panel and keeps every action reachable. Each segment sets its
+          OWN mode — toggling meant clicking the already-active segment flipped
+          the view to the other one. */}
+      <div className="flex flex-wrap items-center justify-end gap-x-0.5 @[440px]:gap-x-1 gap-y-1 text-ink/70 ml-auto">
         {/* Change counts live here, not in the identity block: the editor tab
             carries the file name but never the counts, so this is the one piece
             of the header that must survive a narrow panel. */}
@@ -118,6 +138,57 @@ export function DiffToolbar({
           </button>
         </div>
 
+        {/* Content scope toggle (Full Code vs Diff Only). A separate group from
+            the view-mode toggle because the two are orthogonal: Unified/Split is
+            the shape of the rows, Full/Diff is how many of them there are. Each
+            segment SETS its mode — clicking the active one must not flip the
+            other, which is what a toggle would do. */}
+        <div className="flex items-center bg-canvas rounded border border-ink/15 p-0.5 mr-0.5 @[440px]:mr-1 flex-shrink-0">
+          <button
+            type="button"
+            onClick={() => onSetContentMode('full')}
+            className={`px-2 py-0.5 rounded text-[11px] font-medium flex items-center space-x-1 transition-colors cursor-pointer flex-shrink-0 ${
+              contentMode === 'full' ? 'bg-paper text-ink shadow-xs' : 'text-ink/60 hover:text-ink'
+            }`}
+            title="Full code (whole file, changes marked)"
+            aria-label="Full code (whole file, changes marked)"
+            aria-pressed={contentMode === 'full'}
+          >
+            <FileCode size={12} />
+            <span className="hidden @[420px]:inline">Full Code</span>
+          </button>
+          <button
+            type="button"
+            onClick={() => onSetContentMode('diff')}
+            className={`px-2 py-0.5 rounded text-[11px] font-medium flex items-center space-x-1 transition-colors cursor-pointer flex-shrink-0 ${
+              contentMode === 'diff' ? 'bg-paper text-ink shadow-xs' : 'text-ink/60 hover:text-ink'
+            }`}
+            title="Diff only (changed hunks)"
+            aria-label="Diff only (changed hunks)"
+            aria-pressed={contentMode === 'diff'}
+          >
+            <Diff size={12} />
+            <span className="hidden @[420px]:inline">Diff Only</span>
+          </button>
+        </div>
+
+        {/* Word wrap. On by default: a diff of a minified file or a long line
+            is unreadable when it runs off the panel, and horizontal scrolling
+            hides the change the reader opened the diff to see. Off keeps one
+            line = one row, which is what a column-aligned comparison needs. */}
+        <button
+          type="button"
+          onClick={onToggleWordWrap}
+          className={`p-1.5 rounded transition-colors cursor-pointer flex-shrink-0 ${
+            wordWrap ? 'bg-ink/10 text-ink' : 'text-ink/50 hover:text-ink hover:bg-ink/5'
+          }`}
+          title={wordWrap ? 'Word wrap on' : 'Word wrap off'}
+          aria-label={wordWrap ? 'Word wrap on' : 'Word wrap off'}
+          aria-pressed={wordWrap}
+        >
+          <WrapText size={13} />
+        </button>
+
         {/* Ignore whitespace toggle */}
         <button
           type="button"

package/src/client/components/workspace/diff-panel/UnifiedView.tsx

@@ -6,9 +6,11 @@ import { useSyntaxReady } from '@/client/hooks/ui/syntax-ready';
 interface UnifiedViewProps {
   lines: DiffLine[];
   language: string;
+  /** Wrap long lines instead of scrolling horizontally. */
+  wordWrap: boolean;
 }
 
-export function UnifiedView({ lines, language }: UnifiedViewProps) {
+export function UnifiedView({ lines, language, wordWrap }: UnifiedViewProps) {
   const syntaxReady = useSyntaxReady();
 
   const htmlByIndex = useMemo(() => {
@@ -41,8 +43,13 @@ export function UnifiedView({ lines, language }: UnifiedViewProps) {
       {/* The room under the last row belongs to the content, not the scroller:
           a scroll container's own bottom padding is not part of its scrollable
           overflow, so the padding has to sit inside it to have any effect. */}
-      <div className="pb-4">
-        <table className="w-max min-w-full border-collapse">
+      <div className={`pb-4 ${wordWrap ? 'w-full' : 'w-max min-w-full'}`}>
+        {/* Wrap needs `table-fixed`: auto layout sizes a column by its widest
+            cell's UNAMBIGUOUS minimum (`overflow-wrap: break-word` does not
+            lower it), so a long line would still widen the table and scroll
+            instead of wrapping. Fixed layout takes the width from the row's
+            own box, which is what makes the cell's wrap rule effective. */}
+        <table className={`border-collapse ${wordWrap ? 'table-fixed w-full' : 'w-max min-w-full'}`}>
           <tbody>
             {lines.map((line, idx) => {
               if (line.type === 'meta') {
@@ -69,9 +76,13 @@ export function UnifiedView({ lines, language }: UnifiedViewProps) {
                       : 'hover:bg-ink/[0.03]'
                   }`}
                 >
-                  {/* Old line number */}
+                  {/* Old line number. Top-aligned when the row wraps, or the
+                      number would float to the middle of a multi-line cell
+                      instead of naming its first line. */}
                   <td
                     className={`w-12 py-0.5 px-2 text-right text-[10px] select-none border-r border-ink/10 font-mono ${
+                      wordWrap ? 'align-top' : ''
+                    } ${
                       isDel
                         ? 'bg-error/15 text-error font-semibold'
                         : isAdd
@@ -85,6 +96,8 @@ export function UnifiedView({ lines, language }: UnifiedViewProps) {
                   {/* New line number */}
                   <td
                     className={`w-12 py-0.5 px-2 text-right text-[10px] select-none border-r border-ink/10 font-mono ${
+                      wordWrap ? 'align-top' : ''
+                    } ${
                       isAdd
                         ? 'bg-success/15 text-success font-semibold'
                         : isDel
@@ -96,7 +109,7 @@ export function UnifiedView({ lines, language }: UnifiedViewProps) {
                   </td>
 
                   {/* Change prefix & code text */}
-                  <td className="py-0.5 px-3 whitespace-pre text-ink pr-6">
+                  <td className={`py-0.5 px-3 text-ink pr-6 ${wordWrap ? 'whitespace-pre-wrap break-words align-top' : 'whitespace-pre'}`}>
                     <span
                       className={`inline-block w-4 text-center select-none font-bold ${
                         isAdd ? 'text-success' : isDel ? 'text-error' : 'opacity-0'

package/src/client/components/workspace/diff-panel/index.tsx

@@ -1,8 +1,8 @@
-import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'preact/hooks';
 import { useSessionUiState } from '@/client/hooks/workspace/session-state';
 import { parseUnifiedDiff } from '@/shared/lib/fs/diff-parser';
-import { getLanguageFromPath } from '@/shared/lib/code/syntax-highlight';
-import { DiffToolbar, type DiffViewMode } from '@/client/components/workspace/diff-panel/Toolbar';
+import { getLanguageFromPath } from '@/shared/lib/code/language';
+import { DiffToolbar, type DiffContentMode, type DiffViewMode } from '@/client/components/workspace/diff-panel/Toolbar';
 import { UnifiedView } from '@/client/components/workspace/diff-panel/UnifiedView';
 import { SplitView } from '@/client/components/workspace/diff-panel/SplitView';
 import { AlertCircle, RefreshCw } from 'lucide-preact';
@@ -30,6 +30,8 @@ export function DiffPanel({
 }: DiffPanelProps) {
   // Read and persist view mode & whitespace preference in session_ui_state
   const [viewMode, setViewMode] = useSessionUiState<DiffViewMode>('diff.viewMode', 'unified');
+  const [contentMode, setContentMode] = useSessionUiState<DiffContentMode>('diff.contentMode', 'full');
+  const [wordWrap, setWordWrap] = useSessionUiState<boolean>('diff.wordWrap', true);
   const [ignoreWhitespace, setIgnoreWhitespace] = useSessionUiState<boolean>('diff.ignoreWhitespace', false);
 
   const [rawDiff, setRawDiff] = useState<string>('');
@@ -66,6 +68,11 @@ export function DiffPanel({
         staged: staged ? '1' : '0',
         repo: repo || '.',
       });
+      // `fullContext=1` makes git emit the whole file rather than the hunks.
+      // Only the user's own toggle changes it, so it is safe as a callback
+      // dependency (unlike the staged/status copies above, which the action
+      // path updates while a fetch of its own is already in flight).
+      if (contentMode === 'full') params.set('fullContext', '1');
       if (statusForFetch) params.set('status', statusForFetch);
       if (root) params.set('root', root);
 
@@ -99,7 +106,7 @@ export function DiffPanel({
     } finally {
       if (seq === fetchSeqRef.current) setIsLoading(false);
     }
-  }, [filePath, repo, root]);
+  }, [filePath, repo, root, contentMode]);
 
   useEffect(() => {
     setCurrentStatus(status);
@@ -112,13 +119,31 @@ export function DiffPanel({
     void fetchDiff();
   }, [fetchDiff]);
 
-  const parsed = parseUnifiedDiff(rawDiff, ignoreWhitespace);
+  // Full-code mode parses the whole file, not the hunks, so the parse is keyed
+  // to its inputs: every render used to re-walk the diff (measured 21 ms on an
+  // 80k-line file), for a result that only changes when the diff or the
+  // whitespace toggle does.
+  // Only the rendered view is built: `views` keeps the shared flush (so the
+  // whitespace decision and the counts cannot diverge) while skipping the
+  // object graph nobody draws.
+  const parsed = useMemo(
+    () => parseUnifiedDiff(rawDiff, { ignoreWhitespace, views: viewMode === 'split' ? 'split' : 'unified' }),
+    [rawDiff, ignoreWhitespace, viewMode],
+  );
   const language = getLanguageFromPath(filePath);
 
   const handleSetViewMode = (mode: DiffViewMode) => {
     setViewMode(mode);
   };
 
+  const handleSetContentMode = (mode: DiffContentMode) => {
+    setContentMode(mode);
+  };
+
+  const handleToggleWordWrap = () => {
+    setWordWrap(!wordWrap);
+  };
+
   const handleToggleWhitespace = () => {
     setIgnoreWhitespace(!ignoreWhitespace);
   };
@@ -218,6 +243,8 @@ export function DiffPanel({
         status={currentStatus}
         isStaged={currentStaged}
         viewMode={viewMode}
+        contentMode={contentMode}
+        wordWrap={wordWrap}
         ignoreWhitespace={ignoreWhitespace}
         additions={parsed.additions}
         deletions={parsed.deletions}
@@ -225,6 +252,8 @@ export function DiffPanel({
         isCopied={isCopied}
         isBusy={isBusy}
         onSetViewMode={handleSetViewMode}
+        onSetContentMode={handleSetContentMode}
+        onToggleWordWrap={handleToggleWordWrap}
         onToggleWhitespace={handleToggleWhitespace}
         onStageUnstage={handleStageUnstage}
         onDiscard={handleDiscard}
@@ -268,9 +297,9 @@ export function DiffPanel({
             </button>
           </div>
         ) : viewMode === 'split' ? (
-          <SplitView rows={parsed.splitRows} language={language} />
+          <SplitView rows={parsed.splitRows} language={language} wordWrap={wordWrap} />
         ) : (
-          <UnifiedView lines={parsed.lines} language={language} />
+          <UnifiedView lines={parsed.lines} language={language} wordWrap={wordWrap} />
         )}
       </div>
 

package/src/client/components/workspace/editor/Toolbar.tsx

@@ -68,14 +68,21 @@ export function EditorToolbar({
           : 'Save file (Ctrl+S)';
 
   return (
-    <div className="flex items-center justify-between px-3 py-2 border-b border-ink/10 bg-paper flex-shrink-0">
+    // `@container`: the path below hides on a NARROW PANEL, not a narrow
+    // viewport. At the editor panel's 320px floor the action strip is 273px of
+    // `flex-shrink-0`, which left the path a measured 23px — a truncated
+    // fragment of a filename is not information, and the tab above already
+    // carries it.
+    <div className="@container flex items-center justify-between px-3 py-2 border-b border-ink/10 bg-paper flex-shrink-0">
       {/* Left status */}
-      <div className="flex items-center space-x-2 text-xs font-mono text-ink/40 min-w-0">
+      <div className="hidden @[420px]:flex items-center space-x-2 text-xs font-mono text-ink/40 min-w-0">
         <span className="truncate max-w-[300px]" title={path}>{path}</span>
       </div>
 
-      {/* Right actions */}
-      <div className="flex items-center space-x-1 text-ink/40 flex-shrink-0">
+      {/* Right actions. `ml-auto` keeps them right-aligned once the path block
+          above is hidden, which `justify-between` alone would not do (a single
+          child sits at the start). */}
+      <div className="flex items-center space-x-1 text-ink/40 flex-shrink-0 ml-auto">
         {!isImage && (
           <div className="flex items-center pr-2 mr-1 border-r border-ink/10">
             <button

package/src/client/components/workspace/git-panel/commit-modal/CommitDiffViewer.tsx

@@ -1,6 +1,7 @@
 import { useMemo, useState } from 'preact/hooks';
 import { ChevronDown, ChevronUp } from 'lucide-preact';
-import { getLanguageFromPath, highlightLines } from '@/shared/lib/code/syntax-highlight';
+import { getLanguageFromPath } from '@/shared/lib/code/language';
+import { highlightLines } from '@/shared/lib/code/syntax-highlight';
 import { useSyntaxReady } from '@/client/hooks/ui/syntax-ready';
 
 interface DiffLineItem {

package/src/client/hooks/chat/omp/session-list.tsx

@@ -32,6 +32,16 @@ export interface SidebarDataHandle {
   initializing: boolean;
   /** Fire a refresh (dedup: while a load is in flight this is a no-op). */
   refresh: () => void;
+  /**
+   * User-initiated refresh: the same load as `refresh`, but it also raises
+   * `refreshing` until THAT load settles, so a toolbar button can spin while
+   * it runs. The background paths (idle poll, stream events, status ack) go
+   * through `refresh` and deliberately never raise the flag — a spinner that
+   * turns on by itself every 30s reads as a broken list.
+   */
+  refreshNow: () => void;
+  /** True while a `refreshNow` load is in flight. */
+  refreshing: boolean;
   /**
    * Mark a session's one-shot terminal badge as seen NOW: strips the check
    * optimistically for this mount and POSTs the server ack. No-op unless the
@@ -74,6 +84,22 @@ export function SidebarDataProvider({ children, initialFolders = [] }: { childre
     };
   }, [fetcher]);
 
+  // User-initiated refresh. Unlike `refresh` it does NOT skip an in-flight
+  // load — a click is an explicit "read it again now", and the fetcher aborts
+  // the superseded request rather than letting two answer. The spinner follows
+  // THIS load only: a token marks the newest click, so a background poll
+  // settling in between cannot stop a spin that is still running, and a
+  // superseded click cannot stop the newer one's.
+  const [refreshing, setRefreshing] = useState(false);
+  const refreshTokenRef = useRef(0);
+  const refreshNow = useCallback(() => {
+    const token = ++refreshTokenRef.current;
+    setRefreshing(true);
+    void fetcher.load('/api/sessions/list').finally(() => {
+      if (refreshTokenRef.current === token) setRefreshing(false);
+    });
+  }, [fetcher]);
+
   // Idle keep-alive: the throttled stream-event hook and useStreamPoll only
   // fire while THIS client streams, so changes made elsewhere (another tab,
   // a background omp process finishing, an archive from a second browser)
@@ -142,10 +168,12 @@ export function SidebarDataProvider({ children, initialFolders = [] }: { childre
       isMock: data?.isMock ?? false,
       initializing: !hasLoaded,
       refresh,
+      refreshNow,
+      refreshing,
       markSeen,
       hasSeen: (id) => seen.has(String(id)),
     };
-  }, [fetcher.data, initialFolders, hasLoaded, refresh, markSeen]);
+  }, [fetcher.data, initialFolders, hasLoaded, refresh, refreshNow, refreshing, markSeen]);
 
   return <SidebarDataContext.Provider value={value}>{children}</SidebarDataContext.Provider>;
 }
@@ -163,6 +191,8 @@ export function useSidebarData(): SidebarDataHandle {
     isMock: false,
     initializing: true,
     refresh: () => {},
+    refreshNow: () => {},
+    refreshing: false,
     markSeen: () => {},
     hasSeen: () => false,
   };

package/src/client/hooks/chat/omp/session-sidebar-controller.ts

@@ -51,6 +51,10 @@ export interface SessionSidebarController {
   folders: WorkspaceFolderData[];
   initializing: boolean;
   refresh: () => void;
+  /** User-initiated refresh — raises `refreshing` until that load settles. */
+  refreshNow: () => void;
+  /** True while a `refreshNow` load is in flight (drives the toolbar spinner). */
+  refreshing: boolean;
   activeSessionId: number | string | null;
   sessionParam: string | null;
   searchQuery: string;
@@ -71,7 +75,7 @@ export function useSessionSidebarController(
   options: SessionSidebarControllerOptions = {},
 ): SessionSidebarController {
   const { includePendingSessions = false, onSelectSession, onAfterSelect } = options;
-  const { folders, initializing, refresh, markSeen, hasSeen } = useSidebarData();
+  const { folders, initializing, refresh, refreshNow, refreshing, markSeen, hasSeen } = useSidebarData();
   const [searchParams, setSearchParams] = useSearchParams();
   const sessionParam = searchParams.get('sessionId');
   const activeSessionId = sessionParam
@@ -232,6 +236,8 @@ export function useSessionSidebarController(
     folders,
     initializing,
     refresh: revalidate,
+    refreshNow,
+    refreshing,
     activeSessionId,
     sessionParam,
     searchQuery,

package/src/client/hooks/chat/subagent/index.ts

@@ -2,7 +2,7 @@
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
 import type { ChatMessageData, SubagentInfo } from '@/shared/types';
 import { isRecord } from '@/shared/lib/util/guards';
-import { parseSubagentLifecycle, parseSubagentProgress } from '@/shared/lib/omp/subagent/parse';
+import { parseSubagentLifecycle, readSubagentProgressFrame } from '@/shared/lib/omp/subagent/parse';
 import { convertMessages, mergeMessages, requestHistoryPage, requestSubagentPage } from '@/shared/lib/omp/subagent/transcript-client';
 
 /**
@@ -86,6 +86,9 @@ export function useSubagentTranscript(
   const nextByteRef = useRef(0);
   const sessionFileRef = useRef<string | undefined>(undefined);
   const readyRef = useRef(false);
+  /** False once the live RPC has refused this subagent (its process is gone).
+   *  Later tail fetches then read the on-disk transcript directly. */
+  const rpcAvailableRef = useRef(true);
   const flushingRef = useRef(false);
   const queuedRef = useRef(false);
   const flushTimerRef = useRef<number | null>(null);
@@ -103,8 +106,25 @@ export function useSubagentTranscript(
     flushingRef.current = true;
     const generation = generationRef.current;
     try {
-      const page = await requestSubagentPage(sid, active.id, sessionFileRef.current, nextByteRef.current);
-      if (generation !== generationRef.current || !page) return;
+      const fromByte = nextByteRef.current;
+      // Once the RPC has answered "not managed", stop probing it: the child is
+      // gone for the rest of this view's life, and every later tail would pay a
+      // refused round-trip before falling back anyway. The disk path below is
+      // the same transcript file the RPC was reading.
+      let page = rpcAvailableRef.current
+        ? await requestSubagentPage(sid, active.id, sessionFileRef.current, fromByte)
+        : null;
+      if (generation !== generationRef.current) return;
+      if (!page) {
+        // The session's omp process is gone (the child finished, the idle
+        // reclaim took it, or the chamber restarted) — the RPC is refused for
+        // an unmanaged session rather than respawning one for a read. Continue
+        // on disk; without this the view froze on whatever the last live page
+        // held, which is exactly the final turns of a just-finished subagent.
+        rpcAvailableRef.current = false;
+        page = await requestHistoryPage(sid, active.id, fromByte);
+        if (generation !== generationRef.current || !page) return;
+      }
       sessionFileRef.current = page.sessionFile || sessionFileRef.current;
       const converted = convertMessages(page.messages, true);
       if (page.reset) {
@@ -163,6 +183,7 @@ export function useSubagentTranscript(
     nextByteRef.current = 0;
     sessionFileRef.current = initial?.sessionFile;
     readyRef.current = false;
+    rpcAvailableRef.current = true;
 
     const scheduleTail = () => {
       if (flushTimerRef.current !== null) return;
@@ -188,8 +209,10 @@ export function useSubagentTranscript(
         if (!isCurrent()) return;
         if (!result && !viaHistory && fromByte === 0) {
           // The parent RPC dropped this subagent (already finished) — the
-          // on-disk transcript is authoritative from here on.
+          // on-disk transcript is authoritative from here on, and the tail
+          // fetch must not keep probing a refused RPC.
           viaHistory = true;
+          rpcAvailableRef.current = false;
           result = await requestHistoryPage(sessionId, subagentId, 0);
           if (!isCurrent()) return;
         }
@@ -236,15 +259,18 @@ export function useSubagentTranscript(
       if (!detail) return;
       const payload = isRecord(detail.payload) ? detail.payload : null;
       if (!payload) return;
-      const payloadId = typeof payload.id === 'string' ? payload.id : null;
-      if (payloadId && payloadId !== subagentId) return;
-      if (!payloadId) {
-        const payloadIndex = typeof payload.index === 'number' ? payload.index : null;
+      // `subagent_progress` nests the child's AgentProgress under `progress`
+      // (SubagentProgressPayload), and only the NESTED snapshot carries the id
+      // plus the resolved model/thinking level — reading the wrapper alone
+      // dropped every field it reports.
+      const progress = readSubagentProgressFrame(payload);
+      if (!progress) return;
+      if (progress.id !== undefined) {
+        if (progress.id !== subagentId) return;
+      } else {
         // Index is only unique within a spawning batch — require the exact match.
-        if (payloadIndex === null || payloadIndex !== (subagentRef.current?.index ?? -1)) return;
+        if (progress.index === undefined || progress.index !== (subagentRef.current?.index ?? -1)) return;
       }
-      const progress = parseSubagentProgress(payload);
-      if (!progress) return;
       setStatus(prev => {
         if (!prev || prev.id !== subagentId) return prev;
         const next: SubagentInfo = { ...prev, progress: { ...prev.progress, ...progress } };

package/src/client/hooks/editor/use-file-editor.ts

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
-import { getLanguageFromPath } from '@/shared/lib/code/syntax-highlight';
+import { getLanguageFromPath } from '@/shared/lib/code/language';
 import { getImageMimeType } from '@/shared/lib/fs/file-kind';
 import { buildFsRawUrl } from '@/shared/lib/fs/paths';
 import { detectLineEnding, toDiskText, toLf, type LineEnding } from '@/shared/lib/code/line-endings';

package/src/client/hooks/settings/master-detail.ts

@@ -0,0 +1,33 @@
+import { useCallback, useState } from 'preact/hooks';
+
+/** Which of a two-pane settings category's screens a phone is showing. */
+export type SettingsPane = 'list' | 'detail';
+
+export interface SettingsMasterDetailHandle {
+  pane: SettingsPane;
+  /** Called by the category's own row handler, never derived from selection. */
+  openDetail: () => void;
+  back: () => void;
+}
+
+/**
+ * Pane state for the settings categories that are two panes on a desktop.
+ *
+ * A phone has no room for a 224px list beside a detail pane: measured on a
+ * 412x915 Android viewport, the detail was left 186px wide, and the categories
+ * whose container stacked gave it 48px of height. Below `md` the two panes are
+ * therefore two screens, and this is which one is up.
+ *
+ * The pane is opened by an EXPLICIT row choice, never by a selection that
+ * merely exists: `useCrudList` selects its first row on load and the provider
+ * list falls back to `connectedProviders[0]`, so deriving the pane from
+ * `selectedId` would drop the user into a detail pane they never asked for and
+ * hide the list they came to browse. Desktop ignores this state entirely —
+ * `md:` shows both panes.
+ */
+export function useSettingsMasterDetail(): SettingsMasterDetailHandle {
+  const [pane, setPane] = useState<SettingsPane>('list');
+  const openDetail = useCallback(() => setPane('detail'), []);
+  const back = useCallback(() => setPane('list'), []);
+  return { pane, openDetail, back };
+}