@stigmer/react 3.1.1 → 3.1.3

package/src/workspace/useWorkspaceContentSearch.ts

@@ -0,0 +1,228 @@
+"use client";
+
+import { useEffect, useMemo, useRef, useState } from "react";
+import { toError } from "../internal/toError.js";
+import type { WorkspaceEntry } from "./useWorkspaceEntries.js";
+import type {
+  WorkspaceContentMatch,
+  WorkspaceContentSearcher,
+} from "./WorkspaceContentSearcher.js";
+
+/** Default debounce for content-search query changes — matches `useResourceSearch`. */
+const DEFAULT_DEBOUNCE_MS = 300;
+
+/**
+ * Minimum query length before a disk search fires. Content search hits the
+ * filesystem on every query (unlike the cached filename search), so a
+ * single-character query would scan the whole tree for a near-useless result.
+ * Two characters is a gentle, documented floor — not an arbitrary limit.
+ */
+const DEFAULT_MIN_LENGTH = 2;
+
+/** Options for {@link useWorkspaceContentSearch}. */
+export interface UseWorkspaceContentSearchOptions {
+  /** All workspace entries to search across. */
+  readonly entries: readonly WorkspaceEntry[];
+  /** Platform-injected content searcher. `undefined` → content search is unavailable. */
+  readonly searcher: WorkspaceContentSearcher | undefined;
+  /** Current search query. Trimmed; below {@link minLength} yields no search. */
+  readonly query: string;
+  /** Debounce delay for query changes in milliseconds. @default 300 */
+  readonly debounceMs?: number;
+  /** Minimum trimmed query length before a search runs. @default 2 */
+  readonly minLength?: number;
+}
+
+/** Content-search hits (and per-entry status) for one workspace entry. */
+export interface WorkspaceContentSearchGroup {
+  /** The workspace entry these matches belong to. */
+  readonly entry: WorkspaceEntry;
+  /** Line-level matches within this entry, backend-ordered (path, then line). */
+  readonly matches: readonly WorkspaceContentMatch[];
+  /** `true` when this entry's search was capped (more matches exist than shown). */
+  readonly truncated: boolean;
+  /** Search error for this entry, if any (isolated — other entries still resolve). */
+  readonly error: Error | null;
+}
+
+/** Return value of {@link useWorkspaceContentSearch}. */
+export interface UseWorkspaceContentSearchReturn {
+  /** Entries with something to show (matches, an error, or a truncation notice). */
+  readonly groups: readonly WorkspaceContentSearchGroup[];
+  /** Total matches across all groups (for a "showing N of M" affordance). */
+  readonly totalMatches: number;
+  /** `true` during the first search of a query with no prior results to show. */
+  readonly isLoading: boolean;
+  /** `true` while a new query loads *over* previously-shown results (no blank flash). */
+  readonly isRefetching: boolean;
+  /** `true` when no substrate can be searched (no searcher, or every entry unsupported). */
+  readonly isUnsupported: boolean;
+  /** First per-entry error, for a top-level fallback message. `null` when none. */
+  readonly error: Error | null;
+}
+
+/** Settled per-entry result held between query changes (never a "loading" state). */
+type EntryResult =
+  | { readonly status: "ready"; readonly matches: readonly WorkspaceContentMatch[]; readonly truncated: boolean }
+  | { readonly status: "error"; readonly error: Error }
+  | { readonly status: "unsupported" };
+
+const EMPTY_GROUPS: readonly WorkspaceContentSearchGroup[] = [];
+
+/**
+ * Behavior hook powering workspace-wide content (text) search.
+ *
+ * The text-grep sibling of
+ * {@link useWorkspaceFileSearch}: it keeps
+ * that hook's per-entry aggregation, error isolation, and generation guard, and
+ * adds the platform's canonical debounce idiom from `useResourceSearch`
+ * (`query`/`debouncedQuery` + `setTimeout`). The key difference is that the
+ * debounced query is part of the *fetch* — each keystroke hits disk via the
+ * injected {@link WorkspaceContentSearcher}, uncached — so a `minLength` guard
+ * and a debounce protect the filesystem.
+ *
+ * Prior results stay visible while a new debounced query loads (`isRefetching`
+ * true, results unchanged); only the very first search with nothing to show
+ * flips `isLoading`. This avoids a per-keystroke blank flash the cached filename
+ * search never had.
+ *
+ * @example
+ * ```tsx
+ * const { groups, totalMatches, isRefetching } = useWorkspaceContentSearch({
+ *   entries: workspace.entries,
+ *   searcher: workspaceContentSearcher,
+ *   query,
+ * });
+ * ```
+ */
+export function useWorkspaceContentSearch({
+  entries,
+  searcher,
+  query,
+  debounceMs = DEFAULT_DEBOUNCE_MS,
+  minLength = DEFAULT_MIN_LENGTH,
+}: UseWorkspaceContentSearchOptions): UseWorkspaceContentSearchReturn {
+  // Settled results per entry, keyed by entry id. Retained across query changes
+  // and only swapped wholesale when a new generation fully resolves — so a
+  // reload never blanks what the user is already reading.
+  const [results, setResults] = useState<Record<string, EntryResult>>({});
+  const [pending, setPending] = useState(false);
+
+  // Debounce the query into the fetch key (the `useResourceSearch` idiom).
+  const [debouncedQuery, setDebouncedQuery] = useState(query);
+  useEffect(() => {
+    const timer = setTimeout(() => setDebouncedQuery(query), debounceMs);
+    return () => clearTimeout(timer);
+  }, [query, debounceMs]);
+
+  // Latest entries read inside the effect without widening its dependency to the
+  // (possibly per-render) array identity — the effect keys on the id set instead.
+  const entriesRef = useRef(entries);
+  entriesRef.current = entries;
+  const entriesKey = entries.map((entry) => entry.id).join("\u0000");
+
+  // Ignore resolutions from a superseded run (id set, searcher, or query changed).
+  const generationRef = useRef(0);
+
+  const effectiveQuery = debouncedQuery.trim();
+  const belowMinLength = effectiveQuery.length < minLength;
+
+  useEffect(() => {
+    // No searcher or a too-short query: clear results, nothing in flight. (An
+    // in-flight generation is abandoned via the bumped ref.)
+    if (!searcher || belowMinLength) {
+      generationRef.current += 1;
+      setResults({});
+      setPending(false);
+      return;
+    }
+
+    const currentEntries = entriesRef.current;
+    const generation = ++generationRef.current;
+    setPending(true);
+
+    Promise.all(
+      currentEntries.map(async (entry): Promise<[string, EntryResult]> => {
+        try {
+          const result = await searcher(entry, effectiveQuery);
+          if (result === null) return [entry.id, { status: "unsupported" }];
+          return [
+            entry.id,
+            { status: "ready", matches: result.matches, truncated: result.truncated },
+          ];
+        } catch (err) {
+          return [entry.id, { status: "error", error: toError(err) }];
+        }
+      }),
+    ).then((settled) => {
+      // A newer generation started while this batch was in flight — drop it so
+      // stale results never overwrite fresher ones (or clobber a cleared state).
+      if (generationRef.current !== generation) return;
+      const next: Record<string, EntryResult> = {};
+      for (const [id, res] of settled) next[id] = res;
+      setResults(next);
+      setPending(false);
+    });
+  }, [entriesKey, searcher, effectiveQuery, belowMinLength]);
+
+  return useMemo<UseWorkspaceContentSearchReturn>(() => {
+    if (!searcher) {
+      return {
+        groups: EMPTY_GROUPS,
+        totalMatches: 0,
+        isLoading: false,
+        isRefetching: false,
+        isUnsupported: true,
+        error: null,
+      };
+    }
+
+    const groups: WorkspaceContentSearchGroup[] = [];
+    let totalMatches = 0;
+    let firstError: Error | null = null;
+    let unsupportedCount = 0;
+    let settledCount = 0;
+
+    for (const entry of entries) {
+      const state = results[entry.id];
+      if (!state) continue;
+      settledCount += 1;
+
+      if (state.status === "unsupported") {
+        unsupportedCount += 1;
+        continue;
+      }
+      if (state.status === "error") {
+        if (!firstError) firstError = state.error;
+        groups.push({ entry, matches: [], truncated: false, error: state.error });
+        continue;
+      }
+
+      totalMatches += state.matches.length;
+      // Worth showing only when it carries matches or a truncation notice.
+      if (state.matches.length > 0 || state.truncated) {
+        groups.push({
+          entry,
+          matches: state.matches,
+          truncated: state.truncated,
+          error: null,
+        });
+      }
+    }
+
+    const hasPriorResults = settledCount > 0;
+    const isUnsupported =
+      entries.length > 0 && unsupportedCount === entries.length;
+
+    return {
+      groups,
+      totalMatches,
+      // First search (nothing settled yet) blanks; a reload over existing
+      // results keeps them visible and signals `isRefetching` instead.
+      isLoading: pending && !hasPriorResults,
+      isRefetching: pending && hasPriorResults,
+      isUnsupported,
+      error: firstError,
+    };
+  }, [entries, results, pending, searcher]);
+}

package/src/workspace/useWorkspaceFileContent.ts

@@ -0,0 +1,129 @@
+"use client";
+
+import { useMemo } from "react";
+import { useFetch } from "../internal/useFetch.js";
+import type { WorkspaceEntry } from "./useWorkspaceEntries.js";
+import type {
+  WorkspaceFileContent,
+  WorkspaceFileReader,
+} from "./WorkspaceFileReader.js";
+
+/** Options for {@link useWorkspaceFileContent}. */
+export interface UseWorkspaceFileContentOptions {
+  /** The workspace entry that owns the file, or `null` when nothing is open. */
+  readonly entry: WorkspaceEntry | null;
+  /** Repo-relative (git) or root-relative (local) path, or `null` when nothing is open. */
+  readonly path: string | null;
+  /**
+   * Platform-injected content reader. `undefined` when the host app injects
+   * no reader at all (e.g. web with no GitHub token) — surfaced as
+   * {@link UseWorkspaceFileContentReturn.isUnsupported}, not an error.
+   */
+  readonly reader: WorkspaceFileReader | undefined;
+}
+
+/** Return value of {@link useWorkspaceFileContent}. */
+export interface UseWorkspaceFileContentReturn {
+  /**
+   * The decoded file content (+ metadata), or `null` while the request is
+   * in-flight, skipped, failed, or the substrate is unsupported. A present
+   * object with `text === null` is a real file that is binary, too large, or
+   * undecodable — distinct from `isUnsupported`.
+   */
+  readonly content: WorkspaceFileContent | null;
+  /** `true` only on the first load, before any content has arrived. */
+  readonly isLoading: boolean;
+  /** `true` while a background refetch is in flight and stale content is shown. */
+  readonly isRefetching: boolean;
+  /** Error from the last failed read (a reader throw), or `null` when healthy. */
+  readonly error: Error | null;
+  /**
+   * `true` when no reader can serve this file — either no reader was injected
+   * or the reader reported the entry's substrate as unsupported (git-on-desktop,
+   * local-on-web, missing token). This is the honest "not available here" state,
+   * never an error.
+   */
+  readonly isUnsupported: boolean;
+  /** Imperatively re-read the current file. Stale content stays visible. */
+  readonly refetch: () => void;
+}
+
+/**
+ * Wrapping the resolved `WorkspaceFileContent | null` in an object lets
+ * `useFetch` distinguish "resolved to unsupported" (`content: null`) from its
+ * own `initialData` sentinel without the two colliding — the object reference
+ * is always present after a completed fetch.
+ */
+interface FileContentData {
+  readonly content: WorkspaceFileContent | null;
+}
+
+const EMPTY_CONTENT: FileContentData = { content: null };
+
+/**
+ * Behavior hook that reads a single workspace file's content on demand.
+ *
+ * The byte-reading peer of {@link useWorkspaceFiles}
+ * (which lists the tree), built on the same {@link useFetch} engine as the
+ * content-fetch family ({@link useArtifactContent},
+ * `useToolOutputContent`, `useFileChangeContent`) so it inherits their
+ * stale-while-revalidate, cancellation, and `refetch` semantics for free.
+ *
+ * Deliberately passes **no** `cacheKey`: file bodies (up to
+ * {@link MAX_WORKSPACE_FILE_READ_BYTES})
+ * do not belong in the cross-mount metadata cache, which is sized for small,
+ * hot resources. Re-opening a file re-reads it — the correct trade for a
+ * read-only viewer.
+ *
+ * Maps the reader's two failure axes onto distinct states:
+ * - reader resolves `null` (unsupported substrate) -> {@link UseWorkspaceFileContentReturn.isUnsupported}
+ * - reader **throws** (404, network, unreadable) -> {@link UseWorkspaceFileContentReturn.error}
+ *
+ * Pass `null` for `entry`/`path` (or an `undefined` reader) to stay idle —
+ * the established `useFetch` convention.
+ *
+ * @example
+ * ```tsx
+ * const { content, isLoading, error, isUnsupported } = useWorkspaceFileContent({
+ *   entry,
+ *   path: "src/index.ts",
+ *   reader: workspaceFileReader,
+ * });
+ * ```
+ */
+export function useWorkspaceFileContent({
+  entry,
+  path,
+  reader,
+}: UseWorkspaceFileContentOptions): UseWorkspaceFileContentReturn {
+  // The fetch runs only when a reader, an entry, and a path are all present.
+  const enabled = !!(reader && entry && path);
+
+  const { data, isLoading, isRefetching, error, refetch } =
+    useFetch<FileContentData>(
+      enabled
+        ? () => reader(entry, path).then((c) => ({ content: c }))
+        : null,
+      // Identity deps: a change to any of these is a different file to read.
+      [entry?.id ?? null, path ?? null, reader],
+      EMPTY_CONTENT,
+    );
+
+  // Unsupported = no reader at all, or a completed fetch that resolved to null
+  // (the reader's "this substrate isn't mine" signal). In-flight and error
+  // states are excluded so the viewer shows loading/error, not "unavailable".
+  const isUnsupported =
+    !reader || (enabled && !isLoading && !error && data.content === null);
+
+  return useMemo(
+    () => ({
+      content: data.content,
+      isLoading,
+      isRefetching,
+      error,
+      isUnsupported,
+      refetch,
+    }),
+    [data.content, isLoading, isRefetching, error, isUnsupported, refetch],
+  );
+}

package/src/workspace/useWorkspaceFileSearch.ts

@@ -0,0 +1,184 @@
+"use client";
+
+import { useEffect, useMemo, useRef, useState } from "react";
+import { toError } from "../internal/toError.js";
+import type { WorkspaceEntry } from "./useWorkspaceEntries.js";
+import type { WorkspaceFileLister } from "./WorkspaceFileLister.js";
+import { loadEntryFiles, type WorkspaceListing } from "./workspaceListingCache.js";
+import { matchWorkspaceFiles, type WorkspaceFileMatch } from "./matchWorkspaceFiles.js";
+
+/** Options for {@link useWorkspaceFileSearch}. */
+export interface UseWorkspaceFileSearchOptions {
+  /** All workspace entries to search across. */
+  readonly entries: readonly WorkspaceEntry[];
+  /** Platform-injected file lister. `undefined` → nothing is searchable. */
+  readonly lister: WorkspaceFileLister | undefined;
+  /** Current search query. Empty/whitespace yields no matches (search shows a hint). */
+  readonly query: string;
+}
+
+/** Matches (and per-entry status) for one workspace entry. */
+export interface WorkspaceFileSearchGroup {
+  /** The workspace entry these matches belong to. */
+  readonly entry: WorkspaceEntry;
+  /** Ranked matches within this entry, best-first. */
+  readonly matches: readonly WorkspaceFileMatch[];
+  /** `true` when this entry's listing was truncated (repository too large). */
+  readonly truncated: boolean;
+  /** Listing error for this entry, if any (isolated — other entries still resolve). */
+  readonly error: Error | null;
+}
+
+/** Return value of {@link useWorkspaceFileSearch}. */
+export interface UseWorkspaceFileSearchReturn {
+  /** Entries with something to show (matches, an error, or a truncation notice). */
+  readonly groups: readonly WorkspaceFileSearchGroup[];
+  /** Total matches across all groups (for a "showing N of M" affordance). */
+  readonly totalMatches: number;
+  /** `true` while any entry's listing is still loading. */
+  readonly isLoading: boolean;
+  /** `true` when no substrate can be searched (no lister, or every entry unsupported). */
+  readonly isUnsupported: boolean;
+  /** First per-entry error, for a top-level fallback message. `null` when none. */
+  readonly error: Error | null;
+}
+
+/** Per-entry listing status held while the hook loads across entries. */
+interface EntryListingState {
+  readonly status: "loading" | "ready" | "error" | "unsupported";
+  readonly listing?: WorkspaceListing;
+  readonly error?: Error;
+}
+
+const EMPTY_GROUPS: readonly WorkspaceFileSearchGroup[] = [];
+
+/**
+ * Behavior hook powering workspace-wide filename/path search.
+ *
+ * Loads each entry's listing through the shared
+ * {@link loadEntryFiles} cache (warm from
+ * Files browsing → usually free), then ranks matches per entry with the pure
+ * {@link matchWorkspaceFiles}. Fetching is keyed by the set of entry ids, so a
+ * query change re-ranks the already-loaded listings without re-fetching. Errors
+ * are isolated per entry (one failing repo never blanks the rest), and a stale
+ * generation's late resolutions are ignored.
+ *
+ * Meant to be consumed by a component mounted only while Search is active
+ * (`WorkspaceFileSearch`), so the Files view incurs no search fetching.
+ *
+ * @example
+ * ```tsx
+ * const { groups, totalMatches, isLoading } = useWorkspaceFileSearch({
+ *   entries: workspace.entries,
+ *   lister: workspaceFileLister,
+ *   query,
+ * });
+ * ```
+ */
+export function useWorkspaceFileSearch({
+  entries,
+  lister,
+  query,
+}: UseWorkspaceFileSearchOptions): UseWorkspaceFileSearchReturn {
+  const [states, setStates] = useState<Record<string, EntryListingState>>({});
+
+  // Latest entries read inside the effect without widening its dependency to the
+  // (possibly per-render) array identity — the effect keys on the id set instead.
+  const entriesRef = useRef(entries);
+  entriesRef.current = entries;
+  const entriesKey = entries.map((entry) => entry.id).join("\u0000");
+
+  // Ignore resolutions from a superseded entry set (id set or lister changed).
+  const generationRef = useRef(0);
+
+  useEffect(() => {
+    if (!lister) {
+      setStates({});
+      return;
+    }
+
+    const currentEntries = entriesRef.current;
+    const generation = ++generationRef.current;
+
+    // Seed loading for not-yet-known entries; drop states for removed ones.
+    setStates((prev) => {
+      const next: Record<string, EntryListingState> = {};
+      for (const entry of currentEntries) {
+        next[entry.id] = prev[entry.id] ?? { status: "loading" };
+      }
+      return next;
+    });
+
+    for (const entry of currentEntries) {
+      loadEntryFiles(entry, lister)
+        .then((listing) => {
+          if (generationRef.current !== generation) return;
+          setStates((prev) => ({
+            ...prev,
+            [entry.id]:
+              listing === null
+                ? { status: "unsupported" }
+                : { status: "ready", listing },
+          }));
+        })
+        .catch((err) => {
+          if (generationRef.current !== generation) return;
+          setStates((prev) => ({
+            ...prev,
+            [entry.id]: { status: "error", error: toError(err) },
+          }));
+        });
+    }
+  }, [entriesKey, lister]);
+
+  return useMemo<UseWorkspaceFileSearchReturn>(() => {
+    if (!lister) {
+      return {
+        groups: EMPTY_GROUPS,
+        totalMatches: 0,
+        isLoading: false,
+        isUnsupported: true,
+        error: null,
+      };
+    }
+
+    const groups: WorkspaceFileSearchGroup[] = [];
+    let totalMatches = 0;
+    let isLoading = false;
+    let firstError: Error | null = null;
+    let unsupportedCount = 0;
+
+    for (const entry of entries) {
+      const state = states[entry.id];
+
+      if (!state || state.status === "loading") {
+        isLoading = true;
+        continue;
+      }
+      if (state.status === "unsupported") {
+        unsupportedCount += 1;
+        continue;
+      }
+
+      const error = state.status === "error" ? state.error ?? null : null;
+      if (error && !firstError) firstError = error;
+
+      const truncated = state.listing?.truncated ?? false;
+      const matches = state.listing
+        ? matchWorkspaceFiles(state.listing.files, query)
+        : [];
+      totalMatches += matches.length;
+
+      // A group is worth showing only when it carries matches, an error, or a
+      // truncation notice — otherwise it is silent.
+      if (matches.length > 0 || error || truncated) {
+        groups.push({ entry, matches, truncated, error });
+      }
+    }
+
+    const isUnsupported =
+      entries.length > 0 && unsupportedCount === entries.length;
+
+    return { groups, totalMatches, isLoading, isUnsupported, error: firstError };
+  }, [entries, states, query, lister]);
+}

package/src/workspace/useWorkspaceFiles.ts

@@ -1,10 +1,11 @@
 "use client";
 
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { buildFileTree, type TreeNode } from "../internal/file-tree/index.js";
+import type { TreeNode } from "../internal/file-tree/index.js";
 import { toError } from "../internal/toError.js";
 import type { WorkspaceEntry } from "./useWorkspaceEntries.js";
-import type { WorkspaceFileEntry, WorkspaceFileLister } from "./WorkspaceFileLister.js";
+import type { WorkspaceFileLister } from "./WorkspaceFileLister.js";
+import { loadEntryFiles, peekEntryListing } from "./workspaceListingCache.js";
 
 /** Options for {@link useWorkspaceFiles}. */
 export interface UseWorkspaceFilesOptions {
@@ -22,39 +23,34 @@ export interface UseWorkspaceFilesReturn {
   readonly isLoading: boolean;
   /** Error from the lister, if any. */
   readonly error: Error | null;
+  /**
+   * `true` when the listing was truncated by the backend (repository too large).
+   * The advisory entry is excluded from `tree`; callers render an incomplete-results
+   * banner from this flag instead (DD-11).
+   */
+  readonly truncated: boolean;
   /** Re-fetch the file listing for the current entry (cache-bust). */
   readonly refresh: () => void;
 }
 
-interface CacheEntry {
-  files: WorkspaceFileEntry[];
-  tree: TreeNode[];
-}
-
 const EMPTY_TREE: readonly TreeNode[] = [];
 
-/**
- * Module-level cache shared across all component instances. This ensures
- * that switching between tabs (e.g., Workspace tab unmount/remount) doesn't
- * re-fetch file listings that were already loaded. Entries are keyed by
- * the workspace entry's stable ID.
- */
-const sharedCache = new Map<string, CacheEntry>();
-
 /**
  * Behavior hook that fetches and caches a file listing for a single
  * workspace entry, converting it into a {@link TreeNode} hierarchy.
  *
- * - Calls the platform-injected `lister` when the entry changes.
- * - Caches results per `entry.id` so tab switches and re-expands
- *   are instant without re-fetching.
+ * - Calls the platform-injected `lister` (via the shared
+ *   {@link loadEntryFiles} cache) when the
+ *   entry changes.
+ * - Reads the shared listing cache so tab switches, re-expands, and the search
+ *   surface are instant without re-fetching (one cache, keyed by `entry.id`).
  * - Returns an empty tree and skips the call when `lister` is
  *   `undefined` (graceful degradation — DD-011 opt-in).
  * - Memoizes the return value for referential stability (DD-010).
  *
  * @example
  * ```tsx
- * const { tree, isLoading, error, refresh } = useWorkspaceFiles({
+ * const { tree, isLoading, error, truncated, refresh } = useWorkspaceFiles({
  *   entry: selectedEntry,
  *   lister: workspaceFileLister,
  * });
@@ -67,6 +63,7 @@ export function useWorkspaceFiles({
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
   const [tree, setTree] = useState<readonly TreeNode[]>(EMPTY_TREE);
+  const [truncated, setTruncated] = useState(false);
 
   const fetchIdRef = useRef(0);
 
@@ -75,9 +72,10 @@ export function useWorkspaceFiles({
       if (!lister) return;
 
       if (!bustCache) {
-        const cached = sharedCache.get(target.id);
+        const cached = peekEntryListing(target.id);
         if (cached) {
           setTree(cached.tree);
+          setTruncated(cached.truncated);
           setError(null);
           setIsLoading(false);
           return;
@@ -89,24 +87,25 @@ export function useWorkspaceFiles({
       setError(null);
 
       try {
-        const files = await lister(target);
+        const listing = await loadEntryFiles(target, lister, { bustCache });
 
         if (fetchIdRef.current !== id) return;
 
-        if (files === null) {
+        if (listing === null) {
           setTree(EMPTY_TREE);
+          setTruncated(false);
           setIsLoading(false);
           return;
         }
 
-        const built = buildFileTree(files.filter((f) => !f.isDirectory));
-        sharedCache.set(target.id, { files, tree: built });
-        setTree(built);
+        setTree(listing.tree);
+        setTruncated(listing.truncated);
         setIsLoading(false);
       } catch (err) {
         if (fetchIdRef.current !== id) return;
         setError(toError(err));
         setTree(EMPTY_TREE);
+        setTruncated(false);
         setIsLoading(false);
       }
     },
@@ -116,6 +115,7 @@ export function useWorkspaceFiles({
   useEffect(() => {
     if (!entry || !lister) {
       setTree(EMPTY_TREE);
+      setTruncated(false);
       setIsLoading(false);
       setError(null);
       return;
@@ -130,7 +130,7 @@ export function useWorkspaceFiles({
   }, [entry, lister, fetchFiles]);
 
   return useMemo(
-    () => ({ tree, isLoading, error, refresh }),
-    [tree, isLoading, error, refresh],
+    () => ({ tree, isLoading, error, truncated, refresh }),
+    [tree, isLoading, error, truncated, refresh],
   );
 }