cli-jaw 2.2.3 → 2.2.4-preview.20260703203439

package/public/manager/src/SidebarRailRouter.tsx

@@ -11,6 +11,7 @@ import { RightSidebar } from './panels/RightSidebar';
 import { BottomPanel, type BottomPanelRenderControls } from './panels/BottomPanel';
 import { usePanelLayout } from './panels/PanelLayoutProvider';
 import { currentManagerSurface } from './panels/panel-capabilities';
+import { getDesktop } from './panels/desktop-bridge';
 import type { RightPanelMode, BottomPanelTab } from './panels/types';
 import type { FolderPanelSessionState } from './folder-panel/folder-panel-session';
 import type { WorkbenchRepoRootMode } from './workbench/workbench-resource-types';
@@ -65,7 +66,6 @@ import { ModeSwitch } from './code/ModeSwitch';
 const CodeCanvas = lazy(() => import('./code/CodeCanvas').then(m => ({ default: m.CodeCanvas })));
 import './code/code.css';
 import { useWorkbenchResourceState } from './workbench/useWorkbenchResourceState';
-import { WorkerProgressMonitorPanel } from './workers/WorkerProgressMonitorPanel';
 
 type WorkspaceSurfaceProps = {
     active: boolean;
@@ -76,6 +76,12 @@ function WorkspaceSurface(props: WorkspaceSurfaceProps) {
     return <section className={`workspace-surface${props.active ? ' is-active' : ''}`} hidden={!props.active} aria-hidden={!props.active}>{props.children}</section>;
 }
 
+function expandDesktopHomePath(path: string): string {
+    if (!path.startsWith('~/')) return path;
+    const home = getDesktop()?.getHomePath?.()?.replace(/\/+$/, '');
+    return home ? `${home}/${path.slice(2)}` : path;
+}
+
 type Props = {
     sidebarCollapsed: boolean;
     activityDockCollapsed: boolean;
@@ -200,7 +206,7 @@ function renderRightPanelContent(
             onSettingsPatch={onDashboardSettingsPatch}
         /></Suspense>;
         case 'folder': return <Suspense fallback={fallback}><FolderPanel selectedFilePath={previewFilePath} externalRootPath={folderRootPath} repoRootPath={repoRootMode === 'instance' ? repoRootPath : null} gitRefreshVersion={gitRefreshVersion} notesTree={notesModel.tree} notesRoot={notesModel.notesRoot} onRootChange={onFolderRootChange} onRepoRootChange={onRepoRootChange} onGitRefresh={onGitRefresh} onPreviewFile={onPreviewFile} sessionState={folderPanelSession} onSessionStateChange={onFolderPanelSessionChange} /></Suspense>;
-        case 'doc': return <Suspense fallback={fallback}><DocPanel filePath={previewFilePath ?? undefined} /></Suspense>;
+        case 'doc': return <Suspense fallback={fallback}><DocPanel filePath={previewFilePath ?? undefined} onOpenLocalFile={onPreviewFile} /></Suspense>;
         case 'browser': return <Suspense fallback={fallback}><BrowserPanel /></Suspense>;
         case 'ceo': return jawCeoPanel;
         default: return null;
@@ -284,7 +290,9 @@ export function SidebarRailRouter(props: Props) {
         && !props.notesSelectedNote.tags?.includes(props.notesModel.tagFilter),
     );
     function handleRightPreviewFile(path: string): void {
-        setActiveResource(path, 'doc');
+        const previewPath = expandDesktopHomePath(path.trim());
+        if (!previewPath) return;
+        setActiveResource(previewPath, 'doc');
         panelLayout.dispatch({ type: 'OPEN_RIGHT_PANEL', mode: 'doc', slot: 'bottom' });
     }
 
@@ -400,12 +408,9 @@ export function SidebarRailRouter(props: Props) {
                                 <div id="code-session-sidebar-host" className="code-session-sidebar-host" />
                             </section>
                         ) : (
-                            <>
-                                <InstanceNavigator active={props.selectedInstance} hiddenCount={props.instances.filter(instance => instance.hidden).length} collapsed={props.sidebarCollapsed}>
-                                    {props.instanceListContent}
-                                </InstanceNavigator>
-                                <WorkerProgressMonitorPanel />
-                            </>
+                            <InstanceNavigator active={props.selectedInstance} hiddenCount={props.instances.filter(instance => instance.hidden).length} collapsed={props.sidebarCollapsed}>
+                                {props.instanceListContent}
+                            </InstanceNavigator>
                         )}
                     </div>
                 </>
@@ -434,7 +439,7 @@ export function SidebarRailRouter(props: Props) {
                         {props.viewMode === 'code' && props.sidebarMode === 'instances' ? (
                             <WorkspaceSurface active>
                                 <Suspense fallback={<div style={{ padding: '24px', color: 'var(--text-dim)', fontSize: '13px' }}>Loading Code workspace...</div>}>
-                                    <CodeCanvas port={props.port} workingDir={codeWorkingDir} onWorkingDirChange={updateRightFolderRoot} />
+                                    <CodeCanvas port={props.port} workingDir={codeWorkingDir} onWorkingDirChange={updateRightFolderRoot} onOpenLocalFile={handleRightPreviewFile} />
                                 </Suspense>
                             </WorkspaceSurface>
                         ) : null}

package/public/manager/src/code/CodeCanvas.tsx

@@ -35,9 +35,10 @@ type CodeCanvasProps = {
     port: number;
     workingDir: string;
     onWorkingDirChange?: (path: string | null) => void;
+    onOpenLocalFile?: (path: string) => void;
 };
 
-export function CodeCanvas({ port, workingDir, onWorkingDirChange }: CodeCanvasProps) {
+export function CodeCanvas({ port, workingDir, onWorkingDirChange, onOpenLocalFile }: CodeCanvasProps) {
     const client = useMemo(() => createCodeSessionClient(port), [port]);
     const [codeWorkingDir, setCodeWorkingDir] = useState(workingDir);
     const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
@@ -588,6 +589,7 @@ export function CodeCanvas({ port, workingDir, onWorkingDirChange }: CodeCanvasP
                 setActivePopup(null);
             }}
             onWorkingDirChange={handleWorkingDirChange}
+            onOpenLocalFile={onOpenLocalFile}
             workspaceFrozen={workspaceFrozen}
             onPickWorkingDir={handlePickWorkspace}
         />

package/public/manager/src/code/CodeTranscript.tsx

@@ -9,6 +9,7 @@ type CodeTranscriptProps = {
     sending: boolean;
     workingDir: string;
     transcriptRef: RefObject<HTMLDivElement | null>;
+    onOpenLocalFile?: ((path: string) => void) | undefined;
 };
 
 function renderToolContent(content: ToolContent, index: number) {
@@ -107,7 +108,7 @@ function estimateTranscriptRowSize(msg: TranscriptEntry | undefined): number {
     return 56 + Math.min(420, msg.text.length / 6);
 }
 
-function renderCodeMessage(msg: TranscriptEntry, i: number) {
+function renderCodeMessage(msg: TranscriptEntry, i: number, onOpenLocalFile?: ((path: string) => void) | undefined) {
     return (
         <div key={i} className={`code-message code-message-${msg.role}`}>
             {msg.role === 'tool' ? (() => {
@@ -165,7 +166,7 @@ function renderCodeMessage(msg: TranscriptEntry, i: number) {
                     <div className="code-message-text">
                         {msg.role === 'assistant' ? (
                             <Suspense fallback={<span>{msg.text}</span>}>
-                                <MarkdownRenderer markdown={msg.text} tableMode="linear" />
+                                <MarkdownRenderer markdown={msg.text} tableMode="linear" onLocalFileOpen={onOpenLocalFile} />
                             </Suspense>
                         ) : msg.text}
                     </div>
@@ -184,7 +185,7 @@ function renderSendingMessage() {
     );
 }
 
-export function CodeTranscript({ messages, sending, workingDir, transcriptRef }: CodeTranscriptProps) {
+export function CodeTranscript({ messages, sending, workingDir, transcriptRef, onOpenLocalFile }: CodeTranscriptProps) {
     const showSending = sending && messages[messages.length - 1]?.role !== 'assistant';
     const rowCount = messages.length + (showSending ? 1 : 0);
     const getItemKey = useCallback((index: number): string | number => {
@@ -248,7 +249,7 @@ export function CodeTranscript({ messages, sending, workingDir, transcriptRef }:
                                 data-code-transcript-idx={virtualItem.index}
                                 style={{ transform: `translateY(${virtualItem.start}px)` }}
                             >
-                                {msg ? renderCodeMessage(msg, virtualItem.index) : renderSendingMessage()}
+                                {msg ? renderCodeMessage(msg, virtualItem.index, onOpenLocalFile) : renderSendingMessage()}
                             </div>
                         );
                     })}

package/public/manager/src/code/CodeWorkbench.tsx

@@ -61,6 +61,7 @@ type CodeWorkbenchProps = {
     onUseModel: (provider: string, model: string) => void | Promise<void>;
     onUseForNewSessions: (provider: string, model: string) => void | Promise<void>;
     onWorkingDirChange: (path: string | null) => void;
+    onOpenLocalFile?: ((path: string) => void) | undefined;
     workspaceFrozen: boolean;
     onPickWorkingDir: () => Promise<string | null>;
 };
@@ -94,7 +95,7 @@ export function CodeWorkbench(props: CodeWorkbenchProps) {
                     {props.transportState === 'reconnecting' ? 'Live updates reconnecting…' : 'Live updates disconnected — retrying.'}
                 </section>
             )}
-            <CodeTranscript messages={props.messages} sending={props.sending} workingDir={props.codeWorkingDir} transcriptRef={props.transcriptRef} />
+            <CodeTranscript messages={props.messages} sending={props.sending} workingDir={props.codeWorkingDir} transcriptRef={props.transcriptRef} onOpenLocalFile={props.onOpenLocalFile} />
             <CodePermissionQueue permissions={props.permissions} onAnswer={props.onPermissionAnswer} />
             <div className="code-composer-dock">
                 <div className="code-composer-surface" aria-label="Code composer controls">

package/public/manager/src/doc-panel/DocPanel.tsx

@@ -9,7 +9,7 @@ import './doc-panel.css';
 const EXT_LANG: Record<string, string> = {
     ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
     py: 'python', rs: 'rust', go: 'go', java: 'java', cpp: 'cpp', c: 'cpp',
-    css: 'css', html: 'html', xml: 'xml', json: 'json',
+    css: 'css', html: 'html', htm: 'html', xml: 'xml', json: 'json',
     yaml: 'yaml', yml: 'yaml', sh: 'bash', bash: 'bash', sql: 'sql',
 };
 
@@ -22,6 +22,10 @@ function isMarkdown(filePath: string): boolean {
     return /\.(md|mdx)$/i.test(filePath);
 }
 
+function isHtml(filePath: string): boolean {
+    return /\.html?$/i.test(filePath);
+}
+
 function getFileBridge(): Pick<FolderBridgeApi, 'readFile' | 'getDefaultRoot'> | null {
     return getDesktop()?.folder ?? null;
 }
@@ -34,17 +38,60 @@ function getDisplayFileName(filePath: string): string {
     return filePath.split(/[\\/]/).pop() || filePath;
 }
 
-function DocContent(props: { filePath: string; content: string; raw: boolean }) {
+function htmlPreviewSrcDoc(content: string): string {
+    const csp = [
+        "default-src 'none'",
+        "img-src data: blob:",
+        "style-src 'unsafe-inline' data:",
+        "font-src data:",
+        "script-src 'none'",
+        "connect-src 'none'",
+        "object-src 'none'",
+        "base-uri 'none'",
+        "form-action 'none'",
+        "frame-src 'none'",
+    ].join('; ');
+    return [
+        '<!doctype html>',
+        '<html>',
+        '<head>',
+        `<meta http-equiv="Content-Security-Policy" content="${csp}">`,
+        '<meta charset="utf-8">',
+        '<style>html,body{margin:0;min-height:100%;}body{font-family:system-ui,sans-serif;}</style>',
+        '</head>',
+        '<body>',
+        content,
+        '</body>',
+        '</html>',
+    ].join('');
+}
+
+function HtmlPreview(props: { content: string; title: string }) {
+    return (
+        <iframe
+            className="doc-html-preview"
+            title={props.title}
+            sandbox=""
+            referrerPolicy="no-referrer"
+            srcDoc={htmlPreviewSrcDoc(props.content)}
+        />
+    );
+}
+
+function DocContent(props: { filePath: string; content: string; raw: boolean; onOpenLocalFile?: ((path: string) => void) | undefined }) {
     if (props.raw) {
         return <pre className="doc-pre"><code>{props.content}</code></pre>;
     }
     if (isMarkdown(props.filePath)) {
         return (
             <article className="notes-preview doc-markdown">
-                <MarkdownRenderer markdown={props.content} />
+                <MarkdownRenderer markdown={props.content} onLocalFileOpen={props.onOpenLocalFile} />
             </article>
         );
     }
+    if (isHtml(props.filePath)) {
+        return <HtmlPreview content={props.content} title={`Rendered preview of ${getDisplayFileName(props.filePath)}`} />;
+    }
     const lang = getFileLanguage(props.filePath);
     if (lang) {
         return <CodeBlock code={props.content} language={lang} />;
@@ -52,7 +99,7 @@ function DocContent(props: { filePath: string; content: string; raw: boolean })
     return <pre className="doc-pre"><code>{props.content}</code></pre>;
 }
 
-export function DocPanel(props: { filePath?: string | undefined }) {
+export function DocPanel(props: { filePath?: string | undefined; onOpenLocalFile?: ((path: string) => void) | undefined }) {
     const bridge = getFileBridge();
     const scrollRef = useRef<HTMLDivElement | null>(null);
     const contentBodyRef = useRef<HTMLDivElement | null>(null);
@@ -260,7 +307,7 @@ export function DocPanel(props: { filePath?: string | undefined }) {
                 }}
             >
                 <div className="doc-content-body" ref={contentBodyRef}>
-                    <DocContent filePath={props.filePath} content={content} raw={raw} />
+                    <DocContent filePath={props.filePath} content={content} raw={raw} onOpenLocalFile={props.onOpenLocalFile} />
                 </div>
             </div>
         </div>

package/public/manager/src/doc-panel/doc-panel.css

@@ -67,6 +67,8 @@
 }
 .doc-content-body {
     min-width: 0;
+    min-height: 100%;
+    height: 100%;
 }
 .doc-content .notes-mermaid-block.is-loading {
     min-height: 96px;
@@ -85,6 +87,14 @@
 .doc-markdown {
     padding: 12px 16px;
 }
+.doc-html-preview {
+    display: block;
+    width: 100%;
+    min-height: 100%;
+    height: 100%;
+    border: 0;
+    background: #fff;
+}
 .doc-content .notes-code-block {
     margin: 0;
     border-radius: 0;

package/public/manager/src/folder-panel/FolderPanel.tsx

@@ -15,6 +15,7 @@ import { useGitWorktrees } from './use-git-worktrees';
 import { useFolderChord } from './use-folder-chord';
 import { useFolderSelection, type FolderDragSelection } from './use-folder-selection';
 import { useFolderVisibleRefresh } from './use-folder-visible-refresh';
+import { useFolderPreviewSync } from './use-folder-preview-sync';
 import { useFolderWorktreeOperations } from './use-folder-worktree-operations';
 import { useFolderMutations } from './use-folder-mutations';
 import { useFolderContextMenu } from './use-folder-context-menu';
@@ -55,6 +56,7 @@ export function FolderPanel(props: FolderPanelProps) {
     const [actionStatus, setActionStatus] = useState<string | null>(null);
     const [gitRefreshToken, setGitRefreshToken] = useState(0);
     const treeRef = useRef<HTMLDivElement | null>(null);
+    const restoredRootLoadRef = useRef<string | null>(null);
     const { folderChordActive, startFolderChord, cancelFolderChord } = useFolderChord();
     const onPreviewFile = props.onPreviewFile;
     const selectedFilePath = props.selectedFilePath;
@@ -71,20 +73,13 @@ export function FolderPanel(props: FolderPanelProps) {
         selectedPaths: folderSelection.selectedPaths,
         selectOnlyPath: folderSelection.selectOnlyPath,
     });
-    useEffect(() => {
-        const selectedPath = props.selectedFilePath;
-        if (!selectedPath || !rootPath) return;
-        if (!isDescendantPath(rootPath, selectedPath)) return;
-        if (selectedPath === folderSelection.selectedPath) return;
-        if (!folderSelection.visiblePaths.includes(selectedPath)) return;
-        folderSelection.selectOnlyPath(selectedPath);
-    }, [
-        folderSelection.selectedPath,
-        folderSelection.selectOnlyPath,
-        folderSelection.visiblePaths,
-        props.selectedFilePath,
+    useFolderPreviewSync({
+        selectedFilePath: props.selectedFilePath,
         rootPath,
-    ]);
+        selectedPath: folderSelection.selectedPath,
+        visiblePaths: folderSelection.visiblePaths,
+        selectOnlyPath: folderSelection.selectOnlyPath,
+    });
     useEffect(() => {
         props.onSessionStateChange?.(folderPanelSessionFromState({
             rootPath,
@@ -197,13 +192,16 @@ export function FolderPanel(props: FolderPanelProps) {
 
     useEffect(() => {
         const externalRoot = props.externalRootPath;
-        if (!externalRoot || externalRoot === rootPath) return;
+        if (!externalRoot) return;
+        if (externalRoot === rootPath) {
+            if (entries.length > 0 || restoredRootLoadRef.current === externalRoot) return;
+            restoredRootLoadRef.current = externalRoot;
+        } else restoredRootLoadRef.current = null;
         void openFolderRoot(externalRoot);
-    }, [openFolderRoot, props.externalRootPath, rootPath]);
+    }, [entries.length, openFolderRoot, props.externalRootPath, rootPath]);
 
     const gitStatus = useFolderGitStatus({
         rootPath,
-        repoRoot: repoRootPath,
         enabled: source.kind === 'electron-folder',
         refreshToken: gitRefreshToken + gitRefreshVersion,
     });

package/public/manager/src/folder-panel/use-folder-git-status.ts

@@ -88,6 +88,21 @@ export function useFolderGitStatus(input: UseFolderGitStatusInput): FolderPanelG
                     setState(stateFromStatus(result.status));
                     return;
                 }
+                if (repoRoot && /repo root mismatch/i.test(result.error)) {
+                    const healed = await loadFolderGitStatus(rootPath, {
+                        includeIgnored: true,
+                        includeUntracked: true,
+                    });
+                    if (cancelled) return;
+                    if (healed.ok) {
+                        setState(stateFromStatus(healed.status));
+                        return;
+                    }
+                    setState(healed.quiet
+                        ? EMPTY_FOLDER_GIT_STATE
+                        : { ...EMPTY_FOLDER_GIT_STATE, error: healed.error });
+                    return;
+                }
                 setState(result.quiet
                     ? EMPTY_FOLDER_GIT_STATE
                     : { ...EMPTY_FOLDER_GIT_STATE, error: result.error });

package/public/manager/src/folder-panel/use-folder-preview-sync.ts

@@ -0,0 +1,37 @@
+import { useEffect, useRef } from 'react';
+import { isDescendantPath } from './folder-panel-state';
+
+type UseFolderPreviewSyncInput = {
+    selectedFilePath: string | null | undefined;
+    rootPath: string | null;
+    selectedPath: string | null;
+    visiblePaths: string[];
+    selectOnlyPath: (path: string | null) => void;
+};
+
+/**
+ * Mirrors the externally-driven preview file (DocPanel/DiffPanel selection) into
+ * the folder tree's visible-row selection, WITHOUT clobbering local row clicks.
+ *
+ * The sync only fires when the external preview path actually changes. A local
+ * row click changes `selectedPath` but not `selectedFilePath`, so the guard
+ * leaves the user's selection untouched (the 990461c1 selection-lock fix). When
+ * the preview path is cleared/changes to a non-visible or out-of-root file, the
+ * current selection is left as-is rather than being reset.
+ */
+export function useFolderPreviewSync(input: UseFolderPreviewSyncInput): void {
+    const { selectedFilePath, rootPath, selectedPath, visiblePaths, selectOnlyPath } = input;
+    const syncedPreviewPathRef = useRef<string | null>(null);
+
+    useEffect(() => {
+        const previewPath = selectedFilePath ?? null;
+        const previewPathChanged = previewPath !== syncedPreviewPathRef.current;
+        if (previewPathChanged) syncedPreviewPathRef.current = previewPath;
+        if (!previewPathChanged && selectedPath) return;
+        if (!previewPath || !rootPath) return;
+        if (!isDescendantPath(rootPath, previewPath)) return;
+        if (previewPath === selectedPath) return;
+        if (!visiblePaths.includes(previewPath)) return;
+        selectOnlyPath(previewPath);
+    }, [rootPath, selectOnlyPath, selectedFilePath, selectedPath, visiblePaths]);
+}

package/public/manager/src/folder-panel/use-folder-visible-refresh.ts

@@ -57,6 +57,12 @@ export function useFolderVisibleRefresh(input: UseFolderVisibleRefreshInput) {
     const refreshingRef = useRef(false);
     const queuedRefreshRef = useRef<{ reason: FolderRefreshReason; options: FolderVisibleRefreshOptions } | null>(null);
     const watchTimerRef = useRef<number | null>(null);
+    const runRefreshRef = useRef<(reason: FolderRefreshReason, options?: FolderVisibleRefreshOptions) => Promise<void>>(async () => undefined);
+    const mountedRef = useRef(true);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => { mountedRef.current = false; };
+    }, []);
 
     const clearWatchTimer = useCallback(() => {
         if (watchTimerRef.current === null) return;
@@ -82,8 +88,10 @@ export function useFolderVisibleRefresh(input: UseFolderVisibleRefreshInput) {
             return;
         }
         refreshingRef.current = true;
-        setIsRefreshing(true);
-        setRefreshStatus(reason === 'watch' ? 'Refreshing changed files...' : 'Refreshing folder...');
+        if (mountedRef.current) {
+            setIsRefreshing(true);
+            setRefreshStatus(reason === 'watch' ? 'Refreshing changed files...' : 'Refreshing folder...');
+        }
         try {
             const expandedPaths = Array.from(new Set([...Array.from(expanded), ...(options.extraPaths ?? [])]))
                 .slice(0, MAX_EXPANDED_REFRESH_BRANCHES);
@@ -92,16 +100,19 @@ export function useFolderVisibleRefresh(input: UseFolderVisibleRefreshInput) {
             bumpGitRefresh();
             onGitRefresh?.();
             refreshWorktrees();
+            if (!mountedRef.current) return;
             const skippedCount = Math.max(0, expanded.size - expandedPaths.length);
             setRefreshStatus(skippedCount > 0
                 ? `${reasonLabel(reason)}; ${skippedCount} collapsed/overflow branches skipped`
                 : reasonLabel(reason));
         } finally {
             refreshingRef.current = false;
-            setIsRefreshing(false);
+            if (mountedRef.current) setIsRefreshing(false);
             const queuedRefresh = queuedRefreshRef.current;
             queuedRefreshRef.current = null;
-            if (queuedRefresh) void runRefresh(queuedRefresh.reason, queuedRefresh.options);
+            if (queuedRefresh && mountedRef.current) {
+                void runRefreshRef.current(queuedRefresh.reason, queuedRefresh.options);
+            }
         }
     }, [bumpGitRefresh, expanded, loadChildren, loadDir, onGitRefresh, refreshWorktrees, rootPath]);
 
@@ -112,13 +123,15 @@ export function useFolderVisibleRefresh(input: UseFolderVisibleRefreshInput) {
         await runRefresh(reason, options);
     }, [runRefresh]);
 
+    useEffect(() => { runRefreshRef.current = runRefresh; }, [runRefresh]);
+
     const scheduleWatchRefresh = useCallback(() => {
         clearWatchTimer();
         watchTimerRef.current = window.setTimeout(() => {
             watchTimerRef.current = null;
-            void runRefresh('watch');
+            void runRefreshRef.current('watch');
         }, WATCH_REFRESH_DELAY_MS);
-    }, [clearWatchTimer, runRefresh]);
+    }, [clearWatchTimer]);
 
     useEffect(() => {
         if (!source.watchDir || !source.onDirChange || rootPath === null) return;

package/public/manager/src/manager-notes.css

@@ -1142,6 +1142,29 @@
     font-size: 0.92em;
 }
 
+.markdown-local-file-link {
+    display: inline;
+    border: 0;
+    padding: 0;
+    background: transparent;
+    color: var(--accent-default);
+    font: inherit;
+    text-decoration: underline;
+    text-decoration-thickness: 1px;
+    text-underline-offset: 2px;
+    cursor: pointer;
+}
+
+.markdown-local-file-link:hover {
+    color: var(--accent);
+}
+
+.markdown-local-file-link:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+    border-radius: 3px;
+}
+
 .notes-preview :where(.katex-display, .notes-code-block, .notes-mermaid-block) {
     max-width: 100%;
     overflow-x: auto;

package/public/manager/src/notes/rendering/MarkdownRenderer.tsx

@@ -1,4 +1,5 @@
 import { Children, createElement, isValidElement, useMemo } from 'react';
+import type { MouseEvent } from 'react';
 import type { ComponentProps, CSSProperties, ReactNode } from 'react';
 import ReactMarkdown from 'react-markdown';
 import type { Components } from 'react-markdown';
@@ -24,6 +25,7 @@ type MarkdownRendererProps = {
     outgoing?: NotesNoteLinkRef[] | undefined;
     notes?: readonly NotesNoteMetadata[] | undefined;
     onWikiLinkNavigate?: ((path: string) => void) | undefined;
+    onLocalFileOpen?: ((path: string) => void) | undefined;
     tableMode?: 'semantic' | 'linear' | undefined;
 };
 
@@ -114,6 +116,77 @@ function languageFromCodeNode(node: ReactNode): string {
 }
 
 const NOOP_NAVIGATE = (_path: string): void => {};
+const LOCAL_FILE_PATH_RE_G = /(?:~\/[^\s)`\]"'<>]+|\/(?:Users|home|tmp|var|opt|private)\/[^\s)`\]"'<>]+)/g;
+const TRAILING_PATH_PUNCT_RE = /[.,!?:;]+$/;
+
+function isLocalFilePathCandidate(path: string): boolean {
+    return path.startsWith('~/') || /^\/(?:Users|home|tmp|var|opt|private)\//.test(path);
+}
+
+function localPathLabel(path: string): string {
+    const basename = path.split('/').pop() || path;
+    return /\.\w{1,10}$/.test(basename) ? basename : path;
+}
+
+function splitTextWithLocalFileLinks(
+    text: string,
+    onLocalFileOpen: ((path: string) => void) | undefined,
+    keyPrefix: string,
+): ReactNode[] {
+    if (!text || !onLocalFileOpen) return [text];
+    LOCAL_FILE_PATH_RE_G.lastIndex = 0;
+    const out: ReactNode[] = [];
+    let cursor = 0;
+    let index = 0;
+    let match: RegExpExecArray | null;
+    while ((match = LOCAL_FILE_PATH_RE_G.exec(text)) !== null) {
+        const raw = match[0];
+        const clean = raw.replace(TRAILING_PATH_PUNCT_RE, '');
+        if (!isLocalFilePathCandidate(clean)) continue;
+        if (match.index > cursor) out.push(text.slice(cursor, match.index));
+        const trailing = raw.slice(clean.length);
+        out.push(
+            createElement(
+                'button',
+                {
+                    key: `${keyPrefix}-lf-${index++}`,
+                    type: 'button',
+                    className: 'markdown-local-file-link',
+                    title: clean,
+                    onClick: (event: MouseEvent<HTMLButtonElement>) => {
+                        event.preventDefault();
+                        onLocalFileOpen(clean);
+                    },
+                },
+                localPathLabel(clean),
+            ),
+        );
+        if (trailing) out.push(trailing);
+        cursor = match.index + raw.length;
+    }
+    if (cursor === 0) return [text];
+    if (cursor < text.length) out.push(text.slice(cursor));
+    return out;
+}
+
+function splitChildrenWithLocalFileLinks(
+    children: ReactNode,
+    onLocalFileOpen: ((path: string) => void) | undefined,
+    keyPrefix: string,
+): ReactNode {
+    if (!onLocalFileOpen) return children;
+    const out: ReactNode[] = [];
+    let stringIndex = 0;
+    Children.forEach(children, (child, i) => {
+        if (typeof child === 'string') {
+            const segments = splitTextWithLocalFileLinks(child, onLocalFileOpen, `${keyPrefix}-${stringIndex++}-${i}`);
+            for (const seg of segments) out.push(seg);
+            return;
+        }
+        out.push(child);
+    });
+    return out;
+}
 
 export function MarkdownRenderer(props: MarkdownRendererProps) {
     const renderedMarkdown = useMemo(
@@ -128,15 +201,20 @@ export function MarkdownRenderer(props: MarkdownRendererProps) {
         onNavigate: props.onWikiLinkNavigate ?? NOOP_NAVIGATE,
     }), [props.outgoing, props.notes, props.onWikiLinkNavigate]);
 
+    const inlineTransform = (children: ReactNode, keyPrefix: string): ReactNode => {
+        const withWikiLinks = splitChildrenWithWikiLinks(children, wikiCtx, keyPrefix);
+        return splitChildrenWithLocalFileLinks(withWikiLinks, props.onLocalFileOpen, keyPrefix);
+    };
+
     const wikiTransform = (tag: WikiContainerTag) => (containerProps: WikiContainerProps) => {
         const { children, node: _node, className, id, style } = containerProps;
-        const transformed = splitChildrenWithWikiLinks(children, wikiCtx, tag);
+        const transformed = inlineTransform(children, tag);
         return createElement(tag, { className, id, style }, transformed);
     };
 
     const linearCellTransform = (tag: 'td' | 'th') => (cellProps: LinearTableCellProps) => {
         const { children, node: _node, className, style, align } = cellProps;
-        const transformed = splitChildrenWithWikiLinks(children, wikiCtx, tag);
+        const transformed = inlineTransform(children, tag);
         return (
             <span
                 className={mergeClassName(`markdown-linear-table-cell markdown-linear-table-${tag}`, className)}