lael-labs/t3code

apps/web/src/components/ChatMarkdown.workspace-images.test.tsx+64−57

 const testState = vi.hoisted(() => ({
   resources: [] as Array<unknown>,
   assetState: "success" as "success" | "loading" | "failure",
-  editorEnvironmentIds: [] as Array<unknown>,
-  remoteEnvironmentIds: [] as Array<unknown>,
 }));
 vi.mock("@effect/atom-react", () => ({ useAtomValue: () => null }));
 vi.mock("../assets/assetUrls", () => ({
+  useAssetUrlRefresh: () => vi.fn(),
   useAssetUrlState: (_environmentId: unknown, resource: unknown) => {
     testState.resources.push(resource);
     if (testState.assetState === "loading") return { _tag: "Loading" };
   ...(await importOriginal<typeof import("../state/session")>()),
   usePreparedConnection: () => ({ _tag: "Loading" }),
 }));
-vi.mock("../editorPreferences", () => ({
+vi.mock("../state/entities", () => ({
-  useOpenInPreferredEditor: (environmentId: unknown) => {
+  readThreadShell: () => null,
-    testState.editorEnvironmentIds.push(environmentId);
+  useProjects: () => [],
-    return vi.fn();
-  },
-  usePreferredEditor: () => ["vscode", vi.fn()],
 }));
 vi.mock("../remoteOpen", () => ({
-  useRemoteOpenResolution: (environmentId: unknown) => {
+  useRemoteOpenResolution: () => ({ state: { mode: "local-exec" }, isResolved: true }),
-    testState.remoteEnvironmentIds.push(environmentId);
+}));
-    return {
+vi.mock("../editorPreferences", () => ({
-      isResolved: true,
+  useOpenInPreferredEditor: () => vi.fn(),
-      state: { mode: "local-exec", localExecutionUnavailableReason: null },
+  usePreferredEditor: () => [null, vi.fn()],
-    };
+}));
-  },
+vi.mock("~/lib/openPullRequestLink", () => ({
+  findProjectForChangeRequest: () => undefined,
+  matchesLinkedPullRequestUrl: () => false,
+  parseChangeRequestUrl: () => null,
+  useOpenChangeRequestLink: () => vi.fn(),
 }));
-vi.mock("~/lib/openPullRequestLink", () => ({ useOpenChangeRequestLink: () => vi.fn() }));
 import ChatMarkdown from "./ChatMarkdown";
 import { FileMarkdownPreview } from "./files/FileMarkdownPreview";
   beforeEach(() => {
     testState.resources = [];
     testState.assetState = "success";
-    testState.editorEnvironmentIds = [];
-    testState.remoteEnvironmentIds = [];
   });
   it.each([
     expect(testState.resources).toEqual([
       {
-        _tag: "workspace-file",
+        _tag: "media-file",
         threadId: threadRef.threadId,
         path: expectedPath,
       },
     ]);
   });
-  it("loads relative workspace paths through signed asset URLs", () => {
+  it("loads every Windows workspace path form through a signed asset URL", () => {
-    const html = render("![relative](.t3/workspace-image.svg)");
+    const imagePath = "C:/Users/shawn/project/.t3/workspace-image.svg";
+    const html = render(
+      [
+        "![relative](.t3/workspace-image.svg)",
+        `![absolute](${imagePath})`,
+        `![file URL](file:///${imagePath})`,
+        "![UNC file URL](file://server/share/workspace-image.svg)",
+      ].join("\n\n"),
+    );
     expect(testState.resources).toEqual([
       {
-        _tag: "workspace-file",
+        _tag: "media-file",
         threadId: threadRef.threadId,
         path: "C:\\Users\\shawn\\project\\.t3\\workspace-image.svg",
       },
+      { _tag: "media-file", threadId: threadRef.threadId, path: imagePath },
+      { _tag: "media-file", threadId: threadRef.threadId, path: imagePath },
+      {
+        _tag: "media-file",
+        threadId: threadRef.threadId,
+        path: "\\\\server\\share\\workspace-image.svg",
+      },
     ]);
-    expect(html).toContain("https://signed.test/workspace-image.svg");
+    expect(html.match(/https:\/\/signed\.test\/workspace-image\.svg/g)).toHaveLength(4);
+    expect(html.match(/max-w-\[min\(100%,30rem\)\]/g)).toHaveLength(4);
+    expect(html.match(/max-h-\[30rem\]/g)).toHaveLength(4);
+    expect(html).not.toContain("Image unavailable");
   });
-  it("preserves Windows drive links through markdown sanitization", () => {
+  it("normalizes a drive-absolute src in raw image HTML", () => {
-    const html = render(String.raw`[Open](C:\Users\shawn\project\src\main.ts)`);
+    const html = render(String.raw`<img src="D:\screens\workspace-image.svg" alt="raw">`);
-    expect(html).toContain('href="C:/Users/shawn/project/src/main.ts"');
-    expect(html).toContain("chat-markdown-file-link");
-  });
-  it("loads drive-absolute markdown and raw HTML images through assets", () => {
-    const html = render(
-      [
-        "![absolute](C:/Users/shawn/project/.t3/workspace-image.svg)",
-        String.raw`<img src="D:\screens\workspace-image.svg" alt="raw">`,
-      ].join("\n\n"),
-    );
     expect(testState.resources).toEqual([
       {
-        _tag: "workspace-file",
+        _tag: "media-file",
-        threadId: threadRef.threadId,
-        path: "C:/Users/shawn/project/.t3/workspace-image.svg",
-      },
-      {
-        _tag: "workspace-file",
         threadId: threadRef.threadId,
         path: "D:/screens/workspace-image.svg",
       },
     ]);
-    expect(html.match(/https:\/\/signed\.test\/workspace-image\.svg/g)).toHaveLength(2);
+    expect(html).toContain("https://signed.test/workspace-image.svg");
   });
   it("keeps a tall image placeholder and loaded image at the same proportional bounds", () => {
   it("uses a static bounded-width placeholder while a signed asset URL loads", () => {
     testState.assetState = "loading";
     const html = render("![loading](.t3/workspace-image.svg)");
     const className = /<span[^>]*aria-label="Loading image"[^>]*class="([^"]*)"/.exec(html)?.[1];
     expect(className?.split(" ")).toContain("w-64");
   });
-  it("keeps remote images directly loadable", () => {
+  it("never passes a workspace source to a raw image when thread context is unavailable", () => {
-    const html = render("![remote](https://example.com/image.png)");
+    const html = renderWithoutThread(
+      "![file URL](file:///C:/Users/shawn/project/workspace-image.svg)",
+    );
     expect(testState.resources).toEqual([]);
-    expect(html).toContain('src="https://example.com/image.png"');
+    expect(html).toContain("Image unavailable");
-    expect(html).toContain("max-h-[30rem]");
+    expect(html).not.toContain("file://");
   });
-  it("uses the markdown owner's environment for file actions", () => {
+  it("blocks unsupported image schemes instead of passing them to a raw image", () => {
-    const owningEnvironmentId = EnvironmentId.make("env-pull-request");
+    const html = render("![unsupported](content://media/image/1)");
-    renderToStaticMarkup(
+    expect(testState.resources).toEqual([]);
-      <ChatMarkdown
+    expect(html).toContain("Image unavailable");
-        cwd="/workspace/project"
+    expect(html).not.toContain("content://");
-        environmentId={owningEnvironmentId}
+  });
-        text="[Open](src/main.ts)"
-      />,
-    );
-    expect(testState.editorEnvironmentIds).toEqual([owningEnvironmentId]);
+  it("keeps remote images directly loadable", () => {
-    expect(testState.remoteEnvironmentIds).toEqual([owningEnvironmentId]);
+    const html = render("![remote](https://example.com/image.png)");
+    expect(testState.resources).toEqual([]);
+    expect(html).toContain('src="https://example.com/image.png"');
+    expect(html).toContain("max-w-[min(100%,30rem)]");
+    expect(html).toContain("max-h-[30rem]");
+    expect(html).not.toContain("Image unavailable");
   });
 });

apps/web/src/components/ChatView.logic.test.ts+2−2

   deriveComposerSendState,
   dismissBranchMismatchForSession,
   getStartedThreadModelChangeBlockReason,
+  isVideoPreviewRequestCurrent,
+  hasEnvironmentReconnectWarningGraceElapsed,
   hasServerAcknowledgedLocalDispatch,
   isBranchMismatchDismissedForSession,
-  isVideoPreviewRequestCurrent,
-  loadVideoPreviewUrl,
   reconcileMountedTerminalThreadIds,
   reconcileRetainedMountedThreadIds,
   resolveDraftPromotionNavigationTarget,

apps/web/src/components/ChatView.logic.ts+6−0

   type RunId,
 } from "@t3tools/contracts";
 import * as DateTime from "effect/DateTime";
+import { resolveAssetUrl } from "@t3tools/client-runtime/state/assets";
+import {
+  squashAtomCommandFailure,
+  type AtomCommandResult,
+} from "@t3tools/client-runtime/state/runtime";
+import { videoMimeType } from "@t3tools/shared/video";
 import {
   appendCodexArtifactTemplateUsePrompt,
   codexArtifactTemplateUsePrompt,

apps/web/src/components/ChatView.tsx+151−91

   threadWokeAt,
 } from "@t3tools/client-runtime/state/thread-settled";
 import { useThreadActions } from "../hooks/useThreadActions";
-import {
-  resolveDisplayedThreadPr,
-  threadChangeRequestSnapshotsAtom,
-  useLinkedThreadPullRequest,
-} from "./ThreadStatusIndicators";
 import {
   deriveThreadActivityRun,
   deriveLatestThreadRun,
 import { derivePendingBackgroundWork } from "@t3tools/shared/orchestrationV2PendingBackgroundWork";
 import { projectScriptCwd, projectScriptRuntimeEnv } from "@t3tools/shared/projectScripts";
 import { truncate } from "@t3tools/shared/String";
-import { nextTerminalId, resolveTerminalSessionLabel } from "@t3tools/shared/terminalLabels";
+import { resolveThreadReferenceCopyTarget } from "@t3tools/shared/threadReference";
+import {
+  getTerminalLabel,
+  nextTerminalId,
+  resolveTerminalSessionLabel,
+} from "@t3tools/shared/terminalLabels";
 import { Debouncer } from "@tanstack/react-pacer";
 import { useAtomValue } from "@effect/atom-react";
 import {
   ThreadErrorBanner,
 } from "./chat/ThreadErrorBanner";
 import { resolveThreadPr } from "./ThreadStatusIndicators";
-import { type ComposerBannerStackItem } from "./chat/ComposerBannerStack";
 import { QueuedRunsControl, type EditQueuedRunRequest } from "./chat/QueuedRunsControl";
+import {
+  resolveDisplayedThreadPr,
+  threadPullRequestRefreshSource,
+  threadChangeRequestSnapshotsAtom,
+  useLinkedThreadPullRequest,
+} from "./ThreadStatusIndicators";
+import type { ComposerBannerStackItem } from "./chat/ComposerBannerStack";
 import { ComposerSurface } from "./chat/ComposerSurface";
 import { resolveThreadSyncPhase } from "../threadSync";
 import {
   });
   const createAttachmentAssetUrl = useAtomQueryRunner(assetEnvironment.createUrl, {
     reportFailure: false,
+    refresh: true,
   });
   const interruptThreadTurn = useAtomCommand(threadEnvironment.interruptTurn, {
     reportFailure: false,
   >({});
   const activePullRequestSurfaceId =
     activeRightPanelSurface?.kind === "pull-request" ? activeRightPanelSurface.id : undefined;
-  const handlePullRequestTabStatusChange = useCallback(
+  const updatePullRequestTabStatusFromPanel = useCallback(
     (status: PullRequestTabStatus) => {
       const id = activePullRequestSurfaceId;
       if (id === undefined) return;
     },
     [activePullRequestSurfaceId],
   );
+  const refreshVcsStatus = useAtomCommand(vcsEnvironment.refreshStatus, { reportFailure: false });
+  const sidebarPrRefreshKeyRef = useRef<string | null>(null);
   const activeFileSurface =
     activeRightPanelSurface?.kind === "file" ? activeRightPanelSurface : null;
   const activePreviewState = useThreadPreviewState(activeThreadRef);
         toastManager.add({ type: "error", title: "The environment is not connected." });
         return;
       }
-      const videoMime = videoMimeType(attachment);
+      const isVideo = videoMimeType(attachment) !== null;
-      const isVideo = videoMime !== null;
       const action = isVideo ? "play" : "download";
-      const videoPreviewAbortController = isVideo ? new AbortController() : null;
-      if (isVideo) {
-        videoPreviewAbortControllerRef.current?.abort();
-        videoPreviewAbortControllerRef.current = videoPreviewAbortController;
-      }
       const videoPreviewRequestId = isVideo ? ++videoPreviewRequestIdRef.current : 0;
       const isCurrentRequest = () =>
         !isVideo ||
           videoPreviewRequestId,
           videoPreviewRequestIdRef.current,
         );
-      const finishVideoPreviewRequest = () => {
-        if (videoPreviewRequestIdRef.current === videoPreviewRequestId) {
-          setOpeningVideoAttachmentId(null);
-          videoPreviewAbortControllerRef.current = null;
-        }
-      };
       if (isVideo) setOpeningVideoAttachmentId(attachment.id);
-      // fileName and mimeType ride in the signed claims so videos render
+      try {
-      // inline while other files keep their real download name and type.
+        const url = await resolveFileAttachmentUrl({
-      const result = await createAttachmentAssetUrl({
+          attachment,
-        environmentId,
+          environmentId,
-        input: {
+          httpBaseUrl: connection.httpBaseUrl,
-          resource: {
+          createAssetUrl: createAttachmentAssetUrl,
-            _tag: "attachment",
-            attachmentId: attachment.id,
-            fileName: attachment.name,
-            mimeType: videoMime ?? attachment.mimeType,
-          },
-        },
-      });
-      if (!isCurrentRequest()) {
-        finishVideoPreviewRequest();
-        return;
-      }
-      if (result._tag === "Failure") {
-        finishVideoPreviewRequest();
-        const error = squashAtomCommandFailure(result);
-        toastManager.add({
-          type: "error",
-          title: "Could not " + action + " " + attachment.name,
-          description: error instanceof Error ? error.message : "The attachment is unavailable.",
         });
-        return;
+        if (!isCurrentRequest()) return;
-      }
+        if (isVideo) {
-      const url = resolveAssetUrl(connection.httpBaseUrl, result.value.relativeUrl);
-      if (!url) {
-        finishVideoPreviewRequest();
-        toastManager.add({ type: "error", title: "Could not " + action + " " + attachment.name });
-        return;
-      }
-      if (isVideo) {
-        try {
-          const previewUrl = await loadVideoPreviewUrl(url, videoPreviewAbortController?.signal);
-          if (!isCurrentRequest()) {
-            revokeBlobPreviewUrl(previewUrl);
-            return;
-          }
           setExpandedImage({
-            images: [{ src: previewUrl, name: attachment.name, type: "video" }],
+            images: [{ src: url, name: attachment.name, type: "video" }],
             index: 0,
           });
-        } catch (error) {
+          return;
-          if (!isCurrentRequest()) return;
-          toastManager.add({
-            type: "error",
-            title: "Could not play " + attachment.name,
-            description: error instanceof Error ? error.message : "The attachment is unavailable.",
-          });
-        } finally {
-          finishVideoPreviewRequest();
         }
-        return;
+        const anchor = document.createElement("a");
+        anchor.href = url;
+        anchor.download = attachment.name;
+        anchor.click();
+      } catch (error) {
+        if (!isCurrentRequest()) return;
+        toastManager.add({
+          type: "error",
+          title: "Could not " + action + " " + attachment.name,
+          description: error instanceof Error ? error.message : "The attachment is unavailable.",
+        });
+      } finally {
+        if (isVideo && isCurrentRequest()) setOpeningVideoAttachmentId(null);
       }
-      const anchor = document.createElement("a");
-      anchor.href = url;
-      anchor.download = attachment.name;
-      anchor.click();
     },
     [createAttachmentAssetUrl, environmentId, routeThreadKey],
   );
   );
   // The server-projected settled state keeps the banner and sidebar in sync.
   const activeThreadShell = useThreadShell(isServerThread ? activeThreadRef : null);
-  const autoSettleAfterDays = useClientSettings((settings) => settings.sidebarAutoSettleAfterDays);
+  const autoSettleAfterDays = useEnvironmentSettings(
-  const autoSettleOnMerge = useClientSettings((settings) => settings.sidebarAutoSettleOnMerge);
+    environmentId,
+    (settings) => settings.sidebarAutoSettleAfterDays,
+  );
+  const autoSettleOnMerge = useEnvironmentSettings(
+    environmentId,
+    (settings) => settings.sidebarAutoSettleOnMerge,
+  );
   const changeRequestSnapshotByKey = useAtomValue(threadChangeRequestSnapshotsAtom);
   // The thread's own change request, placed against the project it belongs to.
   const linkedThreadPullRequest = activeThread?.linkedPullRequest ?? null;
     linkedPullRequest: linkedThreadPullRequest,
     linkedPullRequestStatus,
   });
+  const handlePullRequestTabStatusChange = useCallback(
+    (status: PullRequestTabStatus) => {
+      updatePullRequestTabStatusFromPanel(status);
+      const source = threadPullRequestRefreshSource({
+        panel: status,
+        thread: {
+          repository: threadRepository,
+          number: linkedThreadPullRequest?.number ?? activeThreadPr?.number ?? null,
+          state: activeThreadPr?.state ?? null,
+          linked: linkedThreadPullRequest !== null,
+        },
+      });
+      if (source === null) {
+        sidebarPrRefreshKeyRef.current = null;
+        return;
+      }
+      const refreshKey = `${activeThreadKey}:${source}:${status.repository}#${status.number}:${status.state}`;
+      if (sidebarPrRefreshKeyRef.current === refreshKey) return;
+      sidebarPrRefreshKeyRef.current = refreshKey;
+      if (source === "linked-detail" && activeThreadRef && linkedThreadPullRequest) {
+        appAtomRegistry.refresh(
+          linkedPullRequestDetailAtom({
+            environmentId: activeThreadRef.environmentId,
+            input: {
+              projectId: linkedThreadPullRequest.projectId,
+              repository: linkedThreadPullRequest.repository,
+              number: linkedThreadPullRequest.number,
+            },
+          }),
+        );
+        return;
+      }
+      if (source === "vcs" && activeThreadRef && gitCwd !== null) {
+        void refreshVcsStatus({
+          environmentId: activeThreadRef.environmentId,
+          input: { cwd: gitCwd },
+        }).then(() => {
+          if (sidebarPrRefreshKeyRef.current === refreshKey) {
+            sidebarPrRefreshKeyRef.current = null;
+          }
+        });
+      }
+    },
+    [
+      activeThreadKey,
+      activeThreadPr?.number,
+      activeThreadPr?.state,
+      activeThreadRef,
+      gitCwd,
+      linkedThreadPullRequest,
+      refreshVcsStatus,
+      threadRepository,
+      updatePullRequestTabStatusFromPanel,
+    ],
+  );
+  const activeThreadReferenceCopyTarget = useMemo(
+    () =>
+      activeThreadId === null || !isServerThread
+        ? null
+        : resolveThreadReferenceCopyTarget({
+            threadId: activeThreadId,
+            linkedPullRequestUrl: linkedThreadPullRequest?.url ?? null,
+            detectedPullRequestUrl: activeThreadPr?.url ?? null,
+          }),
+    [activeThreadId, activeThreadPr?.url, isServerThread, linkedThreadPullRequest?.url],
+  );
+  const copyActiveThreadReference = useCallback(() => {
+    const target = activeThreadReferenceCopyTarget;
+    if (target === null) return;
+    void writeTextToClipboard(target.value, target.clipboardTarget).then(
+      (didCopy) => {
+        if (!didCopy) return;
+        toastManager.add({
+          type: "success",
+          title: target.successTitle,
+          description: target.value,
+        });
+      },
+      (error) => {
+        console.error(error);
+        toastManager.add(
+          stackedThreadToast({
+            type: "error",
+            title: target.failureTitle,
+            description: error instanceof Error ? error.message : "An error occurred.",
+          }),
+        );
+      },
+    );
+  }, [activeThreadReferenceCopyTarget]);
   // The right panel offers the thread's own change request, so it can only offer it once the
   // branch has one; until then the picker says so rather than opening an empty panel.
   const addPullRequestSurface = useCallback(() => {
     if (activeThreadRef === null || activeThreadWokeAt === null) return;
     markThreadVisited(scopedThreadKey(activeThreadRef), activeThreadWokeAt);
   }, [activeThreadRef, activeThreadWokeAt, markThreadVisited]);
-  // Mirror of the sidebar's Woke pill for the open thread. It uses the same
+  // Mirror of the sidebar's Woke pill for the open thread.
-  // visit comparison and change request settle rule.
   const activeThreadLastVisitedAt = useUiStateStore((store) =>
     activeThreadKey === null ? undefined : store.threadLastVisitedAtById[activeThreadKey],
   );
   const activeThreadWokeVisible = useMemo(() => {
     if (activeThreadWokeAt === null) return false;
-    if (
+    if (activeThreadShell?.settledOverride === "settled") return false;
-      changeRequestAutoSettles(activeThreadChangeRequest, {
-        autoSettleOnMerge,
-        thread: activeThreadShell,
-      })
-    ) {
-      return false;
-    }
     const wokeAtMs = Date.parse(activeThreadWokeAt);
     if (Number.isNaN(wokeAtMs)) return false;
     // Having the thread open counts as a visit at completedAt (the effect
   }, [
     activeLatestRun?.completedAt,
     activeThreadLastVisitedAt,
-    activeThreadChangeRequest,
     activeThreadShell,
     activeThreadWokeAt,
     autoSettleOnMerge,
     nowMinute,
     supportsSettlement,
   ]);
-  const activeThreadSettled =
-    supportsSettlement && activeThreadShell?.settledOverride === "settled";
   const unsettleThreadMutation = useAtomCommand(threadEnvironment.unsettle, {
     reportFailure: false,
   });
       });
       if (!command) return;
+      if (command === "thread.copyReference") {
+        event.preventDefault();
+        event.stopPropagation();
+        if (!event.repeat) copyActiveThreadReference();
+        return;
+      }
       if (command === "thread.settle") {
         event.preventDefault();
         event.stopPropagation();
     supportsPinning,
     supportsSettlement,
     confirmAndUnpinThread,
+    copyActiveThreadReference,
     toggleRightPanel,
     toggleThreadPanel,
     toggleTerminalVisibility,
                         }
                       >
                         <DraftHeroHeadline
+                          draftId={draftId}
                           activeProjectRef={activeProjectRef}
                           activeProjectTitle={activeProject?.title ?? null}
                         />

apps/web/src/components/Sidebar.tsx+30−30

 import { CSS } from "@dnd-kit/utilities";
 import {
   canSnooze,
+  effectiveSettled,
   effectiveSnoozed,
   threadWokeAt,
 } from "@t3tools/client-runtime/state/thread-settled";
 import { useHandleNewThread } from "../hooks/useHandleNewThread";
 import { isCommandPaletteOpen, openCommandPalette } from "../commandPaletteBus";
 import { startNewThreadFromContext } from "../lib/chatThreadActions";
-import { useClientSettings } from "../hooks/useSettings";
+import { useClientSettings, usePrimarySettings } from "../hooks/useSettings";
 import { useCopyToClipboard } from "../hooks/useCopyToClipboard";
 import { useLocalStorage } from "../hooks/useLocalStorage";
 import { useNowMinute } from "../hooks/useNowMinute";
 import { ProviderInstanceIcon } from "./chat/ProviderInstanceIcon";
 import { getTriggerDisplayModelLabel } from "./chat/providerIconUtils";
 import {
-  deriveProviderInstanceEntries,
+  deriveProviderEntriesByEnvironment,
   shouldShowInstanceBadge,
   type ProviderInstanceEntry,
 } from "../providerInstances";
   const isWoke =
     wokeAtDate !== null &&
     (lastVisitedDate === null || lastVisitedDate < wokeAtDate) &&
-    !changeRequestAutoSettles(pr, {
+    thread.settledOverride !== "settled";
-      autoSettleOnMerge: props.autoSettleOnMerge,
-      thread,
-    });
   // In-flight rows (working, or waiting on approval/input) fade as a whole:
   // there is nothing for the user to do yet, so prominence is reserved for
   // rows that need a human — done (unread), read-but-unsettled, failed, and
   const { isMobile, setOpenMobile } = useSidebar();
   const keybindings = useAtomValue(primaryServerKeybindingsAtom);
   const confirmThreadDelete = useClientSettings((s) => s.confirmThreadDelete);
+  const autoSettleAfterDays = usePrimarySettings((s) => s.sidebarAutoSettleAfterDays);
+  const autoSettleOnMerge = usePrimarySettings((s) => s.sidebarAutoSettleOnMerge);
   const confirmThreadArchive = useClientSettings((s) => s.confirmThreadArchive);
   const sidebarProjectSortOrder = useClientSettings((s) => s.sidebarProjectSortOrder);
   const timestampFormat = useClientSettings((s) => s.timestampFormat);
     () => sortLogicalProjectsForSidebar(unsortedProjectGroups, threads, sidebarProjectSortOrder),
     [sidebarProjectSortOrder, threads, unsortedProjectGroups],
   );
-  const serverProviders = useAtomValue(primaryServerProvidersAtom);
+  const projectGroupsRef = useRef(projectGroups);
-  const providerEntryByInstanceId = useMemo(
+  projectGroupsRef.current = projectGroups;
+  const serverConfigs = useAtomValue(environmentServerConfigsAtom);
+  // Threads on non-primary environments (T3 Connect, hosted) resolve their
+  // provider entry from their own environment's config: default instance ids
+  // are driver slugs, so a flat map would collide across environments.
+  const providerEntriesByEnvironment = useMemo(
     () =>
-      new Map(
+      deriveProviderEntriesByEnvironment(
-        deriveProviderInstanceEntries(serverProviders).map(
+        [...serverConfigs].map(
-          (entry) => [entry.instanceId as string, entry] as const,
+          ([environmentId, config]) => [environmentId, config.providers] as const,
         ),
       ),
-    [serverProviders],
+    [serverConfigs],
   );
   const projectCwdByKey = useMemo(
     () =>
     clearSelection();
   }, [clearSelection, projectScopeKey]);
-  const handleProjectSettings = useCallback(
+  const openProjectSettings = useCallback(
-    (event: ReactMouseEvent<HTMLButtonElement>, projectGroup: SidebarProjectSnapshot) => {
+    (projectGroup: SidebarProjectSnapshot) => {
-      event.preventDefault();
-      event.stopPropagation();
-      dispatchProjectScopeMenu({ type: "project-settings-opened" });
       if (isMobile) {
         setOpenMobile(false);
       }
   // the partition works directly off live shells: no archived-snapshot
   // merging, no optimistic holds. Archived threads remain hidden here —
   // archive keeps its original "remove from sidebar" meaning.
-  const serverConfigs = useAtomValue(environmentServerConfigsAtom);
   const {
     pinnedThreads,
     reorderablePinnedKeys,
     // memo exactly at the next wake boundary.
     void snoozeWakeTick;
     const preciseNow = new Date().toISOString();
+    const now = `${nowMinute}:00.000Z`;
     // Subagent child threads live in the parent's Agents surface, not the
     // sidebar roster (v2 models them as real threads with lineage).
     const visible = filterSidebarV2VisibleThreads(threads, scopedProjectKeys);
       settledThreads: sortSettledThreadsForSidebar(settled),
       snoozeNow: preciseNow,
     };
-  }, [
+  }, [nowMinute, scopedProjectKeys, serverConfigs, snoozeWakeTick, threads]);
-    autoSettleAfterDays,
-    autoSettleOnMerge,
-    changeRequestSnapshotByKey,
-    nowMinute,
-    scopedProjectKeys,
-    serverConfigs,
-    snoozeWakeTick,
-    threads,
-  ]);
   const threadSearchInputRef = useRef<HTMLInputElement>(null);
   const [threadSearchQuery, setThreadSearchQuery] = useState("");
                           ) ?? null
                         }
                         environmentLabel={environmentLabelById.get(thread.environmentId) ?? null}
-                        providerEntryByInstanceId={providerEntryByInstanceId}
+                        providerEntryByInstanceId={
+                          providerEntriesByEnvironment.get(thread.environmentId) ??
+                          EMPTY_PROVIDER_ENTRIES
+                        }
                         isHighlighted={activeSearchResultIndex === index}
                         isRouteActive={routeThreadKey === threadKey}
                         resultId={`sidebar-thread-search-result-${index}`}
                             `${thread.environmentId}:${thread.projectId}`,
                           ) ?? null
                         }
-                        providerEntryByInstanceId={providerEntryByInstanceId}
+                        providerEntryByInstanceId={
+                          providerEntriesByEnvironment.get(thread.environmentId) ??
+                          EMPTY_PROVIDER_ENTRIES
+                        }
                         timestampFormat={timestampFormat}
                         onThreadClick={handleThreadClick}
                         onThreadActivate={navigateToThread}
       <SidebarChromeFooter />
     </>
   );
+  const EMPTY_PROVIDER_ENTRIES: ReadonlyMap<string, ProviderInstanceEntry> = new Map();
 }

apps/web/src/components/chat/ChatComposer.tsx+1−0

@@ -172,6 +172,7 @@ import { · 171 unmodified lines
172	submitComposerDraft,	172	submitComposerDraft,
173	} from "./composerSubmission";	173	} from "./composerSubmission";
174	import { ComposerPromptLengthValidation } from "./ComposerPromptLengthValidation";	174	import { ComposerPromptLengthValidation } from "./ComposerPromptLengthValidation";
		175	import { prepareVideoFirstFrame } from "../../lib/videoFirstFrame";
175		176
176	function ComposerVideoThumbnail({ file }: { file: File }) {	177	function ComposerVideoThumbnail({ file }: { file: File }) {
177	const setVideo = useCallback(	178	const setVideo = useCallback(

apps/web/src/components/chat/MessagesTimeline.logic.test.ts+10−9

       "assistant-final-entry",
       "user-followup-entry",
       "working-indicator-row",
-      "thinking-indicator-row",
+      "live-activity-row",
     ]);
     const finalRow = rows.find((row) => row.id === "assistant-final-entry");
     expect(finalRow?.kind === "message" && finalRow.showAssistantMeta).toBe(true);
       revertTurnCountByUserMessageId: new Map(),
     });
-    // The settled tool stays visible in past tense instead of vanishing, and
+    // A successfully settled command keeps the shared live-activity row alive
-    // the thinking indicator marks that the turn itself is still running.
+    // between actions (#9098) instead of dropping to past tense, so no extra
-    expect(rows.map((row) => row.kind)).toEqual(["working", "work-live", "thinking"]);
+    // thinking row appears while the turn is still running.
+    expect(rows.map((row) => row.kind)).toEqual(["working", "work-live"]);
     expect(rows.find((row) => row.kind === "work-live")).toMatchObject({
-      active: false,
+      active: true,
+      id: "live-activity-row",
       entry: { id: "work-1" },
     });
-    expect(rows.at(-1)).toMatchObject({ kind: "thinking" });
   });
   it("does not fold the active in-progress turn", () => {
     expect(rows.map((row) => row.id)).toEqual([
       "working-indicator-row",
       "assistant-thought-entry",
-      "work-live:work-entry-1",
+      "live-activity-row",
     ]);
     const liveRow = rows.find((row) => row.kind === "work-live");
     expect(liveRow?.kind === "work-live" ? liveRow.entry.id : null).toBe("work-1");
       initial,
     );
-    const initialThinking = initial.byId.get("thinking-indicator-row");
+    const initialThinking = initial.byId.get("live-activity-row");
-    const updatedThinking = updated.byId.get("thinking-indicator-row");
+    const updatedThinking = updated.byId.get("live-activity-row");
     expect(initialThinking).toMatchObject({ kind: "thinking" });
     expect(updatedThinking).toBe(initialThinking);
     expect(updated.result.at(-1)).toBe(updatedThinking);

apps/web/src/components/chat/MessagesTimeline.logic.ts+16−207

@@ -1,9 +1,6 @@
1	import * as Equal from "effect/Equal";	1	import * as Equal from "effect/Equal";
2	import { renderCodexDirectivesForCopy } from "@t3tools/client-runtime/codex-markdown-directives";	2	import { renderCodexDirectivesForCopy } from "@t3tools/client-runtime/codex-markdown-directives";
3	import {	3	import {
4	normalizeCompactToolLabel,
5	omitSupersededLifecycleMarkers,
6	resolveWorkEntryToolPresentation,
7	summarizeToolGroup,	4	summarizeToolGroup,
8	toolGroupSummaryKind,	5	toolGroupSummaryKind,
9	type ToolGroupSummaryKind,	6	type ToolGroupSummaryKind,
@@ -18,6 +15,7 @@ import { · 8 unmodified lines
18	formatDuration,	15	formatDuration,
19	timelineEntryIsPersistentResourceCard,	16	timelineEntryIsPersistentResourceCard,
20	workEntryDisplayIndicatesToolFailure,	17	workEntryDisplayIndicatesToolFailure,
		18	workEntryIndicatesToolSuccess,
21	workEntryIndicatesToolNeutralStatus,	19	workEntryIndicatesToolNeutralStatus,
22	workLogEntryIsToolLike,	20	workLogEntryIsToolLike,
23	type TimelineEntry,	21	type TimelineEntry,
@@ -337,200 +335,6 @@ export function computeMessageDurationStart( · 313 unmodified lines
337	return result;	335	return result;
338	}	336	}
339		337
340	export function normalizeCompactToolLabel(value: string): string {
341	return value.replace(/\s+(?:complete\|completed)\s*$/i, "").trim();
342	}
343
344	type ToolGroupAction = "read" \| "edit" \| "command" \| "code-search" \| "search" \| "other" \| "update";
345	export type ToolGroupSummaryKind =
346	\| ToolGroupAction
347	\| "dynamic-tool"
348	\| "agent-tool"
349	\| "tone-tool"
350	\| "mixed";
351
352	export function workLogEntryIsLocalCodeSearch(entry: WorkLogEntry): boolean {
353	return (
354	entry.itemType === "file_search" \|\|
355	(entry.itemType === "web_search" &&
356	/\bgrep\b/i.test(normalizeCompactToolLabel(entry.toolTitle ?? entry.label)))
357	);
358	}
359
360	export function toolGroupAction(entry: WorkLogEntry): ToolGroupAction {
361	if (
362	entry.itemType === "dynamic_tool" &&
363	/^read(?:\s+file)?$/i.test(normalizeCompactToolLabel(entry.toolTitle ?? entry.label))
364	) {
365	return "read";
366	}
367	if (entry.itemType === "file_change" \|\| (entry.changedFiles?.length ?? 0) > 0) {
368	return "edit";
369	}
370	if (entry.itemType === "command_execution" \|\| entry.command) {
371	return "command";
372	}
373	if (workLogEntryIsLocalCodeSearch(entry)) return "code-search";
374	if (entry.itemType === "web_search") return "search";
375	return workLogEntryIsToolLike(entry) ? "other" : "update";
376	}
377
378	function toolGroupActionCount(
379	action: ToolGroupAction,
380	entries: ReadonlyArray<WorkLogEntry>,
381	): number {
382	if (action !== "edit") return entries.length;
383
384	const changedFiles = new Set<string>();
385	let editsWithoutFileDetails = 0;
386	for (const entry of entries) {
387	if (!entry.changedFiles \|\| entry.changedFiles.length === 0) {
388	editsWithoutFileDetails += 1;
389	continue;
390	}
391	for (const file of entry.changedFiles) changedFiles.add(file);
392	}
393	return changedFiles.size + editsWithoutFileDetails;
394	}
395
396	function toolGroupActionLabel(action: ToolGroupAction, count: number): string {
397	switch (action) {
398	case "read":
399	return `Read ${count} ${count === 1 ? "file" : "files"}`;
400	case "edit":
401	return `Changed ${count} ${count === 1 ? "file" : "files"}`;
402	case "command":
403	return `Ran ${count} ${count === 1 ? "command" : "commands"}`;
404	case "search":
405	return `Searched the web ${count} ${count === 1 ? "time" : "times"}`;
406	case "code-search":
407	return `Searched code ${count} ${count === 1 ? "time" : "times"}`;
408	case "other":
409	return `Used ${count} ${count === 1 ? "tool" : "tools"}`;
410	case "update":
411	return `Received ${count} ${count === 1 ? "update" : "updates"}`;
412	}
413	}
414
415	function t3ToolSummaryCall(entry: WorkLogEntry): T3ToolSummaryCall {
416	const item = entry.structuredPayload ?? entry.projectedItem?.item;
417	const data =
418	entry.toolData !== null && typeof entry.toolData === "object"
419	? (entry.toolData as Record<string, unknown>)
420	: undefined;
421	return {
422	input: item?.type === "dynamic_tool" ? item.input : data?.input,
423	output: item?.type === "dynamic_tool" ? item.output : data?.output,
424	// A status/read result may describe a failed child. Only the call's own lifecycle
425	// and MCP error envelope determine whether the orchestration action failed.
426	outcome:
427	entry.toolLifecycleStatus === "failed" \|\|
428	entry.toolLifecycleStatus === "declined" \|\|
429	entry.tone === "error"
430	? "failed"
431	: entry.toolLifecycleStatus === "completed"
432	? "completed"
433	: "unfinished",
434	};
435	}
436
437	function summaryActionPriority(action: ToolGroupAction \| T3McpToolSummaryAction): number {
438	switch (action) {
439	case "command":
440	case "edit":
441	case "delegate":
442	case "task-cancel":
443	case "thread-create":
444	case "thread-send":
445	case "thread-interrupt":
446	case "schedule-create":
447	case "schedule-update":
448	case "schedule-delete":
449	return 0;
450	case "other":
451	case "update":
452	return 2;
453	default:
454	return 1;
455	}
456	}
457
458	/** Summarizes at most two action categories; every omitted call still counts in the remainder. */
459	export function summarizeToolGroup(entries: ReadonlyArray<WorkLogEntry>): {
460	summary: string;
461	hasFailure: boolean;
462	} {
463	const groups = new Map<
464	ToolGroupAction \| T3McpToolSummaryAction,
465	{
466	action: ToolGroupAction;
467	t3Action: T3McpToolSummaryAction \| null;
468	entries: WorkLogEntry[];
469	}
470	>();
471	for (const entry of entries) {
472	const item = entry.structuredPayload ?? entry.projectedItem?.item;
473	const t3Action = resolveT3McpToolSummaryAction(
474	(item?.type === "dynamic_tool" ? item.toolName : null) ?? entry.toolTitle ?? entry.label,
475	);
476	const action = toolGroupAction(entry);
477	const key = t3Action ?? action;
478	const group = groups.get(key);
479	if (group) group.entries.push(entry);
480	else groups.set(key, { action, t3Action, entries: [entry] });
481	}
482	const summaries = [...groups].map(([action, group], index) => ({
483	index,
484	count: group.entries.length,
485	priority: summaryActionPriority(action),
486	...(group.t3Action
487	? summarizeT3ToolCalls(group.t3Action, group.entries.map(t3ToolSummaryCall))
488	: {
489	label: toolGroupActionLabel(
490	group.action,
491	toolGroupActionCount(group.action, group.entries),
492	),
493	failedCount: group.entries.filter(workEntryDisplayIndicatesToolFailure).length,
494	}),
495	}));
496	const selected = summaries
497	.toSorted((a, b) => a.priority - b.priority \|\| a.index - b.index)
498	.slice(0, 2)
499	.sort((a, b) => a.index - b.index);
500	const labels = selected.map(({ label }) => label);
501	const remainingCount = entries.length - selected.reduce((count, group) => count + group.count, 0);
502	if (remainingCount > 0) {
503	labels.push(`Performed ${remainingCount} other ${remainingCount === 1 ? "action" : "actions"}`);
504	}
505	const sentenceLabels = labels.map((label, index) =>
506	index === 0 ? label : label.charAt(0).toLowerCase() + label.slice(1),
507	);
508	const summary =
509	sentenceLabels.length < 3
510	? sentenceLabels.join(" and ")
511	: `${sentenceLabels.slice(0, -1).join(", ")}, and ${sentenceLabels.at(-1)}`;
512	return { summary, hasFailure: summaries.some((group) => group.failedCount > 0) };
513	}
514
515	function toolGroupSummaryKind(entries: ReadonlyArray<WorkLogEntry>): ToolGroupSummaryKind {
516	const actions = new Set(entries.map(toolGroupAction));
517	if (actions.size !== 1) return "mixed";
518
519	const action = actions.values().next().value!;
520	if (action !== "other") return action;
521
522	const fallbackKinds = new Set(
523	entries.map((entry): ToolGroupSummaryKind => {
524	if (entry.itemType === "dynamic_tool") return "dynamic-tool";
525	if (entry.itemType === "subagent") return "agent-tool";
526	if (entry.tone === "thinking") return "agent-tool";
527	if (entry.tone === "tool") return "tone-tool";
528	return "other";
529	}),
530	);
531	return fallbackKinds.size === 1 ? fallbackKinds.values().next().value! : "mixed";
532	}
533
534	function workGroupId(timelineEntryId: string): string {	338	function workGroupId(timelineEntryId: string): string {
535	return `work-group:${timelineEntryId}`;	339	return `work-group:${timelineEntryId}`;
536	}	340	}
@@ -911,21 +715,26 @@ export function deriveMessagesTimelineRows(input: { · 374 unmodified lines
911	const latestRunningToolEntry = visibleActiveToolEntries.findLast((entry) =>	715	const latestRunningToolEntry = visibleActiveToolEntries.findLast((entry) =>
912	workEntryIsActiveTurnActivity(entry.entry),	716	workEntryIsActiveTurnActivity(entry.entry),
913	);	717	);
914	const displayedToolEntry = latestRunningToolEntry ?? latestVisibleToolEntry;	718	const latestToolKeepsActivityLive =
		719	latestRunningToolEntry !== undefined \|\|
		720	(latestVisibleToolEntry !== undefined &&
		721	workEntryIndicatesToolSuccess(latestVisibleToolEntry.entry));
915	const activeWorkPlacementEntryId = latestVisibleToolEntry?.id;	722	const activeWorkPlacementEntryId = latestVisibleToolEntry?.id;
916	const activeWorkRow =	723	const activeWorkRow =
917	activeWorkAnchor && displayedToolEntry	724	activeWorkAnchor && latestVisibleToolEntry
918	? (() => {	725	? (() => {
919	const groupId = workGroupId(activeWorkAnchor.id);	726	const groupId = workGroupId(activeWorkAnchor.id);
920	return {	727	return {
921	kind: "work-live" as const,	728	kind: "work-live" as const,
922	id: `work-live:${activeWorkAnchor.id}`,	729	id: latestToolKeepsActivityLive
		730	? LIVE_ACTIVITY_ROW_ID
		731	: `work-live:${activeWorkAnchor.id}`,
923	createdAt: activeWorkAnchor.createdAt,	732	createdAt: activeWorkAnchor.createdAt,
924	entry: displayedToolEntry.entry,	733	entry: (latestRunningToolEntry ?? latestVisibleToolEntry).entry,
925	groupedEntries: visibleActiveToolEntries.map((entry) => entry.entry),	734	groupedEntries: visibleActiveToolEntries.map((entry) => entry.entry),
926	groupId,	735	groupId,
927	expanded: input.expandedWorkGroupIds?.has(groupId) ?? false,	736	expanded: input.expandedWorkGroupIds?.has(groupId) ?? false,
928	active: latestRunningToolEntry !== undefined,	737	active: latestToolKeepsActivityLive,
929	};	738	};
930	})()	739	})()
931	: null;	740	: null;
@@ -939,11 +748,11 @@ export function deriveMessagesTimelineRows(input: { · 7 unmodified lines
939	createdAt: input.activeTurnStartedAt ?? null,	748	createdAt: input.activeTurnStartedAt ?? null,
940	});	749	});
941	};	750	};
942	let hasLiveWorkRow = false;	751	let hasActivityRow = false;
943	const appendActiveWorkRows = () => {	752	const appendActiveWorkRows = () => {
944	if (activeWorkRow === null) return;	753	if (activeWorkRow === null) return;
945	nextRows.push(activeWorkRow);	754	nextRows.push(activeWorkRow);
946	hasLiveWorkRow \|\|= activeWorkRow.active;	755	hasActivityRow \|\|= activeWorkRow.active;
947	if (!activeWorkRow.expanded) return;	756	if (!activeWorkRow.expanded) return;
948	for (const [entryIndex, workEntry] of activeWorkRow.groupedEntries.entries()) {	757	for (const [entryIndex, workEntry] of activeWorkRow.groupedEntries.entries()) {
949	nextRows.push({	758	nextRows.push({
@@ -1059,7 +868,6 @@ export function deriveMessagesTimelineRows(input: { · 109 unmodified lines
1059	const groupId = workGroupId(timelineEntry.id);	868	const groupId = workGroupId(timelineEntry.id);
1060	const expanded = input.expandedWorkGroupIds?.has(groupId) ?? false;	869	const expanded = input.expandedWorkGroupIds?.has(groupId) ?? false;
1061	const latestActiveToolEntry = activeInProgressToolEntries.at(-1)!;	870	const latestActiveToolEntry = activeInProgressToolEntries.at(-1)!;
1062	hasLiveWorkRow = true;
1063	nextRows.push({	871	nextRows.push({
1064	kind: "work-live",	872	kind: "work-live",
1065	id: `work-live:${timelineEntry.id}`,	873	id: `work-live:${timelineEntry.id}`,
@@ -1070,6 +878,7 @@ export function deriveMessagesTimelineRows(input: { · 4 unmodified lines
1070	expanded,	878	expanded,
1071	active: true,	879	active: true,
1072	});	880	});
		881	hasActivityRow = true;
1073	if (expanded) {	882	if (expanded) {
1074	for (const [entryIndex, workEntry] of visibleGroupedEntries.entries()) {	883	for (const [entryIndex, workEntry] of visibleGroupedEntries.entries()) {
1075	nextRows.push({	884	nextRows.push({
@@ -1192,10 +1001,10 @@ export function deriveMessagesTimelineRows(input: { · 116 unmodified lines
1192	if (input.isWorking && activeTurnHeaderIndex === input.timelineEntries.length) {	1001	if (input.isWorking && activeTurnHeaderIndex === input.timelineEntries.length) {
1193	appendWorkingRow();	1002	appendWorkingRow();
1194	}	1003	}
1195	if (input.isWorking && !hasLiveWorkRow) {	1004	if (input.isWorking && !hasActivityRow) {
1196	nextRows.push({	1005	nextRows.push({
1197	kind: "thinking",	1006	kind: "thinking",
1198	id: "thinking-indicator-row",	1007	id: LIVE_ACTIVITY_ROW_ID,
1199	createdAt: input.activeTurnStartedAt ?? null,	1008	createdAt: input.activeTurnStartedAt ?? null,
1200	});	1009	});
1201	}	1010	}

apps/web/src/components/chat/MessagesTimeline.tsx+7−3

 import ChatMarkdown, { ChatMarkdownAssetImage } from "../ChatMarkdown";
 import {
   BotIcon,
+  BrainIcon,
   CheckIcon,
   ChevronDownIcon,
   ChevronRightIcon,
   // Reserve the activity row during setup so the handoff keeps the same height.
   return (
     <div className="min-h-7">
-      {isPreparingWorktree ? null : <LiveActivityRow label="Thinking" />}
+      {isPreparingWorktree ? null : <LiveActivityRow label="Thinking" iconName="brain" />}
     </div>
   );
 }
 type WorkEntryIconName =
   | "bot"
+  | "brain"
   | "check"
   | "circle-alert"
   | "eye"
   switch (name) {
     case "bot":
       return <BotIcon className={className} aria-hidden />;
+    case "brain":
+      return <BrainIcon className={className} aria-hidden />;
     case "check":
       return <CheckIcon className={className} aria-hidden />;
     case "circle-alert":
   }
   if (tone === "thinking") {
     return {
-      iconName: "bot",
+      iconName: "brain",
-      className: "text-foreground/92",
+      className: "text-foreground",
     };
   }
   if (tone === "info") {

apps/web/src/components/chat/externalLinkContextMenu.test.ts+1−1

       "https://example.com/docs?topic=security#links",
     ],
     ["HTTP://EXAMPLE.COM", "http://example.com/"],
+    ["//example.com/path", "https://example.com/path"],
   ])("resolves the safe external web-link href for %s as %s", (href, expected) => {
     expect(resolveExternalWebLinkHref(href)).toBe(expected);
   });
     "data:text/html,<script>alert(document.domain)</script>",
     "file:///tmp/example.txt",
     "mailto:hello@example.com",
-    "//example.com/path",
     "/relative/path",
     "not a URL",
     "",

apps/web/src/components/settings/SettingsPanels.tsx+2−25

@@ -2254,31 +2254,8 @@ export function GeneralSettingsPanel() { · 2253 unmodified lines
2254	/>	2254	/>
2255	}	2255	}
2256	/>	2256	/>
2257	) : null	2257	) : null}
2258	}	2258	</>
2259	control={
2260	<Switch
2261	checked={settings.sidebarAutoSettleAfterDays !== null}
2262	onCheckedChange={(checked) =>
2263	updateSettings({
2264	sidebarAutoSettleAfterDays: checked ? AUTO_SETTLE_DEFAULT_DAYS : null,
2265	})
2266	}
2267	aria-label="Auto-settle inactive threads"
2268	/>
2269	}
2270	/>
2271	{settings.sidebarAutoSettleAfterDays !== null ? (
2272	<SettingsRow
2273	title={searchableSetting("days-before-auto-settle").title}
2274	description="Any new activity un-settles a thread automatically."
2275	control={
2276	<AutoSettleDaysInput
2277	value={settings.sidebarAutoSettleAfterDays}
2278	onCommit={(days) => updateSettings({ sidebarAutoSettleAfterDays: days })}
2279	/>
2280	}
2281	/>
2282	) : null}	2259	) : null}
2283	</SettingsSection>	2260	</SettingsSection>
2284		2261

apps/web/src/components/settings/settingsSearch.test.ts+21−0

@@ -147,6 +147,7 @@ describe("searchSettings", () => { · 146 unmodified lines
147	hasProviderSettingsEnvironment: false,	147	hasProviderSettingsEnvironment: false,
148	canManageLocalBackend: false,	148	canManageLocalBackend: false,
149	isWslSettingsRowVisible: false,	149	isWslSettingsRowVisible: false,
		150	hasThreadAutoSettlement: false,
150	});	151	});
151		152
152	const gatedIds = new Set<string>([	153	const gatedIds = new Set<string>([
@@ -160,10 +161,30 @@ describe("searchSettings", () => { · 7 unmodified lines
160	"t3-connect",	161	"t3-connect",
161	"tailscale-https",	162	"tailscale-https",
162	"wsl-backend",	163	"wsl-backend",
		164	"auto-settle-inactive-threads",
		165	"auto-settle-merged-threads",
		166	"days-before-auto-settle",
163	]);	167	]);
164	expect(available.map((item) => item.id).filter((id) => gatedIds.has(id))).toEqual([]);	168	expect(available.map((item) => item.id).filter((id) => gatedIds.has(id))).toEqual([]);
165	});	169	});
166		170
		171	it("shows automatic settlement settings when the server supports them", () => {
		172	const available = filterAvailableSettingsSearchItems({
		173	hasCloudPublicConfig: false,
		174	hasPrimaryEnvironment: false,
		175	hasProviderSettingsEnvironment: false,
		176	canManageLocalBackend: false,
		177	isWslSettingsRowVisible: false,
		178	hasThreadAutoSettlement: true,
		179	});
		180
		181	expect(searchSettings("auto-settle", available).map((item) => item.id)).toEqual([
		182	"auto-settle-inactive-threads",
		183	"auto-settle-merged-threads",
		184	"days-before-auto-settle",
		185	]);
		186	});
		187
167	it("keeps catalog result ids unique", () => {	188	it("keeps catalog result ids unique", () => {
168	const ids = SETTINGS_SEARCH_ITEMS.map((item) => item.id);	189	const ids = SETTINGS_SEARCH_ITEMS.map((item) => item.id);
169	expect(new Set(ids).size).toBe(ids.length);	190	expect(new Set(ids).size).toBe(ids.length);

apps/web/src/components/settings/settingsSearch.ts+8−2

   readonly providerSettingsOnly?: boolean;
   readonly localBackendManagementOnly?: boolean;
   readonly wslAvailableOnly?: boolean;
+  readonly requiresThreadAutoSettlement?: boolean;
 }
 export interface SettingsSearchAvailability {
   readonly hasProviderSettingsEnvironment: boolean;
   readonly canManageLocalBackend: boolean;
   readonly isWslSettingsRowVisible: boolean;
+  readonly hasThreadAutoSettlement: boolean;
 }
 /**
     title: "Auto-settle inactive threads",
     to: "/settings/general",
     searchTerms: ["sidebar inactivity days no activity automatically"],
+    requiresThreadAutoSettlement: true,
   },
   {
     id: "auto-settle-merged-threads",
     title: "Auto-settle merged threads",
     to: "/settings/general",
     searchTerms: ["pull request merge closed automatically sidebar"],
+    requiresThreadAutoSettlement: true,
   },
   {
     id: "days-before-auto-settle",
     to: "/settings/general",
     targetId: "auto-settle-inactive-threads",
     searchTerms: ["thread timeout activity sidebar"],
+    requiresThreadAutoSettlement: true,
   },
   {
     id: "time-format",
     id: "quit-confirmation",
     title: "Quit shortcut",
     to: "/settings/general",
-    searchTerms: ["confirmation shortcut desktop app exit"],
+    searchTerms: ["confirmation desktop app exit direct hold double click press twice"],
     desktopOnly: true,
   },
   {
       (!item.primaryOnly || availability.hasPrimaryEnvironment) &&
       (!item.providerSettingsOnly || availability.hasProviderSettingsEnvironment) &&
       (!item.localBackendManagementOnly || availability.canManageLocalBackend) &&
-      (!item.wslAvailableOnly || availability.isWslSettingsRowVisible),
+      (!item.wslAvailableOnly || availability.isWslSettingsRowVisible) &&
+      (!item.requiresThreadAutoSettlement || availability.hasThreadAutoSettlement),
   );
 }

apps/web/src/components/settings/useAvailableSettingsSearchItems.ts+13−1

 import { useMemo } from "react";
+import { useAtomValue } from "@effect/atom-react";
 import { AuthAccessWriteScope } from "@t3tools/contracts";
 import { hasCloudPublicConfig } from "~/cloud/publicConfig";
 import { useEnvironments, usePrimaryEnvironmentId } from "~/state/environments";
 import { useEnvironmentQuery } from "~/state/query";
 import { usePrimarySessionState } from "~/environments/primary";
+import { primaryServerConfigAtom } from "~/state/server";
 import { isWslSettingsRowVisible } from "./ConnectionsSettings.logic";
 import { isProviderSettingsEnvironmentAvailable } from "./ProviderSettingsPanel.logic";
 import { filterAvailableSettingsSearchItems } from "./settingsSearch";
   const primaryEnvironmentId = usePrimaryEnvironmentId();
   const { environments } = useEnvironments();
   const primarySessionState = usePrimarySessionState();
+  const primaryServerConfig = useAtomValue(primaryServerConfigAtom);
   const desktopWsl = useEnvironmentQuery(isElectron ? desktopWslStateAtom : null);
   const canManageLocalBackend =
     isElectron ||
           state: desktopWsl.data,
           error: desktopWsl.error,
         }),
+        hasThreadAutoSettlement:
+          primaryServerConfig?.environment.capabilities.threadAutoSettlement === true,
       }),
-    [canManageLocalBackend, desktopWsl.data, desktopWsl.error, environments, primaryEnvironmentId],
+    [
+      canManageLocalBackend,
+      desktopWsl.data,
+      desktopWsl.error,
+      environments,
+      primaryEnvironmentId,
+      primaryServerConfig,
+    ],
   );
 }

apps/web/src/composerDraftStore.ts+119−0

@@ -45,6 +45,7 @@ import { · 44 unmodified lines
45	type TerminalContextDraft,	45	type TerminalContextDraft,
46	ensureInlineTerminalContextPlaceholders,	46	ensureInlineTerminalContextPlaceholders,
47	normalizeTerminalContextText,	47	normalizeTerminalContextText,
		48	stripInlineTerminalContextPlaceholders,
48	} from "./lib/terminalContext";	49	} from "./lib/terminalContext";
49	import {	50	import {
50	type ElementContextDraft,	51	type ElementContextDraft,
@@ -660,6 +661,13 @@ interface ComposerDraftStoreState { · 609 unmodified lines
660	* prompt stash. Session-bound context stays in the source draft.	661	* prompt stash. Session-bound context stays in the source draft.
661	*/	662	*/
662	clearComposerPromptAndImages: (threadRef: ComposerThreadTarget) => void;	663	clearComposerPromptAndImages: (threadRef: ComposerThreadTarget) => void;
		664	/**
		665	* Moves prompt text and transferable attachments into another composer.
		666	* Attachments over the destination limit and uploaded files that belong to
		667	* another environment stay in the source draft. Terminal and element
		668	* context, preview annotations, and review comments also stay in the source.
		669	*/
		670	moveComposerPromptAndImages: (from: ComposerThreadTarget, to: ComposerThreadTarget) => void;
663	}	671	}
664		672
665	export interface EffectiveComposerModelState {	673	export interface EffectiveComposerModelState {
@@ -3900,6 +3908,117 @@ const composerDraftStore = create<ComposerDraftStoreState>()( · 3234 unmodified lines
3900	return { draftsByThreadKey: nextDraftsByThreadKey };	3908	return { draftsByThreadKey: nextDraftsByThreadKey };
3901	});	3909	});
3902	},	3910	},
		3911	moveComposerPromptAndImages: (from, to) => {
		3912	const fromKey = resolveComposerDraftKey(get(), from) ?? "";
		3913	const toKey = resolveComposerDraftKey(get(), to) ?? "";
		3914	if (fromKey.length === 0 \|\| toKey.length === 0 \|\| fromKey === toKey) {
		3915	return;
		3916	}
		3917	set((state) => {
		3918	const source = state.draftsByThreadKey[fromKey];
		3919	if (!source) {
		3920	return state;
		3921	}
		3922	const destination = state.draftsByThreadKey[toKey] ?? createEmptyThreadDraft();
		3923	const destinationEnvironmentId =
		3924	typeof to === "string"
		3925	? (state.draftThreadsByThreadKey[toKey]?.environmentId ??
		3926	parseScopedThreadKey(toKey)?.environmentId ??
		3927	null)
		3928	: to.environmentId;
		3929	// A file the destination already holds (same id, or same
		3930	// metadata key) stays behind instead of duplicating there.
		3931	const destinationFileIds = new Set(destination.files.map((file) => file.id));
		3932	const destinationFileKeys = new Set(destination.files.map(composerFileDedupKey));
		3933	const transferableFiles = source.files.filter(
		3934	(file) =>
		3935	(file.file !== null \|\| file.uploadEnvironmentId === destinationEnvironmentId) &&
		3936	!destinationFileIds.has(file.id) &&
		3937	!destinationFileKeys.has(composerFileDedupKey(file)),
		3938	);
		3939	const remainingAttachmentSlots = Math.max(
		3940	0,
		3941	PROVIDER_SEND_TURN_MAX_ATTACHMENTS -
		3942	destination.images.length -
		3943	destination.files.length,
		3944	);
		3945	const movedImages = source.images.slice(0, remainingAttachmentSlots);
		3946	const movedImageIds = new Set(movedImages.map((image) => image.id));
		3947	const retainedImages = source.images.filter((image) => !movedImageIds.has(image.id));
		3948	const movedFiles = transferableFiles
		3949	.slice(0, remainingAttachmentSlots - movedImages.length)
		3950	.map((file) => {
		3951	// A byte-backed file moving across environments re-uploads at
		3952	// the destination. Keeping the source-environment upload id
		3953	// would mark it uploaded after a reload with no local bytes
		3954	// and no valid upload anywhere the destination can reach. The
		3955	// upload queue keeps the source upload as fallback, then
		3956	// deletes it after the destination upload succeeds. Abandoned
		3957	// uploads still expire through the server sweep.
		3958	if (
		3959	file.file === null \|\|
		3960	file.uploadEnvironmentId === undefined \|\|
		3961	file.uploadEnvironmentId === destinationEnvironmentId
		3962	) {
		3963	return file;
		3964	}
		3965	const { uploadedAttachmentId: _a, uploadEnvironmentId: _e, ...rest } = file;
		3966	return rest;
		3967	});
		3968	const movedFileIds = new Set(movedFiles.map((file) => file.id));
		3969	const retainedFiles = source.files.filter((file) => !movedFileIds.has(file.id));
		3970	// Inline placeholders reference the source's terminal contexts,
		3971	// which stay behind; re-anchor the moved prompt to whatever
		3972	// contexts the destination already holds.
		3973	const movedPrompt = ensureInlineTerminalContextPlaceholders(
		3974	stripInlineTerminalContextPlaceholders(source.prompt),
		3975	destination.terminalContexts.length,
		3976	);
		3977	const nextDestination: ComposerThreadDraftState = {
		3978	...destination,
		3979	prompt: movedPrompt,
		3980	images: [...destination.images, ...movedImages],
		3981	files: [...destination.files, ...movedFiles],
		3982	nonPersistedImageIds: [
		3983	...destination.nonPersistedImageIds,
		3984	...source.nonPersistedImageIds.filter((imageId) => movedImageIds.has(imageId)),
		3985	],
		3986	persistedAttachments: [
		3987	...destination.persistedAttachments,
		3988	...source.persistedAttachments.filter((attachment) =>
		3989	movedImageIds.has(attachment.id),
		3990	),
		3991	],
		3992	};
		3993	// Same clearing shape as clearComposerPromptAndImages, but the
		3994	// preview URLs are NOT revoked: the images moved and their blobs
		3995	// are still referenced from the destination.
		3996	const nextSource: ComposerThreadDraftState = {
		3997	...source,
		3998	prompt: ensureInlineTerminalContextPlaceholders("", source.terminalContexts.length),
		3999	images: retainedImages,
		4000	files: retainedFiles,
		4001	nonPersistedImageIds: source.nonPersistedImageIds.filter(
		4002	(imageId) => !movedImageIds.has(imageId),
		4003	),
		4004	persistedAttachments: source.persistedAttachments.filter(
		4005	(attachment) => !movedImageIds.has(attachment.id),
		4006	),
		4007	};
		4008	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
		4009	if (shouldRemoveDraft(nextSource)) {
		4010	delete nextDraftsByThreadKey[fromKey];
		4011	} else {
		4012	nextDraftsByThreadKey[fromKey] = nextSource;
		4013	}
		4014	if (shouldRemoveDraft(nextDestination)) {
		4015	delete nextDraftsByThreadKey[toKey];
		4016	} else {
		4017	nextDraftsByThreadKey[toKey] = nextDestination;
		4018	}
		4019	return { draftsByThreadKey: nextDraftsByThreadKey };
		4020	});
		4021	},
3903	};	4022	};
3904	},	4023	},
3905	{	4024	{

apps/web/src/hooks/useHandleNewThread.ts+1−1

@@ -23,7 +23,7 @@ import { · 22 unmodified lines
23	selectProjectGroupingSettings,	23	selectProjectGroupingSettings,
24	} from "../logicalProject";	24	} from "../logicalProject";
25	import { resolveDefaultThreadEnvMode } from "@t3tools/shared/threadEnvMode";	25	import { resolveDefaultThreadEnvMode } from "@t3tools/shared/threadEnvMode";
26	import { readProjects, readThreadShell, useProjects, useThread } from "../state/entities";	26	import { readProjects, readThreadShell, useProjects, useThreadShell } from "../state/entities";
27	import {	27	import {
28	hasExplicitComposerModelSelection,	28	hasExplicitComposerModelSelection,
29	resolveNewDraftStartFromOrigin,	29	resolveNewDraftStartFromOrigin,