@@ -1,12 +1,41 @@
 import { describe, expect, it } from "vite-plus/test";
 
 import {
+  expandHomeFilePath,
   fileRoutePathSegments,
   isSvgImagePreviewFile,
   resolveWorkspaceRelativeFilePath,
   fileHeaderSubtitle,
 } from "./filePath";
 
+describe("expandHomeFilePath", () => {
+  it.each([
+    ["/Users/tommy/repo", "/Users/tommy/.zshrc"],
+    ["/home/tommy/repo", "/home/tommy/.zshrc"],
+    ["C:\\Users\\tommy\\repo", "C:\\Users\\tommy\\.zshrc"],
+  ])("expands host-home paths inferred from %s", (workspaceRoot, expected) => {
+    expect(expandHomeFilePath("~/.zshrc", workspaceRoot)).toBe(expected);
+  });
+
+  it.each([null, undefined, "/repo"])(
+    "keeps home paths when home cannot be inferred from %s",
+    (root) => {
+      expect(expandHomeFilePath("~/.zshrc", root)).toBe("~/.zshrc");
+    },
+  );
+
+  it.each(["src/app.ts", "/tmp/report.md"])("preserves existing file paths: %s", (path) => {
+    expect(expandHomeFilePath(path, "/Users/tommy/repo")).toBe(path);
+  });
+
+  it("routes a home path inside the workspace as a workspace file", () => {
+    const root = "/Users/tommy/repo";
+    expect(
+      resolveWorkspaceRelativeFilePath(root, expandHomeFilePath("~/repo/src/app.ts", root)),
+    ).toBe("src/app.ts");
+  });
+});
+
 describe("fileRoutePathSegments", () => {
   it("round-trips workspace-relative and host paths through the route", () => {
     expect(fileRoutePathSegments("src/main.ts")).toEqual(["src", "main.ts"]);
 
@@ -1,3 +1,4 @@
+import { resolvePathLinkTarget } from "@t3tools/shared/fileLinks";
 import {
   isWorkspaceAudioPreviewPath,
   isWorkspaceVideoPreviewPath,
@@ -18,6 +19,11 @@ export function isAbsolutePath(value: string): boolean {
   return value.startsWith("/") || isWindowsAbsolutePath(value);
 }
 
+/** Expand host-home paths using the same workspace-root inference as web. */
+export function expandHomeFilePath(path: string, workspaceRoot: string | null | undefined): string {
+  return workspaceRoot && path.startsWith("~/") ? resolvePathLinkTarget(path, workspaceRoot) : path;
+}
+
 /** Route segments that `normalizeRoutePath` joins back into the same path, root included. */
 export function fileRoutePathSegments(path: string): string[] {
   const segments = path.split("/").filter((segment) => segment.length > 0);
 
@@ -213,6 +213,7 @@ import { useAtomCommand } from "../../state/use-atom-command";
 import { useV2ItemSupport } from "../../state/v2-item-support";
 import {
   basename,
+  expandHomeFilePath,
   fileRoutePathSegments,
   isAbsolutePath,
   resolveWorkspaceRelativeFilePath,
@@ -2343,7 +2344,14 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
         });
         return;
       }
-      const presentation = resolveMarkdownLinkPresentation(href);
+      const linkPresentation = resolveMarkdownLinkPresentation(href);
+      const presentation =
+        linkPresentation.kind === "file"
+          ? {
+              ...linkPresentation,
+              path: expandHomeFilePath(linkPresentation.path, props.workspaceRoot),
+            }
+          : linkPresentation;
       if (presentation.kind === "file") {
         const relativePath = resolveWorkspaceRelativeFilePath(
           props.workspaceRoot,
 
@@ -17,6 +17,26 @@ describe("resolveFileChipTarget", () => {
     });
   });
 
+  it("expands home paths outside the workspace and strips their position suffix", () => {
+    const target = resolveFileChipTarget("~/.agents/AGENTS.md:4:2", "/Users/tommy/repo");
+    expect(target).toEqual({ fullPath: "/Users/tommy/.agents/AGENTS.md" });
+    expect(fileChipMenu(target!).actions).toEqual([
+      { id: "copy-full-path", title: "Copy full path" },
+      { id: "open-file", title: "Open in file viewer" },
+    ]);
+  });
+
+  it("resolves home paths inside the workspace to both paths", () => {
+    expect(resolveFileChipTarget("~/repo/src/app.ts", "/Users/tommy/repo")).toEqual({
+      fullPath: "/Users/tommy/repo/src/app.ts",
+      relativePath: "src/app.ts",
+    });
+  });
+
+  it.each([null, undefined, "/repo"])("rejects home paths without a known home for %s", (root) => {
+    expect(resolveFileChipTarget("~/.zshrc", root)).toBeNull();
+  });
+
   it("keeps only the relative path when the workspace root is unknown", () => {
     expect(resolveFileChipTarget("src/app.ts", null)).toEqual({ relativePath: "src/app.ts" });
   });
 
@@ -5,6 +5,7 @@ import type { MarkdownFileContextMenu } from "@t3tools/mobile-markdown-text/type
 import { hostPreviewMimeTypeFromExtension } from "@t3tools/shared/filePreview";
 
 import {
+  expandHomeFilePath,
   isAbsolutePath,
   resolveWorkspaceFilePath,
   resolveWorkspaceRelativeFilePath,
@@ -19,16 +20,17 @@ export interface FileChipTarget {
   readonly relativePath?: string;
 }
 
-/** Null when the link is not a file or resolves nowhere the feed can open, such as `~/x` or `../x`. */
+/** Null when the link is not a file or resolves nowhere the feed can open, such as `../x`. */
 export function resolveFileChipTarget(
   href: string,
   workspaceRoot: string | null | undefined,
 ): FileChipTarget | null {
   const presentation = resolveMarkdownLinkPresentation(href);
   if (presentation.kind !== "file") return null;
-  const relativePath = resolveWorkspaceRelativeFilePath(workspaceRoot, presentation.path);
-  const fullPath = isAbsolutePath(presentation.path)
-    ? presentation.path
+  const path = expandHomeFilePath(presentation.path, workspaceRoot);
+  const relativePath = resolveWorkspaceRelativeFilePath(workspaceRoot, path);
+  const fullPath = isAbsolutePath(path)
+    ? path
     : workspaceRoot && relativePath
       ? resolveWorkspaceFilePath(workspaceRoot, relativePath)
       : undefined;