@@ -1,13 +1,18 @@
+import { useAtomMount, useAtomSubscribe } from "@effect/atom-react";
 import { executeAtomQuery } from "@t3tools/client-runtime/state/runtime";
 import type { EnvironmentId, ProjectEntry } from "@t3tools/contracts";
 import * as Cause from "effect/Cause";
+import { Atom } from "effect/reactivity";
 import { useEffect, useReducer, useRef, useState } from "react";
 
+import { environmentCatalog } from "../../connection/catalog";
 import { appAtomRegistry } from "../../state/atom-registry";
 import { projectEnvironment } from "../../state/projects";
 import { useDebouncedValue } from "../../state/queries";
 import { useEnvironmentQuery } from "../../state/query";
 
+const noSessionGeneration = Atom.make(0);
+
 export function useFileTreeEntries(input: {
   readonly cwd: string | null;
   readonly environmentId: EnvironmentId | null;
@@ -94,6 +99,17 @@ export function useFileTreeEntries(input: {
       render();
     });
   };
+  // A folder read fails at once while its environment is unreachable; read it again once a new
+  // session is up rather than leaving the error until someone refreshes.
+  const sessionGeneration =
+    environmentId === null
+      ? noSessionGeneration
+      : environmentCatalog.sessionGenerationAtom(environmentId);
+  // A listener alone does not compute the atom, so nothing would follow the connection.
+  useAtomMount(sessionGeneration);
+  useAtomSubscribe(sessionGeneration, () => {
+    for (const path of directories.errors.keys()) void loadDirectory(path);
+  });
   const { refresh: refreshRoot, data: rootData } = root;
   const { refresh: refreshSearch, data: searchData } = search;
   const snapshot = (() => {
 
@@ -1,11 +1,12 @@
-import { RegistryContext, useAtomValue } from "@effect/atom-react";
+import { RegistryContext, useAtomMount, useAtomSubscribe, useAtomValue } from "@effect/atom-react";
 import { executeAtomQuery, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
 import type { EnvironmentId, PullRequestDiffStat, PullRequestListInput } from "@t3tools/contracts";
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { AsyncResult, Atom, type AtomRegistry } from "effect/reactivity";
 import { use, useCallback, useMemo, useState } from "react";
+import { environmentCatalog } from "../../connection/catalog";
 import {
   composerPullRequests,
   pullRequestListPagesFamily,
@@ -142,6 +143,15 @@ const refreshLoadFamily = Atom.family((scopeKey: string) =>
   ),
 );
 
+// Changes when any of the scope's environments brings up a new session.
+const sessionsFamily = Atom.family((scopeKey: string) =>
+  Atom.make((get) =>
+    (JSON.parse(scopeKey) as readonly ListTarget[])
+      .map(({ environmentId }) => get(environmentCatalog.sessionGenerationAtom(environmentId)))
+      .join(),
+  ),
+);
+
 const settledError = (result: AsyncResult.AsyncResult<string | null, never>) =>
   AsyncResult.isSuccess(result) && !result.waiting ? result.value : null;
 
@@ -156,6 +166,19 @@ export function usePullRequestList(targets: readonly ListTarget[]) {
   // Starting one kind of load clears the other, so at most one holds an error.
   const loadError = settledError(refresh) ?? settledError(page);
 
+  // A page or refresh asked for while an environment was unreachable fails at once, and its
+  // error stops loading on scroll. Once it is back, ask for the page again; a refresh's error is
+  // stale by then because the list queries re-run on reconnect.
+  // A listener alone does not compute the atom, so nothing would follow the connections.
+  useAtomMount(sessionsFamily(scopeKey));
+  useAtomSubscribe(sessionsFamily(scopeKey), () => {
+    const pageResult = registry.get(pageAtom);
+    const refreshResult = registry.get(refreshAtom);
+    if (settledError(refreshResult) !== null) registry.set(refreshAtom, Atom.Reset);
+    else if (settledError(pageResult) !== null && !refreshResult.waiting)
+      registry.set(pageAtom, true);
+  });
+
   // Read from the registry, not the render: a second onEndReached before React re-renders must
   // see the load the first one started.
   const loadMore = (retry = false) => {
 
@@ -19,6 +19,8 @@ const state = vi.hoisted(() => ({
 
 vi.mock("react", () => ({ useCallback: <A>(callback: A) => callback }));
 vi.mock("@effect/atom-react", () => ({
+  useAtomMount: () => undefined,
+  useAtomSubscribe: () => undefined,
   useAtomValue: (atom: unknown) =>
     atom === state.assetAtom
       ? AsyncResult.success({ relativeUrl: "/api/assets/image.png", expiresAt: 1 })
@@ -39,6 +41,9 @@ vi.mock("./query", () => ({
 }));
 vi.mock("./projectClones", () => ({ environmentProjectCloneListAtom: () => null }));
 vi.mock("../connection/runtime", () => ({ connectionAtomRuntime: {} }));
+vi.mock("../connection/catalog", () => ({
+  environmentCatalog: { sessionGenerationAtom: () => null },
+}));
 vi.mock("@t3tools/client-runtime/state/assets", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@t3tools/client-runtime/state/assets")>()),
   createAssetEnvironmentAtoms: () => ({ createUrl: state.assetQuery }),
 
@@ -1,4 +1,4 @@
-import { useAtomValue } from "@effect/atom-react";
+import { useAtomMount, useAtomSubscribe, useAtomValue } from "@effect/atom-react";
 import { resolveFilesystemReadAccess } from "@t3tools/client-runtime/state/filesystem";
 import {
   assetUrlStateFromResult,
@@ -13,6 +13,7 @@ import * as Effect from "effect/Effect";
 import { Atom, AsyncResult } from "effect/reactivity";
 import { useCallback } from "react";
 
+import { environmentCatalog } from "../connection/catalog";
 import { connectionAtomRuntime } from "../connection/runtime";
 import { projectFaviconDatabaseCache } from "../lib/projectFaviconDatabaseCache";
 import { type AssetUrlState, deriveAssetUrlState } from "./asset-url-state";
@@ -112,7 +113,7 @@ export async function refreshAssetUrl(
     reportFailure: false,
     ...(signal ? { signal } : {}),
   });
-  // The query can wait through a reconnect; resolve against the connection that answered it.
+  // A route can change while the query runs; resolve against the connection now current.
   const connection = appAtomRegistry.get(connectionAtom);
   if (connection._tag === "None") return null;
   const state = assetUrlStateFromResult(result, connection.value.httpBaseUrl);
@@ -154,6 +155,7 @@ const freshAssetUrlFamily = Atom.family((key: FreshAssetUrlKey) =>
 const noFreshAssetUrl = Atom.make(AsyncResult.initial<AuthorizedAssetUrl, Error>()).pipe(
   Atom.withLabel("fresh-asset-url:none"),
 );
+const noSessionGeneration = Atom.make(0);
 
 /**
  * A signed URL minted when the reader mounts, not a cached one: cached links can
@@ -166,9 +168,20 @@ export function useFreshAssetUrl(
 ): AsyncResult.AsyncResult<AuthorizedAssetUrl, Error> {
   const connection = usePreparedConnection(environmentId);
   const httpBaseUrl = connection._tag === "Some" ? connection.value.httpBaseUrl : null;
-  return useAtomValue(
+  const atom =
     resource === null
       ? noFreshAssetUrl
-      : freshAssetUrlFamily({ environmentId, resource, httpBaseUrl, revision }),
-  );
+      : freshAssetUrlFamily({ environmentId, resource, httpBaseUrl, revision });
+  // Minting fails at once while the environment is unreachable; mint again once a new session is
+  // up instead of keeping the error until Retry.
+  const sessionGeneration =
+    environmentId === null
+      ? noSessionGeneration
+      : environmentCatalog.sessionGenerationAtom(environmentId);
+  // A listener alone does not compute the atom, so nothing would follow the connection.
+  useAtomMount(sessionGeneration);
+  useAtomSubscribe(sessionGeneration, () => {
+    if (AsyncResult.isFailure(appAtomRegistry.get(atom))) appAtomRegistry.refresh(atom);
+  });
+  return useAtomValue(atom);
 }
@@ -1,3 +1,10 @@
+import {
+  ConnectionBlockedError,
+  ConnectionTransientError,
+} from "@t3tools/client-runtime/connection";
+import { EnvironmentRpcUnavailableError } from "@t3tools/client-runtime/rpc";
+import * as Cause from "effect/Cause";
+import * as Schema from "effect/Schema";
 import type { RefObject } from "react";
 import type { ChatComposerProps } from "./ChatComposer";
 import {
@@ -49,6 +56,10 @@ import { useAtomQueryRunner } from "~/state/use-atom-query-runner";
 import { useStableCallback } from "../../hooks/useStableCallback";
 import { countPreparingComposerImages } from "./preparingComposerImages";
 
+const isUnreachable = Schema.is(
+  Schema.Union([ConnectionTransientError, ConnectionBlockedError, EnvironmentRpcUnavailableError]),
+);
+
 async function downloadAttachmentBlob(url: string): Promise<Blob | null> {
   try {
     const response = await fetch(url, { signal: AbortSignal.timeout(60_000) });
@@ -162,7 +173,12 @@ export function useComposerContextImport(input: {
           ? resolveAssetUrl(sourceConnection.httpBaseUrl, result.value.relativeUrl)
           : null;
       if (!url) {
-        fail("The original attachment is no longer available.");
+        const cause = result._tag === "Failure" ? Cause.squash(result.cause) : null;
+        fail(
+          isUnreachable(cause)
+            ? "The environment it came from is not reachable right now."
+            : "The original attachment is no longer available.",
+        );
         return;
       }
       const blob = await downloadAttachmentBlob(url);
 
@@ -0,0 +1,66 @@
+import { RegistryContext } from "@effect/atom-react";
+import { EnvironmentId } from "@t3tools/contracts";
+import * as Cause from "effect/Cause";
+import { AsyncResult, Atom } from "effect/reactivity";
+import { describe, expect, it, vi } from "vite-plus/test";
+
+import { appAtomRegistry } from "~/rpc/atomRegistry";
+import { act, render } from "../../../test/render";
+import { useDirectoryEntries } from "./useDirectoryEntries";
+
+const mocks = vi.hoisted(() => ({
+  reachable: null as unknown as Atom.Writable<boolean>,
+  connectedSession: null as unknown as Atom.Writable<number>,
+}));
+
+vi.mock("~/connection/catalog", () => ({
+  // Derived like the real one, which only follows the connection once something computes it.
+  environmentCatalog: {
+    sessionGenerationAtom: () => Atom.make((get) => get(mocks.connectedSession)),
+  },
+}));
+vi.mock("~/state/projects", () => ({
+  projectEnvironment: {
+    listEntries: () =>
+      Atom.make((get) =>
+        get(mocks.reachable)
+          ? AsyncResult.success({
+              entries: [{ path: "README.md", kind: "file" }],
+              truncated: false,
+            })
+          : AsyncResult.failure(Cause.fail(new Error("Environment is reconnecting."))),
+      ),
+  },
+}));
+
+function setup() {
+  mocks.reachable = Atom.make(false);
+  mocks.connectedSession = Atom.make(1);
+}
+
+function Probe() {
+  const directory = useDirectoryEntries(EnvironmentId.make("env-files"), "/repo");
+  return (
+    <output>{directory.error ?? directory.entries.map((entry) => entry.path).join(",")}</output>
+  );
+}
+
+describe("useDirectoryEntries", () => {
+  it("reads a folder that failed while unreachable again once a new session is up", async () => {
+    setup();
+    await using screen = await render(
+      <RegistryContext.Provider value={appAtomRegistry}>
+        <Probe />
+      </RegistryContext.Provider>,
+      // A bare hook probe; nothing here navigates.
+      { router: false },
+    );
+    await expect.element(screen.getByText("Environment is reconnecting.")).toBeInTheDocument();
+
+    await act(() => {
+      appAtomRegistry.set(mocks.reachable, true);
+      appAtomRegistry.set(mocks.connectedSession, 2);
+    });
+    await expect.element(screen.getByText("README.md")).toBeInTheDocument();
+  });
+});
@@ -1,8 +1,10 @@
 import type { EnvironmentId, ProjectEntry } from "@t3tools/contracts";
+import { useAtomMount, useAtomSubscribe } from "@effect/atom-react";
 import { executeAtomQuery } from "@t3tools/client-runtime/state/runtime";
 import * as Cause from "effect/Cause";
 import { useEffect, useRef, useState } from "react";
 
+import { environmentCatalog } from "~/connection/catalog";
 import { appAtomRegistry } from "~/rpc/atomRegistry";
 import { projectEnvironment } from "~/state/projects";
 
@@ -100,6 +102,15 @@ export function useDirectoryEntries(environmentId: EnvironmentId, cwd: string) {
     };
   }, [startRequest]);
 
+  // A folder read fails at once while its environment is unreachable; read it again once a new
+  // session is up rather than leaving the error until someone retries by hand.
+  const sessionGeneration = environmentCatalog.sessionGenerationAtom(environmentId);
+  // A listener alone does not compute the atom, so nothing would follow the connection.
+  useAtomMount(sessionGeneration);
+  useAtomSubscribe(sessionGeneration, () => {
+    for (const path of errors.keys()) void load(path);
+  });
+
   const entries: ProjectEntry[] = [];
   const visit = (path: string) => {
     for (const entry of directories.get(path) ?? []) {