diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index b0209754b0d0..729f3e77c4a1 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -106,10 +106,6 @@ import { MediaActions, type MediaActionSource } from "./media/MediaActions";
 import { resolveProtocolRelativeMediaUrl } from "./media/mediaContent";
 import { CHAT_FILE_TAG_CHIP_CLASS_NAME, FileTagChipContent } from "./chat/FileTagChip";
 import { PierreEntryIcon } from "./chat/PierreEntryIcon";
-import {
-  revealInFileExplorerLabelForKind,
-  revealInFileExplorerLabelForOs,
-} from "./preview/fileExplorerLabel";
 import {
   resolveExternalWebLinkHost,
   showExternalLinkContextMenu,
@@ -122,11 +118,7 @@ import { ScrollArea } from "./ui/scroll-area";
 import { Menu, MenuItem, MenuPopup, MenuTrigger } from "./ui/menu";
 import { stackedThreadToast, toastManager } from "./ui/toast";
 import { recordVisitForThread } from "../browserHistoryStore";
-import {
-  PreferredEditorEnvironmentRequiredError,
-  useOpenInPreferredEditor,
-  usePreferredEditor,
-} from "../editorPreferences";
+import { useOpenInPreferredEditor, usePreferredEditor } from "../editorPreferences";
 import { openInEditorMenuLabel } from "../editorLabels";
 import { resolveDiffThemeName, type DiffThemeName } from "../lib/diffRendering";
 import { fnv1a32 } from "../lib/diffRendering";
@@ -156,13 +148,13 @@ import {
   type MarkdownFileLinkMeta,
 } from "../markdown-links";
 import { readLocalApi } from "../localApi";
+import { useFileContextMenu, type FileContextMenuTarget } from "../fileContextMenu";
 import { useAssetUrlRefresh, useAssetUrlState } from "../assets/assetUrls";
 import { cn } from "../lib/utils";
 import { useRemoteOpenResolution, type RemoteOpenMode } from "../remoteOpen";
 import { useRightPanelStore } from "../rightPanelStore";
 import { readThreadShell, useProjects } from "../state/entities";
 import { serverEnvironment } from "../state/server";
-import { shellEnvironment } from "../state/shell";
 import { assetEnvironment } from "../state/assets";
 import { usePreparedConnection } from "../state/session";
 import { previewEnvironment } from "../state/preview";
@@ -184,7 +176,7 @@ import {
 import { useOpenLink } from "../browser/useOpenLink";
 import { writeTextToClipboard } from "../hooks/useCopyToClipboard";
 import { isPreviewSupportedInRuntime } from "../previewStateStore";
-import { isAbsolutePath, resolvePathLinkTarget } from "../terminal-links";
+import { isAbsolutePath } from "../terminal-links";
 import {
   isBrowserPreviewFile,
   openFileInPreview,
@@ -1144,10 +1136,15 @@ interface MarkdownFileLinkProps {
   openInEditorMenuLabel: string;
   onOpenInBrowser?: (() => Promise<AtomCommandResult<unknown, unknown>>) | undefined;
   onOpenMedia?: (() => void) | undefined;
-  onReveal?: (() => Promise<AtomCommandResult<unknown, unknown>>) | undefined;
-  /** Platform-specific menu label ("Reveal in Finder", ...); required for the
-      reveal item to show. */
-  revealLabel?: string | undefined;
+  /** Shared file-menu machinery for reveal and the Open with submenu. */
+  fileMenu?: ReturnType<typeof useFileContextMenu> | undefined;
+  /** Position-stripped path the shared menu acts on; required for it to show. */
+  menuPath?: string | undefined;
+  /** Workspace root the shared menu resolves menuPath against. */
+  menuWorkspaceRoot?: string | undefined;
+  /** Resolves a bare display path (e.g. `ChatView.tsx`) to the indexed
+      workspace path before a shared action runs on it. */
+  resolveMenuPath?: ((filePath: string) => Promise<string | null>) | undefined;
   className?: string | undefined;
 }
 
@@ -1855,8 +1852,10 @@ const MarkdownFileLink = memo(function MarkdownFileLink({
   openInEditorMenuLabel,
   onOpenInBrowser,
   onOpenMedia,
-  onReveal,
-  revealLabel,
+  fileMenu,
+  menuPath,
+  menuWorkspaceRoot,
+  resolveMenuPath,
   className,
 }: MarkdownFileLinkProps) {
   const handleOpenInEditor = useCallback(() => {
@@ -1947,44 +1946,6 @@ const MarkdownFileLink = memo(function MarkdownFileLink({
     })();
   }, [onOpenInBrowser, targetPath]);
 
-  const handleRevealInFileManager = useCallback(() => {
-    if (!onReveal) {
-      return;
-    }
-    void (async () => {
-      try {
-        const result = await onReveal();
-        if (result._tag === "Success" || isAtomCommandInterrupted(result)) {
-          return;
-        }
-        reportMarkdownActionFailure(
-          { operation: "reveal-file-in-file-manager", target: targetPath },
-          result.cause,
-        );
-        const error = squashAtomCommandFailure(result);
-        toastManager.add(
-          stackedThreadToast({
-            type: "error",
-            title: "Unable to reveal file",
-            description: error instanceof Error ? error.message : "An error occurred.",
-          }),
-        );
-      } catch (cause) {
-        reportMarkdownActionFailure(
-          { operation: "reveal-file-in-file-manager", target: targetPath },
-          cause,
-        );
-        toastManager.add(
-          stackedThreadToast({
-            type: "error",
-            title: "Unable to reveal file",
-            description: cause instanceof Error ? cause.message : "An error occurred.",
-          }),
-        );
-      }
-    })();
-  }, [onReveal, targetPath]);
-
   const handleCopy = useCallback(
     (value: string, title: string) => {
       if (typeof window === "undefined" || !navigator.clipboard?.writeText) {
@@ -2029,26 +1990,51 @@ const MarkdownFileLink = memo(function MarkdownFileLink({
       const api = readLocalApi();
       if (!api) return;
 
+      const menuTarget: FileContextMenuTarget | undefined =
+        fileMenu && menuPath
+          ? {
+              environmentId: threadRef?.environmentId ?? null,
+              filePath: menuPath,
+              workspaceRoot: menuWorkspaceRoot,
+            }
+          : undefined;
+      // The chip already renders "Open in <editor>", so the default-app Open
+      // folds into the shared Open with submenu instead of a third open row.
+      const sharedItems = menuTarget
+        ? (fileMenu?.buildItems(menuTarget, { hasPrimaryOpenItem: onOpen !== undefined }) ?? [])
+        : [];
+
       try {
         const clicked = await api.contextMenu.show(
           [
             ...(onOpenMedia ? ([{ id: "preview-media", label: "Preview media" }] as const) : []),
-            ...(onOpen ? ([{ id: "open", label: openInEditorMenuLabel }] as const) : []),
+            ...(onOpen ? ([{ id: "open-editor", label: openInEditorMenuLabel }] as const) : []),
+            ...sharedItems,
             ...(onOpenInBrowser
               ? ([{ id: "open-in-browser", label: "Open in integrated browser" }] as const)
               : []),
-            ...(onReveal && revealLabel ? ([{ id: "reveal", label: revealLabel }] as const) : []),
             { id: "copy-relative", label: "Copy relative path" },
             { id: "copy-full", label: "Copy full path" },
-          ] as const,
+          ],
           position,
         );
 
+        if (clicked === null) return;
+        // "Open with" selections report the child id ("editor:<id>" or the
+        // nested "open"), which is not a top-level item.
+        const sharedClicked = sharedItems
+          .flatMap((item) => [item, ...(item.children ?? [])])
+          .find((item) => item.id === clicked);
+        if (menuTarget && fileMenu && sharedClicked) {
+          const filePath = (await resolveMenuPath?.(menuTarget.filePath)) ?? menuTarget.filePath;
+          await fileMenu.activate(sharedClicked.id, { ...menuTarget, filePath });
+          return;
+        }
         if (clicked === "preview-media") {
           onOpenMedia?.();
           return;
         }
-        if (clicked === "open") {
+        if (clicked === "open-editor") {
           handleOpenInEditor();
           return;
         }
@@ -2056,10 +2042,6 @@ const MarkdownFileLink = memo(function MarkdownFileLink({
           handleOpenInBrowser();
           return;
         }
-        if (clicked === "reveal") {
-          handleRevealInFileManager();
-          return;
-        }
         if (clicked === "copy-relative") {
           handleCopy(displayPath, "Relative path");
           return;
@@ -2076,17 +2058,19 @@ const MarkdownFileLink = memo(function MarkdownFileLink({
     },
     [
       displayPath,
+      fileMenu,
       handleCopy,
       handleOpenInBrowser,
       handleOpenInEditor,
-      handleRevealInFileManager,
+      menuPath,
+      menuWorkspaceRoot,
       onOpenInBrowser,
       onOpenMedia,
       onOpen,
-      onReveal,
       openInEditorMenuLabel,
-      revealLabel,
+      resolveMenuPath,
       targetPath,
+      threadRef,
     ],
   );
 
@@ -2206,8 +2190,10 @@ function areMarkdownFileLinkPropsEqual(
     previous.openInEditorMenuLabel === next.openInEditorMenuLabel &&
     previous.onOpenInBrowser === next.onOpenInBrowser &&
     previous.onOpenMedia === next.onOpenMedia &&
-    previous.onReveal === next.onReveal &&
-    previous.revealLabel === next.revealLabel &&
+    previous.fileMenu === next.fileMenu &&
+    previous.menuPath === next.menuPath &&
+    previous.menuWorkspaceRoot === next.menuWorkspaceRoot &&
+    previous.resolveMenuPath === next.resolveMenuPath &&
     previous.className === next.className
   );
 }
@@ -2301,37 +2287,11 @@ function useChatMarkdownState({
   );
   const serverConfig = useAtomValue(serverEnvironment.configValueAtom(environmentId));
   const projects = useProjects();
-  const availableEditors = serverConfig?.availableEditors ?? [];
+  const availableEditors = useMemo(() => serverConfig?.availableEditors ?? [], [serverConfig]);
   const [preferredEditor] = usePreferredEditor(availableEditors);
   const preferredEditorMenuLabel = openInEditorMenuLabel(preferredEditor);
   const openInPreferredEditor = useOpenInPreferredEditor(environmentId, availableEditors);
-  const openInEditor = useAtomCommand(shellEnvironment.openInEditor, {
-    reportFailure: false,
-  });
-  const revealInFileManagerLabel =
-    environmentId !== null &&
-    serverConfig?.shellRevealInFileManager === true &&
-    serverConfig.availableEditors.includes("file-manager")
-      ? serverConfig.shellRevealInFileManagerKind === undefined
-        ? revealInFileExplorerLabelForOs(serverConfig.environment.platform.os)
-        : revealInFileExplorerLabelForKind(serverConfig.shellRevealInFileManagerKind)
-      : undefined;
-  const revealFileInFileManager = useCallback(
-    (filePath: string) => {
-      if (environmentId === null) {
-        return Promise.resolve(
-          AsyncResult.failure<void, PreferredEditorEnvironmentRequiredError>(
-            Cause.fail(new PreferredEditorEnvironmentRequiredError({ targetPath: filePath })),
-          ),
-        );
-      }
-      return openInEditor({
-        environmentId,
-        input: { cwd: filePath, editor: "file-manager", reveal: true },
-      });
-    },
-    [environmentId, openInEditor],
-  );
+  const fileMenu = useFileContextMenu(environmentId);
   const diffThemeName = resolveDiffThemeName(resolvedTheme);
   const markdownFileLinkMetaByHref = useMemo(() => {
     const metaByHref = new Map<
@@ -2523,17 +2483,6 @@ function useChatMarkdownState({
     },
     [cwd, findWorkspaceBasenameMatch, threadRef],
   );
-  const revealMarkdownFileInFileManager = useCallback(
-    async (fileLinkMeta: MarkdownFileLinkMeta) => {
-      const workspaceRelativePath = fileLinkMeta.workspaceRelativePath;
-      const match = workspaceRelativePath
-        ? await findWorkspaceBasenameMatch(workspaceRelativePath)
-        : null;
-      const filePath = match && cwd ? resolvePathLinkTarget(match, cwd) : fileLinkMeta.filePath;
-      return revealFileInFileManager(filePath);
-    },
-    [cwd, findWorkspaceBasenameMatch, revealFileInFileManager],
-  );
   const fileLinkChip = useCallback(
     (
       fileLinkMeta: MarkdownFileLinkMeta,
@@ -2584,12 +2533,10 @@ function useChatMarkdownState({
               : undefined
           }
           openInEditorMenuLabel={preferredEditorMenuLabel}
-          onReveal={
-            canUseShellActions && revealInFileManagerLabel !== undefined
-              ? () => revealMarkdownFileInFileManager(fileLinkMeta)
-              : undefined
-          }
-          revealLabel={revealInFileManagerLabel}
+          fileMenu={fileMenu}
+          menuPath={fileLinkMeta.workspaceRelativePath ?? fileLinkMeta.filePath}
+          menuWorkspaceRoot={cwd}
+          resolveMenuPath={findWorkspaceBasenameMatch}
           onOpenInBrowser={
             threadRef &&
             isPreviewSupportedInRuntime() &&
@@ -2603,15 +2550,16 @@ function useChatMarkdownState({
     },
     [
       canUseShellActions,
+      cwd,
       fileLinkParentSuffixByPath,
+      fileMenu,
+      findWorkspaceBasenameMatch,
       openFileInPanel,
       openInPreferredEditor,
       openMarkdownFileInPreview,
       openMarkdownMedia,
       preferredEditorMenuLabel,
       resolvedTheme,
-      revealInFileManagerLabel,
-      revealMarkdownFileInFileManager,
       threadRef,
     ],
   );
diff --git a/apps/web/src/components/DiffPanel.tsx b/apps/web/src/components/DiffPanel.tsx
index ca0bdaa7b4d5..f73a0b100f2b 100644
--- a/apps/web/src/components/DiffPanel.tsx
+++ b/apps/web/src/components/DiffPanel.tsx
@@ -26,6 +26,7 @@ import * as Schema from "effect/Schema";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useCodeViewFileReveal } from "./diffs/useCodeViewFileReveal";
 import { useOpenInPreferredEditor } from "../editorPreferences";
+import { useFileContextMenuHandler } from "../fileContextMenu";
 import { type DraftId } from "../composerDraftStore";
 import { openDiffFilePrimaryAction } from "../diffFileActions";
 import { useCheckpointDiff } from "~/lib/checkpointDiffState";
@@ -152,6 +153,7 @@ export default function DiffPanel({
   const serverConfig = useAtomValue(
     serverEnvironment.configValueAtom(activeThread?.environmentId ?? null),
   );
+  const onFileContextMenu = useFileContextMenuHandler(activeThread?.environmentId ?? null);
   const openInPreferredEditor = useOpenInPreferredEditor(
     activeThread?.environmentId ?? null,
     serverConfig?.availableEditors ?? [],
@@ -976,6 +978,39 @@ export default function DiffPanel({
                     );
                     if (file) toggleDiffFileCollapsed(file.fileKey);
                   }}
+                  onContextMenuCapture={(event) => {
+                    const composedPath = event.nativeEvent.composedPath?.() ?? [];
+                    const title = composedPath.find(
+                      (node): node is HTMLElement =>
+                        node instanceof HTMLElement && node.hasAttribute("data-title"),
+                    );
+                    // Metadata and blank header areas have no data-title in
+                    // the click path; fall back to the enclosing header's
+                    // filename like onClickCapture does.
+                    const header = composedPath.find(
+                      (node): node is HTMLElement =>
+                        node instanceof HTMLElement && node.hasAttribute("data-diffs-header"),
+                    );
+                    const filePath = (
+                      title?.textContent ?? header?.querySelector("[data-title]")?.textContent
+                    )?.trim();
+                    if (!filePath) return;
+                    event.preventDefault();
+                    onFileContextMenu(
+                      {
+                        environmentId: activeThread?.environmentId ?? null,
+                        filePath,
+                        // The branch preview can retry at the environment cwd
+                        // when the worktree is rejected; resolve files against
+                        // the cwd the rendered diff actually came from.
+                        workspaceRoot: selectedTurn
+                          ? activeCwd
+                          : (branchDiffPreview.data?.cwd ?? activeCwd),
+                        repositoryRoot: activeRepositoryRoot,
+                      },
+                      event,
+                    );
+                  }}
                 >
                   <AnnotatableCodeView
                     key={collapseScopeKey ?? reviewSectionId}
diff --git a/apps/web/src/components/chat/ChangedFilesTree.tsx b/apps/web/src/components/chat/ChangedFilesTree.tsx
index 5ac9f09613f3..f0cdc0163ce6 100644
--- a/apps/web/src/components/chat/ChangedFilesTree.tsx
+++ b/apps/web/src/components/chat/ChangedFilesTree.tsx
@@ -1,5 +1,5 @@
 import { type TurnId } from "@t3tools/contracts";
-import { memo, useCallback, useMemo, useState } from "react";
+import { type MouseEvent, memo, useCallback, useMemo, useState } from "react";
 import { type TurnDiffFileChange } from "../../types";
 import {
   buildTurnDiffTree,
@@ -22,6 +22,9 @@ import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
 
 const EMPTY_DIRECTORY_OVERRIDES: Record<string, boolean> = {};
 
+/** Opens the OS-level context menu for a changed file (reveal in file manager, open in editor). */
+export type ChangedFileContextMenuHandler = (filePath: string, event: MouseEvent) => void;
+
 export const ChangedFilesCard = memo(function ChangedFilesCard(props: {
   turnId: TurnId;
   files: ReadonlyArray<TurnDiffFileChange>;
@@ -29,6 +32,7 @@ export const ChangedFilesCard = memo(function ChangedFilesCard(props: {
   resolvedTheme: "light" | "dark";
   onToggleAllDirectories: () => void;
   onOpenTurnDiff: (turnId: TurnId, filePath?: string) => void;
+  onFileContextMenu?: ChangedFileContextMenuHandler | undefined;
 }) {
   const {
     turnId,
@@ -37,6 +41,7 @@ export const ChangedFilesCard = memo(function ChangedFilesCard(props: {
     resolvedTheme,
     onToggleAllDirectories,
     onOpenTurnDiff,
+    onFileContextMenu,
   } = props;
   const summaryStat = useMemo(() => summarizeTurnDiffStats(files), [files]);
   const hasDirectories = files.some((file) => /[/\\]/.test(file.path));
@@ -117,6 +122,7 @@ export const ChangedFilesCard = memo(function ChangedFilesCard(props: {
         allDirectoriesExpanded={allDirectoriesExpanded}
         resolvedTheme={resolvedTheme}
         onOpenTurnDiff={onOpenTurnDiff}
+        onFileContextMenu={onFileContextMenu}
       />
     </div>
   );
@@ -128,8 +134,16 @@ export const ChangedFilesTree = memo(function ChangedFilesTree(props: {
   allDirectoriesExpanded: boolean;
   resolvedTheme: "light" | "dark";
   onOpenTurnDiff: (turnId: TurnId, filePath?: string) => void;
+  onFileContextMenu?: ChangedFileContextMenuHandler | undefined;
 }) {
-  const { files, allDirectoriesExpanded, onOpenTurnDiff, resolvedTheme, turnId } = props;
+  const {
+    files,
+    allDirectoriesExpanded,
+    onOpenTurnDiff,
+    resolvedTheme,
+    turnId,
+    onFileContextMenu,
+  } = props;
   const treeNodes = useMemo(() => buildTurnDiffTree(files), [files]);
   const directoryPathsKey = useMemo(
     () => collectDirectoryPaths(treeNodes).join("\u0000"),
@@ -214,6 +228,14 @@ export const ChangedFilesTree = memo(function ChangedFilesTree(props: {
         className="group flex w-full items-center gap-2 rounded-md py-1.5 pr-2 text-left transition-colors hover:bg-accent/60 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-1 focus-visible:ring-offset-background"
         style={{ paddingLeft: `${leftPadding}px` }}
         onClick={() => onOpenTurnDiff(turnId, node.path)}
+        onContextMenu={
+          onFileContextMenu
+            ? (event) => {
+                event.preventDefault();
+                onFileContextMenu(node.path, event);
+              }
+            : undefined
+        }
       >
         {hasDirectoryNodes || depth > 0 ? (
           <span aria-hidden="true" className="size-3.5 shrink-0" />
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index 307a893342f3..e4bf6a7c253d 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -150,6 +150,8 @@ import {
 } from "./SnapShotAttachmentDetails";
 import { ProposedPlanCard } from "./ProposedPlanCard";
 import { ChangedFilesCard } from "./ChangedFilesTree";
+import { useFileContextMenuHandler } from "../../fileContextMenu";
+import { useProject, useThread } from "../../state/entities";
 import {
   CHAT_TIMELINE_ANCHOR_OFFSET,
   timelineContentOverflowsViewport,
@@ -260,6 +262,9 @@ interface TimelineRowSharedState {
   listRef: React.RefObject<LegendListRef | null>;
   timestampFormat: TimestampFormat;
   routeThreadKey: string;
+  // The thread whose rows are currently painted — differs from routeThreadKey
+  // while a held snapshot of the previous thread fills the loading gap.
+  paintedThreadKey: string;
   threadRef: ScopedThreadRef | null;
   markdownCwd: string | undefined;
   resolvedTheme: "light" | "dark";
@@ -917,6 +922,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({
       listRef,
       timestampFormat,
       routeThreadKey,
+      paintedThreadKey: listIdentityKey,
       // Keep Markdown callbacks memoized during unrelated activity updates.
       threadRef: citationThreadRef,
       markdownCwd,
@@ -951,6 +957,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({
       listRef,
       timestampFormat,
       routeThreadKey,
+      listIdentityKey,
       citationThreadRef,
       markdownCwd,
       resolvedTheme,
@@ -2088,7 +2095,7 @@ function AssistantTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "mess
         </AssistantCitationSource>
         <AssistantChangedFilesSection
           turnSummary={row.assistantTurnDiffSummary}
-          routeThreadKey={ctx.routeThreadKey}
+          threadKey={ctx.paintedThreadKey}
           resolvedTheme={ctx.resolvedTheme}
           onOpenTurnDiff={ctx.onOpenTurnDiff}
         />
@@ -2729,12 +2736,12 @@ function WorkGroupToggleTimelineRow({
  *  so toggling re-renders only this component — not the entire list. */
 const AssistantChangedFilesSection = memo(function AssistantChangedFilesSection({
   turnSummary,
-  routeThreadKey,
+  threadKey,
   resolvedTheme,
   onOpenTurnDiff,
 }: {
   turnSummary: TurnDiffSummary | undefined;
-  routeThreadKey: string;
+  threadKey: string;
   resolvedTheme: "light" | "dark";
   onOpenTurnDiff: (turnId: TurnId, filePath?: string) => void;
 }) {
@@ -2746,7 +2753,7 @@ const AssistantChangedFilesSection = memo(function AssistantChangedFilesSection(
     <AssistantChangedFilesSectionInner
       turnSummary={turnSummary}
       checkpointFiles={checkpointFiles}
-      routeThreadKey={routeThreadKey}
+      threadKey={threadKey}
       resolvedTheme={resolvedTheme}
       onOpenTurnDiff={onOpenTurnDiff}
     />
@@ -2758,22 +2765,38 @@ const AssistantChangedFilesSection = memo(function AssistantChangedFilesSection(
 function AssistantChangedFilesSectionInner({
   turnSummary,
   checkpointFiles,
-  routeThreadKey,
+  threadKey,
   resolvedTheme,
   onOpenTurnDiff,
 }: {
   turnSummary: TurnDiffSummary;
   checkpointFiles: TurnDiffSummary["files"];
-  routeThreadKey: string;
+  threadKey: string;
   resolvedTheme: "light" | "dark";
   onOpenTurnDiff: (turnId: TurnId, filePath?: string) => void;
 }) {
+  const ctx = use(TimelineRowCtx);
   const persistedExpanded = useUiStateStore(
-    (store) => store.threadChangedFilesExpandedById[routeThreadKey]?.[turnSummary.turnId],
+    (store) => store.threadChangedFilesExpandedById[threadKey]?.[turnSummary.turnId],
   );
   const setExpanded = useUiStateStore((store) => store.setThreadChangedFilesExpanded);
   const allDirectoriesExpanded = persistedExpanded ?? false;
 
+  // Rows can belong to a held snapshot of the previous thread while the list
+  // settles; bind file actions and expansion state to the painted thread.
+  const paintedThreadRef = useMemo(
+    () => parseScopedThreadKey(threadKey) ?? ctx.threadRef,
+    [threadKey, ctx.threadRef],
+  );
+  const thread = useThread(paintedThreadRef);
+  const project = useProject(
+    thread && thread.projectId
+      ? { environmentId: thread.environmentId, projectId: thread.projectId }
+      : null,
+  );
+  const environmentId = paintedThreadRef?.environmentId ?? ctx.activeThreadEnvironmentId;
+  const onFileContextMenu = useFileContextMenuHandler(environmentId);
+
   return (
     <ChangedFilesCard
       turnId={turnSummary.turnId}
@@ -2781,9 +2804,21 @@ function AssistantChangedFilesSectionInner({
       allDirectoriesExpanded={allDirectoriesExpanded}
       resolvedTheme={resolvedTheme}
       onToggleAllDirectories={() =>
-        setExpanded(routeThreadKey, turnSummary.turnId, !allDirectoriesExpanded)
+        setExpanded(threadKey, turnSummary.turnId, !allDirectoriesExpanded)
       }
       onOpenTurnDiff={onOpenTurnDiff}
+      onFileContextMenu={(filePath, event) =>
+        onFileContextMenu(
+          {
+            environmentId,
+            filePath,
+            workspaceRoot: project?.workspaceRoot ?? ctx.workspaceRoot,
+            repositoryRoot:
+              thread?.worktreePath == null ? project?.repositoryIdentity?.rootPath : undefined,
+          },
+          event,
+        )
+      }
     />
   );
 }
diff --git a/apps/web/src/components/files/FileBrowserPanel.tsx b/apps/web/src/components/files/FileBrowserPanel.tsx
index 750fa3c7d191..4b4a1daacc90 100644
--- a/apps/web/src/components/files/FileBrowserPanel.tsx
+++ b/apps/web/src/components/files/FileBrowserPanel.tsx
@@ -17,6 +17,7 @@ import { useComposerHandleContext } from "~/composerHandleContext";
 import { writeTextToClipboard } from "~/hooks/useCopyToClipboard";
 import { useTheme } from "~/hooks/useTheme";
 import { useWorkspaceMutationRefresh } from "~/hooks/useWorkspaceMutationRefresh";
+import { useFileContextMenu, type FileContextMenuAction } from "~/fileContextMenu";
 import { readLocalApi } from "~/localApi";
 import { T3_PIERRE_ICONS } from "~/pierre-icons";
 import { PIERRE_TREE_UNSAFE_CSS, pierreTreeStyle } from "~/pierre-tree-theme";
@@ -105,6 +106,7 @@ export default function FileBrowserPanel({
 }: FileBrowserPanelProps) {
   const { resolvedTheme } = useTheme();
   const composerRef = useComposerHandleContext();
+  const fileContextMenu = useFileContextMenu(environmentId);
   const {
     entries: directoryEntries,
     load,
@@ -157,6 +159,7 @@ export default function FileBrowserPanel({
     return () => document.removeEventListener("contextmenu", capturePointer, true);
   }, []);
 
+  /** Combines the file actions (open/reveal/open with) with the panel's own mention actions. */
   const showEntryContextMenu = async (
     item: TreeContextMenuItem,
     context: TreeContextMenuOpenContext,
@@ -174,14 +177,26 @@ export default function FileBrowserPanel({
     const position = pointerIsFresh
       ? { x: pointer.x, y: pointer.y }
       : { x: anchorRect.left, y: anchorRect.bottom };
+    const fileTarget = { environmentId, filePath: relativePath, workspaceRoot: cwd };
+    const fileMenuItems = fileContextMenu.buildItems(fileTarget);
     try {
       const clicked = await api.contextMenu.show(
         [
+          ...fileMenuItems,
           { id: "copy-mention", label: "Copy mention" },
           { id: "add-to-chat", label: "Add to chat" },
         ],
         position,
       );
+      if (clicked === null) return;
+      // "Open with" submenu selections report the child id ("editor:<id>"),
+      // which is not present in the top-level item list.
+      const isFileMenuAction =
+        fileMenuItems.some((entry) => entry.id === clicked) || clicked.startsWith("editor:");
+      if (isFileMenuAction) {
+        await fileContextMenu.activate(clicked as FileContextMenuAction, fileTarget);
+        return;
+      }
       if (clicked === "copy-mention") {
         try {
           await writeTextToClipboard(mention);
diff --git a/apps/web/src/fileContextMenu.test.ts b/apps/web/src/fileContextMenu.test.ts
new file mode 100644
index 000000000000..5c14dafb47a0
--- /dev/null
+++ b/apps/web/src/fileContextMenu.test.ts
@@ -0,0 +1,178 @@
+import { EnvironmentId } from "@t3tools/contracts";
+import * as NodeAssert from "node:assert/strict";
+import { describe, expect, it } from "vite-plus/test";
+
+import { buildFileContextMenuItems, resolveFileContextMenuAbsolutePath } from "./fileContextMenu";
+
+const BASE_TARGET = {
+  environmentId: EnvironmentId.make("environment-local"),
+  filePath: "src/index.ts",
+  workspaceRoot: "/workspace/project",
+};
+
+describe("resolveFileContextMenuAbsolutePath", () => {
+  it("joins workspace-relative diff paths onto the workspace root", () => {
+    expect(resolveFileContextMenuAbsolutePath(BASE_TARGET)).toBe("/workspace/project/src/index.ts");
+  });
+
+  it("strips the repository prefix when the repo root is nested in the workspace", () => {
+    expect(
+      resolveFileContextMenuAbsolutePath({
+        ...BASE_TARGET,
+        workspaceRoot: "/workspace/project/packages/app",
+        repositoryRoot: "/workspace/project",
+        filePath: "packages/app/src/index.ts",
+      }),
+    ).toBe("/workspace/project/packages/app/src/index.ts");
+  });
+
+  it("returns null for paths outside the workspace when a repository root is set", () => {
+    expect(
+      resolveFileContextMenuAbsolutePath({
+        ...BASE_TARGET,
+        workspaceRoot: "/workspace/project/packages/app",
+        repositoryRoot: "/workspace/project",
+        filePath: "other/src/index.ts",
+      }),
+    ).toBeNull();
+  });
+
+  it("passes absolute environment-host paths through unchanged", () => {
+    expect(
+      resolveFileContextMenuAbsolutePath({
+        ...BASE_TARGET,
+        filePath: "/absolute/src/index.ts",
+      }),
+    ).toBe("/absolute/src/index.ts");
+    expect(
+      resolveFileContextMenuAbsolutePath({
+        ...BASE_TARGET,
+        workspaceRoot: undefined,
+        filePath: "C:\\temp\\report.pdf",
+      }),
+    ).toBe("C:\\temp\\report.pdf");
+  });
+
+  it("returns null for relative paths without a workspace root, matching diff path resolution", () => {
+    expect(
+      resolveFileContextMenuAbsolutePath({
+        ...BASE_TARGET,
+        workspaceRoot: undefined,
+        filePath: "src/index.ts",
+      }),
+    ).toBeNull();
+  });
+
+  it("does not treat drive-relative Windows paths as absolute", () => {
+    // C:notes.md is relative to the current directory on C:, so it cannot
+    // pass through as an environment-host path or resolve to a workspace file.
+    expect(
+      resolveFileContextMenuAbsolutePath({
+        ...BASE_TARGET,
+        workspaceRoot: undefined,
+        filePath: "C:notes.md",
+      }),
+    ).toBeNull();
+    expect(
+      resolveFileContextMenuAbsolutePath({
+        ...BASE_TARGET,
+        filePath: "C:src\\index.ts",
+      }),
+    ).toBeNull();
+  });
+
+  it("passes UNC environment-host paths through unchanged", () => {
+    expect(
+      resolveFileContextMenuAbsolutePath({
+        ...BASE_TARGET,
+        filePath: "\\\\server\\share\\report.pdf",
+      }),
+    ).toBe("\\\\server\\share\\report.pdf");
+  });
+});
+
+describe("buildFileContextMenuItems", () => {
+  it("offers open, reveal, and an open-with submenu when all are available", () => {
+    const items = buildFileContextMenuItems({
+      hasAbsolutePath: true,
+      capabilities: {
+        revealLabel: "Reveal in Finder",
+        canOpenDefault: true,
+        editorIds: ["vscode", "cursor", "file-manager"],
+      },
+    });
+
+    expect(items.map((item) => item.id)).toEqual(["open", "reveal-in-folder", "open-with"]);
+    expect(items[0]).toMatchObject({ label: "Open" });
+    expect(items[1]).toMatchObject({ label: "Reveal in Finder" });
+    const openWith = items[2];
+    NodeAssert.ok(openWith);
+    expect(openWith.children?.map((child) => child.id)).toEqual(["editor:vscode", "editor:cursor"]);
+  });
+
+  it("offers only the reveal item when just reveal is enabled", () => {
+    const items = buildFileContextMenuItems({
+      hasAbsolutePath: true,
+      capabilities: {
+        revealLabel: "Reveal in File Explorer",
+        canOpenDefault: false,
+        editorIds: [],
+      },
+    });
+
+    expect(items.map((item) => item.id)).toEqual(["reveal-in-folder"]);
+    expect(items[0]).toMatchObject({ label: "Reveal in File Explorer" });
+  });
+
+  it("folds the default-app open into Open with when the caller has its own open row", () => {
+    const items = buildFileContextMenuItems({
+      hasAbsolutePath: true,
+      hasPrimaryOpenItem: true,
+      capabilities: {
+        revealLabel: "Reveal in Finder",
+        canOpenDefault: true,
+        editorIds: ["vscode", "cursor", "file-manager"],
+      },
+    });
+
+    expect(items.map((item) => item.id)).toEqual(["reveal-in-folder", "open-with"]);
+    const openWith = items[1];
+    NodeAssert.ok(openWith);
+    expect(openWith.children?.map((child) => child.id)).toEqual([
+      "open",
+      "editor:vscode",
+      "editor:cursor",
+    ]);
+    expect(openWith.children?.[0]).toMatchObject({ label: "Default Application" });
+  });
+
+  it("drops the default-app open entirely when the caller's row already covers it", () => {
+    // With no editors detected, the caller's "Open in editor" opens the
+    // default app through preferred-editor resolution, so a shared Open row
+    // would be a duplicate.
+    const items = buildFileContextMenuItems({
+      hasAbsolutePath: true,
+      hasPrimaryOpenItem: true,
+      capabilities: {
+        revealLabel: "Reveal in Finder",
+        canOpenDefault: true,
+        editorIds: ["file-manager"],
+      },
+    });
+
+    expect(items.map((item) => item.id)).toEqual(["reveal-in-folder"]);
+  });
+
+  it("offers nothing when the path cannot be resolved", () => {
+    expect(
+      buildFileContextMenuItems({
+        hasAbsolutePath: false,
+        capabilities: {
+          revealLabel: "Reveal in Finder",
+          canOpenDefault: true,
+          editorIds: ["vscode"],
+        },
+      }),
+    ).toEqual([]);
+  });
+});
diff --git a/apps/web/src/fileContextMenu.ts b/apps/web/src/fileContextMenu.ts
new file mode 100644
index 000000000000..6bb674e3224d
--- /dev/null
+++ b/apps/web/src/fileContextMenu.ts
@@ -0,0 +1,230 @@
+/**
+ * Right-click actions for a workspace file: reveal it in the environment's
+ * file manager and open it in an editor. Reuse the chat file-chip menu's
+ * machinery: reveal rides `shell.openInEditor` with `reveal: true`, which the
+ * server only honors when its `shellRevealInFileManager` config flag is set,
+ * so both actions work for every client and connection mode.
+ */
+import {
+  EDITORS,
+  type ContextMenuItem,
+  type EditorId,
+  type EnvironmentId,
+} from "@t3tools/contracts";
+import { useCallback, useMemo } from "react";
+
+import { resolveDiffPathForWorkspace } from "./diffFileActions";
+import {
+  revealInFileExplorerLabelForKind,
+  revealInFileExplorerLabelForOs,
+} from "~/components/preview/fileExplorerLabel";
+import { readLocalApi } from "./localApi";
+import { serverEnvironment } from "./state/server";
+import { shellEnvironment } from "./state/shell";
+import { useAtomCommand } from "./state/use-atom-command";
+import { isAbsolutePath, resolvePathLinkTarget } from "./terminal-links";
+import { toastManager } from "./components/ui/toast";
+import { useAtomValue } from "@effect/atom-react";
+
+export type FileContextMenuAction =
+  | "reveal-in-folder"
+  | "open"
+  /** Submenu parent; never the activated id. */
+  | "open-with"
+  | `editor:${EditorId}`;
+
+export interface FileContextMenuTarget {
+  readonly environmentId: EnvironmentId | null;
+  /**
+   * Repo- or workspace-relative path (as shown in diffs), or an absolute
+   * environment-host path (as carried by markdown file links pointing outside
+   * the workspace).
+   */
+  readonly filePath: string;
+  readonly workspaceRoot: string | undefined;
+  readonly repositoryRoot?: string | undefined;
+}
+
+/**
+ * Absolute path on the environment host for a diff-style target, resolving
+ * repo-relative paths through the workspace root like every other diff
+ * surface. Returns null when the path cannot be resolved, which callers must
+ * treat as "no file actions available".
+ */
+export function resolveFileContextMenuAbsolutePath(target: FileContextMenuTarget): string | null {
+  // Markdown file links can point outside the workspace with an absolute
+  // environment-host path; there is nothing to resolve. isAbsolutePath needs
+  // a separator after a drive colon, so drive-relative C:notes.md is treated
+  // as workspace-relative, and UNC shares pass through.
+  if (isAbsolutePath(target.filePath)) return target.filePath;
+  const workspaceFilePath = resolveDiffPathForWorkspace({
+    filePath: target.filePath,
+    workspaceRoot: target.workspaceRoot,
+    repositoryRoot: target.repositoryRoot,
+  });
+  if (workspaceFilePath === null) return null;
+  if (target.workspaceRoot === undefined) {
+    return isAbsolutePath(workspaceFilePath) ? workspaceFilePath : null;
+  }
+  return resolvePathLinkTarget(workspaceFilePath, target.workspaceRoot);
+}
+
+const EDITOR_LABEL_BY_ID = new Map(EDITORS.map((editor) => [editor.id, editor.label]));
+
+export interface FileContextMenuCapabilities {
+  readonly revealLabel: string | undefined;
+  readonly canOpenDefault: boolean;
+  readonly editorIds: ReadonlyArray<EditorId>;
+}
+
+/**
+ * Menu items for a resolved file, offering only what the environment's config
+ * advertises: default-app open, reveal (with server-provided wording), and an
+ * "Open with" submenu of detected editors. Empty when nothing can act.
+ */
+export function buildFileContextMenuItems(input: {
+  readonly hasAbsolutePath: boolean;
+  readonly capabilities: FileContextMenuCapabilities;
+  /**
+   * Set when the caller already renders its own top-level open row (the file
+   * chip's "Open in <editor>"). The default-app Open folds into "Open with"
+   * so the menu keeps one primary open action plus alternatives.
+   */
+  readonly hasPrimaryOpenItem?: boolean;
+}): readonly ContextMenuItem<FileContextMenuAction>[] {
+  // Without a resolvable absolute path nothing here can act on the file.
+  if (!input.hasAbsolutePath) return [];
+  const items: ContextMenuItem<FileContextMenuAction>[] = [];
+  const editorIds = input.capabilities.editorIds.filter((id) => id !== "file-manager");
+  // With no submenu to fold into, the caller's own open row already reaches
+  // the default app through preferred-editor resolution — a second Open row
+  // would do the same thing.
+  const hasOwnOpen = input.hasPrimaryOpenItem === true;
+  const nestDefaultOpen = hasOwnOpen && input.capabilities.canOpenDefault && editorIds.length > 0;
+  if (input.capabilities.canOpenDefault && !hasOwnOpen) {
+    items.push({ id: "open", label: "Open", icon: "pencil" });
+  }
+  if (input.capabilities.revealLabel !== undefined) {
+    items.push({
+      id: "reveal-in-folder",
+      label: input.capabilities.revealLabel,
+      icon: "folder-tree",
+    });
+  }
+  if (editorIds.length > 0) {
+    items.push({
+      id: "open-with",
+      label: "Open with",
+      children: [
+        ...(nestDefaultOpen ? ([{ id: "open", label: "Default Application" }] as const) : []),
+        ...editorIds.map((editorId) => ({
+          id: `editor:${editorId}` as FileContextMenuAction,
+          label: EDITOR_LABEL_BY_ID.get(editorId) ?? editorId,
+        })),
+      ],
+    });
+  }
+  return items;
+}
+
+/**
+ * Context-menu actions for files. The environment id is fixed per component
+ * (a thread's environment, a file browser's environment), so capabilities
+ * resolve once per hook call.
+ */
+/** Builds and dispatches the file context menu for one environment's files. */
+export function useFileContextMenu(environmentId: EnvironmentId | null) {
+  const openInEditor = useAtomCommand(shellEnvironment.openInEditor, { reportFailure: false });
+  const serverConfig = useAtomValue(serverEnvironment.configValueAtom(environmentId));
+
+  return useMemo(() => {
+    const availableEditors = serverConfig?.availableEditors ?? [];
+    const capabilities: FileContextMenuCapabilities = {
+      // The reveal wording comes from the server because on WSL the reveal can
+      // run through Windows File Explorer even though the host reports Linux.
+      revealLabel:
+        environmentId !== null &&
+        serverConfig?.shellRevealInFileManager === true &&
+        serverConfig.availableEditors.includes("file-manager")
+          ? serverConfig.shellRevealInFileManagerKind === undefined
+            ? revealInFileExplorerLabelForOs(serverConfig.environment.platform.os)
+            : revealInFileExplorerLabelForKind(serverConfig.shellRevealInFileManagerKind)
+          : undefined,
+      canOpenDefault: availableEditors.includes("file-manager"),
+      editorIds: availableEditors,
+    };
+
+    const activate = async (
+      action: FileContextMenuAction,
+      target: FileContextMenuTarget,
+    ): Promise<void> => {
+      const absolutePath = resolveFileContextMenuAbsolutePath(target);
+      if (absolutePath === null || environmentId === null) return;
+
+      const reveal = action === "reveal-in-folder";
+      const editor =
+        action === "open" || reveal
+          ? ("file-manager" as const)
+          : (action.slice("editor:".length) as EditorId);
+      if (action !== "open" && !reveal && !capabilities.editorIds.includes(editor)) return;
+
+      const result = await openInEditor({
+        environmentId,
+        input: { cwd: absolutePath, editor, ...(reveal ? { reveal: true } : {}) },
+      });
+      if (result._tag !== "Failure") return;
+      toastManager.add({
+        type: "error",
+        title:
+          action === "open"
+            ? "Could not open file"
+            : reveal
+              ? "Unable to reveal file"
+              : `Could not open in ${EDITOR_LABEL_BY_ID.get(editor) ?? editor}`,
+        description: absolutePath,
+      });
+    };
+
+    const show = async (
+      target: FileContextMenuTarget,
+      position?: { x: number; y: number },
+    ): Promise<void> => {
+      const api = readLocalApi();
+      const items = buildFileContextMenuItems({
+        hasAbsolutePath: resolveFileContextMenuAbsolutePath(target) !== null,
+        capabilities,
+      });
+      if (items.length === 0 || api === undefined) return;
+      const clicked = await api.contextMenu.show(items, position);
+      if (clicked === null) return;
+      await activate(clicked as FileContextMenuAction, target);
+    };
+
+    return {
+      buildItems: (
+        target: FileContextMenuTarget,
+        options?: { readonly hasPrimaryOpenItem?: boolean },
+      ) =>
+        buildFileContextMenuItems({
+          hasAbsolutePath: resolveFileContextMenuAbsolutePath(target) !== null,
+          capabilities,
+          ...options,
+        }),
+      capabilities,
+      activate,
+      show,
+    };
+  }, [environmentId, openInEditor, serverConfig]);
+}
+
+/** Convenience callback for onContextMenu handlers. */
+/** Returns an onContextMenu callback that shows the menu at the pointer. */
+export function useFileContextMenuHandler(environmentId: EnvironmentId | null) {
+  const contextMenu = useFileContextMenu(environmentId);
+  return useCallback(
+    (target: FileContextMenuTarget, event?: { clientX: number; clientY: number }) => {
+      void contextMenu.show(target, event ? { x: event.clientX, y: event.clientY } : undefined);
+    },
+    [contextMenu],
+  );
+}
diff --git a/docs/internals/file-context-menus.md b/docs/internals/file-context-menus.md
new file mode 100644
index 000000000000..b86064d54041
--- /dev/null
+++ b/docs/internals/file-context-menus.md
@@ -0,0 +1,53 @@
+# File context menus
+
+> For maintainers. Using T3 Code? See [docs/user](../user/).
+
+Every surface that shows a workspace file — as a chip, a row, or a tree node — must offer the
+shared file context menu on right-click. The menu is how a user bridges from the app to their own
+tools, so a file surface without it dead-ends: the user can see the file but cannot reach Finder,
+Explorer, or their editor.
+
+## The rule
+
+A file surface's context menu must include, when the environment supports them:
+
+- **Show in Finder / Explorer / Files** — reveals the file on the environment host, server-side,
+  so it works over local, remote, and tunnel connections.
+- **Open** — opens the file with the host's default application. When a surface already renders
+  its own primary open row (a markdown chip's "Open in \<editor\>"), this folds into the Open
+  with submenu as "Default Application" so the menu keeps one top-level open action.
+- **Open with** — a submenu of the environment's detected editors, with remote deep links when
+  this client is not on the environment's machine.
+
+The menu may add surface-specific items around the shared ones (a diff panel adds diff actions, a
+markdown chip adds preview and copy actions), but the shared items are never dropped and never
+reimplemented with different behavior.
+
+## The mechanism
+
+`apps/web/src/fileContextMenu.ts` owns the menu. `useFileContextMenu(environmentId)` resolves
+capabilities once per environment (detected editors, the server's `shellRevealInFileManager`
+gate and its reveal wording, remote-open mode), and returns `buildItems` and `activate`.
+`useFileContextMenuHandler(environmentId)` wraps them into an `onContextMenu` callback.
+
+To cover a new surface:
+
+1. Build a `FileContextMenuTarget`: an absolute environment-host path or a repo/workspace-relative
+   path, plus the `workspaceRoot` (and `repositoryRoot` for repo-relative paths inside a nested
+   worktree) needed to resolve it.
+2. Wire the surface's right-click (and click-with-no-other-primary-action, for chips that are not
+   links) to `useFileContextMenuHandler` or, when the surface has extra items of its own, call
+   `buildItems` and `activate` around them the way `MarkdownFileLink` does.
+3. Do not fork the actions. If a surface needs a variation, change `fileContextMenu.ts` so every
+   surface benefits.
+
+## Covered surfaces
+
+- Chat changed-files tree and activity rows (`ChangedFilesTree`, `MessagesTimeline`).
+- Diff panel file headers (`DiffPanel`).
+- Workspace file browser (`FileBrowserPanel`).
+- Markdown file-link chips in messages and previews (`MarkdownFileLink` in `ChatMarkdown`).
+
+Not covered yet, tracked as follow-ups: composer file-mention chips (they live inside the Lexical
+editor and need environment context threaded into the decorator) and mobile, which has no
+right-click; long-press there should eventually map to the same menu.
diff --git a/docs/internals/glossary.md b/docs/internals/glossary.md
index 019c9d53023a..6c0aa0f6f6e0 100644
--- a/docs/internals/glossary.md
+++ b/docs/internals/glossary.md
@@ -64,3 +64,10 @@ Terms whose meaning matters across T3 Code. Architecture and lifecycle constrain
 | Attachment inventory | The ordered image records shown as thumbnails above the prose, including images with no inline references.                          |
 
 See [composer context references](./composer-context-references.md) for the contract and lifecycle.
+
+## File surfaces
+
+| Term              | Meaning                                                                                                                                                           |
+| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| File chip         | An inline, clickable file path rendered as a pill in chat markdown, activity, or the composer. Not every file surface is a chip.                                  |
+| File context menu | The shared right-click menu for any shown workspace file: reveal in the file manager and an Open with submenu. See [file context menus](./file-context-menus.md). |