tabminal 3.0.12 → 3.0.14

package/public/app.js

@@ -104,13 +104,22 @@ const editorPane = document.getElementById('editor-pane');
 const HEARTBEAT_INTERVAL_MS = 1000;
 const RECONNECT_RETRY_MS = 5000;
 const FILE_TREE_REFRESH_INTERVAL_MS = 3000;
+const FILE_VERSION_CHECK_INTERVAL_MS = 3000;
 const MAIN_SERVER_ID = 'main';
 const RUNTIME_BOOT_ID_STORAGE_KEY = 'tabminal_runtime_boot_id';
 const WORKSPACE_DEVICE_ID_STORAGE_KEY = 'tabminal_workspace_device_id';
 const RECENT_AGENT_USAGE_STORAGE_KEY = 'tabminal_recent_agent_usage';
 const FILE_WORKSPACE_TAB_PREFIX = 'file:';
+const MARKDOWN_PREVIEW_WORKSPACE_TAB_PREFIX = 'markdown-preview:';
 const AGENT_WORKSPACE_TAB_PREFIX = 'agent:';
 const TERMINAL_WORKSPACE_TAB_KEY = 'terminal:main';
+const SUPPORTED_MARKDOWN_EXTENSIONS = new Set([
+    'md',
+    'markdown',
+    'mkd',
+    'mkdn',
+    'mdown'
+]);
 const SUPPORTED_IMAGE_EXTENSIONS = new Set([
     'png',
     'jpg',
@@ -119,6 +128,20 @@ const SUPPORTED_IMAGE_EXTENSIONS = new Set([
     'svg',
     'webp'
 ]);
+const SUPPORTED_PDF_EXTENSIONS = new Set([
+    'pdf'
+]);
+const PDFJS_VERSION = '5.6.205';
+const PDFJS_MODULE_URL = `https://cdn.jsdelivr.net/npm/pdfjs-dist@${PDFJS_VERSION}/build/pdf.min.mjs`;
+const PDFJS_WORKER_URL = `https://cdn.jsdelivr.net/npm/pdfjs-dist@${PDFJS_VERSION}/build/pdf.worker.min.mjs`;
+const MARKDOWN_IT_MODULE_URL = 'https://cdn.jsdelivr.net/npm/markdown-it@14.1.1/+esm';
+const MARKDOWN_TASK_LISTS_MODULE_URL = 'https://cdn.jsdelivr.net/npm/markdown-it-task-lists@2.1.1/+esm';
+const MARKDOWN_KATEX_MODULE_URL = 'https://cdn.jsdelivr.net/npm/@traptitech/markdown-it-katex@3.6.0/+esm';
+const KATEX_MODULE_URL = 'https://cdn.jsdelivr.net/npm/katex@0.16.25/+esm';
+const HIGHLIGHT_JS_MODULE_URL = 'https://cdn.jsdelivr.net/npm/highlight.js@11.11.1/+esm';
+const MARKDOWN_PREVIEW_GITHUB_CSS_URL = 'https://cdn.jsdelivr.net/npm/github-markdown-css@5.8.1/github-markdown-dark.min.css';
+const MARKDOWN_PREVIEW_HIGHLIGHT_CSS_URL = 'https://cdn.jsdelivr.net/npm/highlight.js@11.11.1/styles/github-dark.css';
+const MARKDOWN_PREVIEW_KATEX_CSS_URL = 'https://cdn.jsdelivr.net/npm/katex@0.16.25/dist/katex.min.css';
 const CLOSE_ICON_SVG = '<svg viewBox="0 0 24 24" width="16" height="16" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>';
 const AGENT_ICON_SVG = '<svg viewBox="0 0 24 24" width="17" height="17" stroke="currentColor" stroke-width="1.8" fill="none" stroke-linecap="round" stroke-linejoin="round"><rect x="7" y="7" width="10" height="10" rx="2"></rect><path d="M9 7V5"></path><path d="M15 7V5"></path><path d="M12 17v2"></path><path d="M5 12H3"></path><path d="M21 12h-2"></path><path d="M9 11h.01"></path><path d="M15 11h.01"></path><path d="M9.5 14c.7.67 1.53 1 2.5 1s1.8-.33 2.5-1"></path></svg>';
 const TERMINAL_TAB_ICON_SVG = '<svg viewBox="0 0 24 24" width="15" height="15" stroke="currentColor" stroke-width="1.8" fill="none" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="5" width="18" height="14" rx="2"></rect><path d="m8 10 3 2-3 2"></path><path d="M13 15h4"></path></svg>';
@@ -137,6 +160,9 @@ const RENAME_ICON_SVG = '<svg viewBox="0 0 24 24" width="14" height="14" stroke=
 const DELETE_ICON_SVG = '<svg viewBox="0 0 24 24" width="14" height="14" stroke="currentColor" stroke-width="1.9" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M4 7h16"></path><path d="M10 11v6"></path><path d="M14 11v6"></path><path d="M6 7l1 12h10l1-12"></path><path d="M9 7V4h6v3"></path></svg>';
 const NEW_FOLDER_ICON_SVG = '<svg viewBox="0 0 24 24" width="14" height="14" stroke="currentColor" stroke-width="1.8" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M3.5 7.5A2.5 2.5 0 0 1 6 5h4l2 2h6a2.5 2.5 0 0 1 2.5 2.5V17A2.5 2.5 0 0 1 18 19.5H6A2.5 2.5 0 0 1 3.5 17Z"></path><path d="M12 10.5v5"></path><path d="M9.5 13h5"></path></svg>';
 const NEW_FILE_ICON_SVG = '<svg viewBox="0 0 24 24" width="14" height="14" stroke="currentColor" stroke-width="1.8" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M7 3.5h7l4 4V20.5H7A2.5 2.5 0 0 1 4.5 18V6A2.5 2.5 0 0 1 7 3.5Z"></path><path d="M14 3.5V8h4"></path><path d="M12 11v6"></path><path d="M9 14h6"></path></svg>';
+const MARKDOWN_PREVIEW_ICON_SVG = '<svg viewBox="0 0 24 24" width="15" height="15" stroke="currentColor" stroke-width="1.8" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M3 5.5h18"></path><path d="M3 9.5h18"></path><path d="M5 5.5V18a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1V5.5"></path><path d="M9 13h6"></path><path d="M9 16h4"></path></svg>';
+const MARKDOWN_SPLIT_ENABLE_ICON_SVG = '<svg viewBox="0 0 24 24" width="15" height="15" stroke="currentColor" stroke-width="1.8" fill="none" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="5" width="16" height="14" rx="2"></rect><path d="M12 5v14"></path></svg>';
+const MARKDOWN_SPLIT_DISABLE_ICON_SVG = '<svg viewBox="0 0 24 24" width="15" height="15" stroke="currentColor" stroke-width="1.8" fill="none" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="5" width="16" height="14" rx="2"></rect><path d="M12 5v14"></path><path d="m9.25 8.5 5.5 7"></path></svg>';
 const TERMINAL_FONT_FAMILY = '\'Monaspace Neon\', "SF Mono Terminal", '
     + '"SFMono-Regular", "SF Mono", "JetBrains Mono", Menlo, Consolas, '
     + 'monospace';
@@ -161,12 +187,18 @@ const agentSetupState = {
 };
 let primaryServerBootId = '';
 let runtimeReloadScheduled = false;
+let pdfJsLibPromise = null;
+let markdownPreviewBundlePromise = null;
 // #endregion
 
 function makeFileWorkspaceTabKey(filePath) {
     return `${FILE_WORKSPACE_TAB_PREFIX}${filePath}`;
 }
 
+function makeMarkdownPreviewWorkspaceTabKey(filePath) {
+    return `${MARKDOWN_PREVIEW_WORKSPACE_TAB_PREFIX}${filePath}`;
+}
+
 function makeAgentTabKey(serverId, tabId) {
     return `${AGENT_WORKSPACE_TAB_PREFIX}${serverId}:${tabId}`;
 }
@@ -182,7 +214,15 @@ function isTerminalWorkspaceTabKey(key) {
 
 function isFileWorkspaceTabKey(key) {
     return typeof key === 'string'
-        && key.startsWith(FILE_WORKSPACE_TAB_PREFIX);
+        && (
+            key.startsWith(FILE_WORKSPACE_TAB_PREFIX)
+            || key.startsWith(MARKDOWN_PREVIEW_WORKSPACE_TAB_PREFIX)
+        );
+}
+
+function isMarkdownPreviewWorkspaceTabKey(key) {
+    return typeof key === 'string'
+        && key.startsWith(MARKDOWN_PREVIEW_WORKSPACE_TAB_PREFIX);
 }
 
 function isCompactWorkspaceMode() {
@@ -201,10 +241,127 @@ function isSupportedImagePath(filePath) {
     return SUPPORTED_IMAGE_EXTENSIONS.has(ext);
 }
 
+function isSupportedPdfPath(filePath) {
+    if (typeof filePath !== 'string') {
+        return false;
+    }
+    const dotIndex = filePath.lastIndexOf('.');
+    if (dotIndex === -1) {
+        return false;
+    }
+    const ext = filePath.slice(dotIndex + 1).toLowerCase();
+    return SUPPORTED_PDF_EXTENSIONS.has(ext);
+}
+
+function isSupportedMarkdownPath(filePath) {
+    if (typeof filePath !== 'string') {
+        return false;
+    }
+    const dotIndex = filePath.lastIndexOf('.');
+    if (dotIndex === -1) {
+        return false;
+    }
+    const ext = filePath.slice(dotIndex + 1).toLowerCase();
+    return SUPPORTED_MARKDOWN_EXTENSIONS.has(ext);
+}
+
+function ensureExternalStylesheet(id, href) {
+    if (!href || document.getElementById(id)) {
+        return;
+    }
+    const link = document.createElement('link');
+    link.id = id;
+    link.rel = 'stylesheet';
+    link.href = href;
+    document.head.appendChild(link);
+}
+
+async function loadMarkdownPreviewBundle() {
+    if (!markdownPreviewBundlePromise) {
+        markdownPreviewBundlePromise = (async () => {
+            ensureExternalStylesheet(
+                'markdown-preview-github-css',
+                MARKDOWN_PREVIEW_GITHUB_CSS_URL
+            );
+            ensureExternalStylesheet(
+                'markdown-preview-highlight-css',
+                MARKDOWN_PREVIEW_HIGHLIGHT_CSS_URL
+            );
+            ensureExternalStylesheet(
+                'markdown-preview-katex-css',
+                MARKDOWN_PREVIEW_KATEX_CSS_URL
+            );
+            const [
+                { default: MarkdownIt },
+                { default: markdownItTaskLists },
+                { default: markdownItKatex },
+                { default: katex },
+                { default: hljs }
+            ] = await Promise.all([
+                import(MARKDOWN_IT_MODULE_URL),
+                import(MARKDOWN_TASK_LISTS_MODULE_URL),
+                import(MARKDOWN_KATEX_MODULE_URL),
+                import(KATEX_MODULE_URL),
+                import(HIGHLIGHT_JS_MODULE_URL)
+            ]);
+            const renderer = new MarkdownIt({
+                html: true,
+                linkify: true,
+                breaks: false,
+                highlight(source, language) {
+                    const code = String(source || '');
+                    const nextLanguage = String(language || '').trim();
+                    let html = '';
+                    if (nextLanguage && hljs.getLanguage(nextLanguage)) {
+                        html = hljs.highlight(code, {
+                            language: nextLanguage,
+                            ignoreIllegals: true
+                        }).value;
+                    } else {
+                        html = hljs.highlightAuto(code).value;
+                    }
+                    const languageClass = nextLanguage
+                        ? ` language-${escapeHtml(nextLanguage)}`
+                        : '';
+                    return `<pre class="hljs"><code class="hljs${languageClass}">${html}</code></pre>`;
+                }
+            });
+            renderer.use(markdownItTaskLists, {
+                enabled: false,
+                label: true,
+                labelAfter: true
+            });
+            renderer.use(markdownItKatex, { katex });
+            return {
+                renderer
+            };
+        })().catch((error) => {
+            markdownPreviewBundlePromise = null;
+            throw error;
+        });
+    }
+    return await markdownPreviewBundlePromise;
+}
+
+async function loadPdfJs() {
+    if (!pdfJsLibPromise) {
+        pdfJsLibPromise = import(PDFJS_MODULE_URL)
+            .then((pdfjsLib) => {
+                pdfjsLib.GlobalWorkerOptions.workerSrc = PDFJS_WORKER_URL;
+                return pdfjsLib;
+            });
+    }
+    return await pdfJsLibPromise;
+}
+
 function isCompactTerminalTabsMode() {
     return !!window.__tabminalCompactTerminalTabsMode;
 }
 
+function canUseMarkdownSplitTabsMode() {
+    return !isForcedTerminalWorkspaceMode();
+}
+
 function isForcedTerminalWorkspaceMode() {
     return isCompactWorkspaceMode() || isCompactTerminalTabsMode();
 }
@@ -220,8 +377,52 @@ function buildMainTerminalTheme() {
 }
 
 function workspaceKeyToFilePath(key) {
-    if (!isFileWorkspaceTabKey(key)) return '';
-    return key.slice(FILE_WORKSPACE_TAB_PREFIX.length);
+    if (typeof key !== 'string' || key.length === 0) return '';
+    if (key.startsWith(MARKDOWN_PREVIEW_WORKSPACE_TAB_PREFIX)) {
+        return key.slice(MARKDOWN_PREVIEW_WORKSPACE_TAB_PREFIX.length);
+    }
+    if (key.startsWith(FILE_WORKSPACE_TAB_PREFIX)) {
+        return key.slice(FILE_WORKSPACE_TAB_PREFIX.length);
+    }
+    return '';
+}
+
+function isExternalHref(href) {
+    return /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(String(href || '').trim());
+}
+
+function resolveMarkdownLocalTarget(baseFilePath, href) {
+    const value = String(href || '').trim();
+    const basePath = String(baseFilePath || '').trim();
+    if (!value || !basePath || value.startsWith('#') || isExternalHref(value)) {
+        return null;
+    }
+    const baseDir = basePath.includes('/')
+        ? basePath.slice(0, basePath.lastIndexOf('/') + 1)
+        : '/';
+    try {
+        const resolved = new URL(
+            value,
+            `https://tabminal.local${encodeURI(baseDir)}`
+        );
+        if (resolved.origin !== 'https://tabminal.local') {
+            return null;
+        }
+        return {
+            path: decodeURIComponent(resolved.pathname),
+            hash: resolved.hash || ''
+        };
+    } catch {
+        return null;
+    }
+}
+
+function slugifyMarkdownHeading(text) {
+    return String(text || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\s-]/gu, '')
+        .replace(/\s+/g, '-');
 }
 
 function getWorkspaceDeviceId() {
@@ -263,15 +464,44 @@ function normalizeWorkspaceSnapshot(input = {}, fallback = {}) {
                 ? base.updatedBy
                 : ''
         );
+    const openFiles = uniqueStringList(source.openFiles);
+    const fallbackOpenFiles = uniqueStringList(base.openFiles);
+    const markdownSplitPathSource =
+        typeof source.markdownSplitPath === 'string'
+            ? source.markdownSplitPath
+            : (
+                typeof base.markdownSplitPath === 'string'
+                    ? base.markdownSplitPath
+                    : ''
+            );
+    const markdownSplitPath = (
+        markdownSplitPathSource
+        && isSupportedMarkdownPath(markdownSplitPathSource)
+        && (
+            openFiles.includes(markdownSplitPathSource)
+            || fallbackOpenFiles.includes(markdownSplitPathSource)
+        )
+    )
+        ? markdownSplitPathSource
+        : '';
+    const activeWorkspaceTabKey = typeof source.activeWorkspaceTabKey === 'string'
+        ? source.activeWorkspaceTabKey
+        : (
+            typeof base.activeWorkspaceTabKey === 'string'
+                ? base.activeWorkspaceTabKey
+                : ''
+        );
     return {
         updatedAt,
         updatedBy,
         isVisible: !!source.isVisible,
-        openFiles: uniqueStringList(source.openFiles),
+        openFiles,
         terminalDisplayMode: source.terminalDisplayMode === 'tab'
             ? 'tab'
             : 'auto',
-        expandedPaths: uniqueStringList(source.expandedPaths)
+        expandedPaths: uniqueStringList(source.expandedPaths),
+        markdownSplitPath,
+        activeWorkspaceTabKey
     };
 }
 
@@ -299,6 +529,8 @@ function buildWorkspaceSnapshotForSession(session, overrides = {}) {
         openFiles: session.editorState.openFiles,
         terminalDisplayMode: session.sharedWorkspaceState.terminalDisplayMode,
         expandedPaths: session.sharedWorkspaceState.expandedPaths,
+        markdownSplitPath: session.workspaceState.markdownSplitPath,
+        activeWorkspaceTabKey: session.workspaceState.activeTabKey,
         ...overrides
     });
 }
@@ -709,6 +941,26 @@ class EditorManager {
         this.monacoContainer = document.getElementById('monaco-container');
         this.imagePreviewContainer = document.getElementById('image-preview-container');
         this.imagePreview = document.getElementById('image-preview');
+        this.pdfPreviewContainer = document.getElementById(
+            'pdf-preview-container'
+        );
+        this.pdfPreviewStatus = document.getElementById('pdf-preview-status');
+        this.pdfPreviewStatusPrimary = document.getElementById(
+            'pdf-preview-status-primary'
+        );
+        this.pdfPreviewStatusSecondary = document.getElementById(
+            'pdf-preview-status-secondary'
+        );
+        this.pdfPreviewPages = document.getElementById('pdf-preview-pages');
+        this.markdownPreviewContainer = document.getElementById(
+            'markdown-preview-container'
+        );
+        this.markdownPreviewScroll = document.getElementById(
+            'markdown-preview-scroll'
+        );
+        this.markdownPreviewContent = document.getElementById(
+            'markdown-preview-content'
+        );
         this.emptyState = document.getElementById('empty-editor-state');
         this.terminalWrapper = terminalWrapper;
         this.terminalOriginalParent = terminalWrapper?.parentElement || null;
@@ -758,17 +1010,47 @@ class EditorManager {
         this.agentEmbeddedEditors = [];
         this.agentEmbeddedTerminals = new Map();
         this.agentTranscriptLayout = null;
+        this.pdfPreviewState = {
+            path: '',
+            sessionKey: '',
+            renderToken: 0,
+            document: null,
+            loadingTask: null,
+            metadata: '',
+            renderedWidth: 0,
+            relayoutTimer: 0
+        };
+        this.markdownPreviewState = {
+            path: '',
+            sessionKey: '',
+            renderToken: 0,
+            renderTimer: 0,
+            pendingHash: ''
+        };
+        this.fileVersionCheckTimer = null;
+        this.fileVersionCheckPromise = null;
+        this.fileConflictDialogKey = '';
+        this.suppressFileWriteCapture = false;
         this.agentTranscriptResizeObserver = null;
+        this.treeDirectoryFetches = new Map();
+        this.treeRefreshInFlight = false;
+        this.treeRefreshRerunRequested = false;
+        this.treeRefreshBatchQueued = false;
+        this.pendingForcedTreeRefreshSessions = new Set();
 
         this.initTerminalControls();
         this.initResizer();
         this.initAgentPanel();
+        this.initMarkdownPreview();
         this.initMonaco();
         this.loadIconMap();
         this.agentTimestampTimer = window.setInterval(() => {
             this.refreshAgentTimelineTimestamps();
             this.refreshAgentUsageHud();
         }, 1000);
+        this.fileVersionCheckTimer = window.setInterval(() => {
+            void this.checkActiveFileVersion();
+        }, FILE_VERSION_CHECK_INTERVAL_MS);
     }
 
     isTerminalTabPinned(session = this.currentSession) {
@@ -811,6 +1093,155 @@ class EditorManager {
         this.terminalWrapper.appendChild(this.terminalLayoutButton);
     }
 
+    initMarkdownPreview() {
+        if (!this.markdownPreviewContainer || !this.markdownPreviewContent) {
+            return;
+        }
+        this.markdownPreviewContainer.addEventListener('click', (event) => {
+            const link = event.target.closest('a[data-markdown-local-path]');
+            if (!link) {
+                return;
+            }
+            const filePath = String(
+                link.dataset.markdownLocalPath || ''
+            ).trim();
+            if (!filePath) {
+                return;
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            void this.openLocalMarkdownLink(
+                filePath,
+                String(link.dataset.markdownLocalHash || '')
+            );
+        });
+    }
+
+    getMarkdownSplitPath(session = this.currentSession) {
+        if (!session?.workspaceState) {
+            return '';
+        }
+        return typeof session.workspaceState.markdownSplitPath === 'string'
+            ? session.workspaceState.markdownSplitPath
+            : '';
+    }
+
+    isMarkdownSplitViewEnabled(
+        session = this.currentSession,
+        filePath = session?.editorState?.activeFilePath || ''
+    ) {
+        return !!(
+            session
+            && canUseMarkdownSplitTabsMode()
+            && filePath
+            && this.getMarkdownSplitPath(session) === filePath
+            && isSupportedMarkdownPath(filePath)
+        );
+    }
+
+    setMarkdownSplitView(
+        filePath,
+        enabled,
+        session = this.currentSession
+    ) {
+        if (!session?.workspaceState || !isSupportedMarkdownPath(filePath)) {
+            return;
+        }
+        const nextMarkdownSplitPath = (
+            enabled
+            && canUseMarkdownSplitTabsMode()
+        )
+            ? filePath
+            : '';
+        if (session.workspaceState.markdownSplitPath === nextMarkdownSplitPath) {
+            return;
+        }
+        session.workspaceState.markdownSplitPath = nextMarkdownSplitPath;
+        session.saveState({ touchWorkspace: true });
+        if (session.key !== this.currentSession?.key) {
+            return;
+        }
+        this.renderEditorTabs();
+        const activeKey = this.getActiveWorkspaceTabKey(session);
+        if (
+            activeKey === makeFileWorkspaceTabKey(filePath)
+            || activeKey === makeMarkdownPreviewWorkspaceTabKey(filePath)
+        ) {
+            this.activateWorkspaceTab(activeKey, true);
+        }
+        this.layout();
+    }
+
+    syncMarkdownSplitSupport(session = this.currentSession) {
+        if (!session?.workspaceState) {
+            return;
+        }
+        const markdownSplitPath = this.getMarkdownSplitPath(session);
+        if (
+            markdownSplitPath
+            && (
+                !isSupportedMarkdownPath(markdownSplitPath)
+                || !session.editorState.openFiles.includes(markdownSplitPath)
+            )
+        ) {
+            session.workspaceState.markdownSplitPath = '';
+        }
+    }
+
+    showMarkdownSplitView(filePath, options = {}) {
+        const session = options.session || this.currentSession;
+        const focusEditor = options.focusEditor !== false;
+        if (!session || !filePath) {
+            return false;
+        }
+        const file = this.getModel(filePath, session);
+        if (!file || file.type !== 'text') {
+            return false;
+        }
+        if (!this.editor || !this.monacoContainer || !this.contentContainer) {
+            return false;
+        }
+
+        this.contentContainer.classList.add('markdown-split-active');
+        this.agentContainer.style.display = 'none';
+        this.imagePreviewContainer.style.display = 'none';
+        this.hidePdfPreview();
+        this.monacoContainer.style.display = 'block';
+        this.markdownPreviewContainer.style.display = 'flex';
+        this.emptyState.style.display = 'none';
+
+        if (!file.model && file.content !== null && this.monacoInstance) {
+            file.model = this.monacoInstance.editor.createModel(
+                file.content,
+                undefined,
+                this.monacoInstance.Uri.file(filePath)
+            );
+        }
+
+        if (file.model) {
+            this.editor.setModel(file.model);
+            this.editor.updateOptions({ readOnly: !!file.readonly });
+            const savedViewState = session.editorState.viewStates.get(filePath);
+            if (savedViewState) {
+                this.editor.restoreViewState(savedViewState);
+            }
+        }
+
+        void this.renderMarkdownPreview(filePath, {
+            session,
+            show: true
+        });
+
+        requestAnimationFrame(() => {
+            this.layout();
+            if (focusEditor && this.editor) {
+                this.editor.focus();
+            }
+        });
+
+        return true;
+    }
+
     updateTerminalLayoutButton() {
         if (!this.terminalLayoutButton) return;
 
@@ -900,7 +1331,13 @@ class EditorManager {
             }
         } else if (isFileWorkspaceTabKey(lastNonTerminal)) {
             const filePath = workspaceKeyToFilePath(lastNonTerminal);
-            if (session.editorState.openFiles.includes(filePath)) {
+            if (
+                session.editorState.openFiles.includes(filePath)
+                && (
+                    !isMarkdownPreviewWorkspaceTabKey(lastNonTerminal)
+                    || isSupportedMarkdownPath(filePath)
+                )
+            ) {
                 return lastNonTerminal;
             }
         }
@@ -1445,6 +1882,12 @@ class EditorManager {
                 && session.editorState.openFiles.includes(
                     workspaceKeyToFilePath(explicitKey)
                 )
+                && (
+                    !isMarkdownPreviewWorkspaceTabKey(explicitKey)
+                    || isSupportedMarkdownPath(
+                        workspaceKeyToFilePath(explicitKey)
+                    )
+                )
             ) {
                 return explicitKey;
             }
@@ -1485,82 +1928,555 @@ class EditorManager {
         store.set(filePath, value);
     }
 
-    remapTreePath(pathValue, oldPath, newPath, isDirectory) {
-        if (typeof pathValue !== 'string' || pathValue.length === 0) {
-            return pathValue;
-        }
-        if (pathValue === oldPath) {
-            return newPath;
-        }
-        if (
-            isDirectory
-            && pathValue.startsWith(`${oldPath}/`)
-        ) {
-            return `${newPath}${pathValue.slice(oldPath.length)}`;
+    normalizePendingFileWrite(write, entry = null) {
+        if (write && typeof write === 'object' && !Array.isArray(write)) {
+            return {
+                content: typeof write.content === 'string' ? write.content : '',
+                expectedVersion: typeof write.expectedVersion === 'string'
+                    ? write.expectedVersion
+                    : (
+                        typeof entry?.version === 'string'
+                            ? entry.version
+                            : ''
+                    ),
+                blocked: write.blocked === true,
+                force: write.force === true
+            };
         }
-        return pathValue;
+        return {
+            content: typeof write === 'string' ? write : '',
+            expectedVersion: typeof entry?.version === 'string'
+                ? entry.version
+                : '',
+            blocked: false,
+            force: false
+        };
     }
 
-    remapWorkspaceTabKey(key, oldPath, newPath, isDirectory) {
-        if (!isFileWorkspaceTabKey(key)) return key;
-        const filePath = workspaceKeyToFilePath(key);
-        const nextPath = this.remapTreePath(
-            filePath,
-            oldPath,
-            newPath,
-            isDirectory
+    queuePendingFileWrite(session, filePath, content, overrides = {}) {
+        if (!session || !filePath) return;
+        const pending = getPendingSession(session.key);
+        const entry = this.getModel(filePath, session);
+        const previous = this.normalizePendingFileWrite(
+            pending.fileWrites.get(filePath),
+            entry
         );
-        return nextPath ? makeFileWorkspaceTabKey(nextPath) : key;
+        pending.fileWrites.set(filePath, {
+            ...previous,
+            content,
+            expectedVersion: typeof overrides.expectedVersion === 'string'
+                ? overrides.expectedVersion
+                : previous.expectedVersion,
+            blocked: overrides.blocked ?? false,
+            force: overrides.force ?? false
+        });
     }
 
-    cloneRenamedModelEntry(entry, nextPath) {
-        if (!entry || typeof entry !== 'object') return entry;
-        const nextEntry = {
-            ...entry
-        };
-        if (nextEntry.model) {
-            let nextContent = nextEntry.content;
-            try {
-                if (typeof nextEntry.model.getValue === 'function') {
-                    nextContent = nextEntry.model.getValue();
-                }
-            } catch {
-                // Ignore content extraction failure and keep cached content.
-            }
-            nextEntry.content = nextContent;
+    getPendingFileWrite(session, filePath) {
+        if (!session || !filePath) return null;
+        const pending = getPendingSession(session.key);
+        if (!pending?.fileWrites?.has(filePath)) {
+            return null;
+        }
+        return this.normalizePendingFileWrite(
+            pending.fileWrites.get(filePath),
+            this.getModel(filePath, session)
+        );
+    }
 
-            if (
-                this.monacoInstance
-                && typeof nextEntry.model.getLanguageId === 'function'
-            ) {
-                const oldModel = nextEntry.model;
-                const languageId = oldModel.getLanguageId();
-                const uri = this.monacoInstance.Uri.file(nextPath);
-                const existingModel = this.monacoInstance.editor.getModel(uri);
-                if (existingModel && existingModel !== oldModel) {
-                    existingModel.setValue(nextContent ?? '');
-                    nextEntry.model = existingModel;
-                } else {
-                    nextEntry.model = this.monacoInstance.editor.createModel(
-                        nextContent ?? '',
-                        languageId,
-                        uri
-                    );
-                }
-                if (nextEntry.model !== oldModel) {
-                    try {
-                        oldModel.dispose();
-                    } catch {
-                        // Ignore disposal failures for stale models.
-                    }
-                }
-                return nextEntry;
-            }
+    getTextFileEntry(filePath, session = this.currentSession) {
+        const entry = this.getModel(filePath, session);
+        if (!entry || entry.type !== 'text') {
+            return null;
         }
-        return nextEntry;
+        if (typeof entry.contentVersion !== 'string') {
+            entry.contentVersion = typeof entry.version === 'string'
+                ? entry.version
+                : '';
+        }
+        return entry;
     }
 
-    remapModelStorePaths(server, oldPath, newPath, isDirectory) {
+    getCurrentTextFileContent(filePath, session = this.currentSession) {
+        const entry = this.getTextFileEntry(filePath, session);
+        if (!entry) return '';
+        try {
+            if (typeof entry.model?.getValue === 'function') {
+                return entry.model.getValue();
+            }
+        } catch {
+            // Ignore model access failures and fall back to cached content.
+        }
+        return typeof entry.content === 'string' ? entry.content : '';
+    }
+
+    isActiveTextFile(session, filePath) {
+        if (!session || !filePath) return false;
+        if (this.currentSession?.key !== session.key) return false;
+        if (state.activeSessionKey !== session.key) return false;
+        if (session.editorState.activeFilePath !== filePath) return false;
+        return this.getActiveWorkspaceTabKey(session)
+            === makeFileWorkspaceTabKey(filePath);
+    }
+
+    updateTextFileEntry(filePath, updates, session = this.currentSession) {
+        const entry = this.getTextFileEntry(filePath, session);
+        if (!entry || !updates || typeof updates !== 'object') {
+            return null;
+        }
+        Object.assign(entry, updates);
+        return entry;
+    }
+
+    updateActiveEditorReadOnlyState(session, filePath, readonly) {
+        if (!this.isActiveTextFile(session, filePath) || !this.editor) {
+            return;
+        }
+        this.editor.updateOptions({ readOnly: !!readonly });
+        this.renderEditorTabs();
+    }
+
+    applyProgrammaticTextContent(entry, nextContent) {
+        if (
+            !entry?.model
+            || typeof entry.model.getValue !== 'function'
+            || typeof entry.model.setValue !== 'function'
+        ) {
+            entry.content = nextContent;
+            return;
+        }
+        const currentValue = entry.model.getValue();
+        if (currentValue === nextContent) {
+            entry.content = nextContent;
+            return;
+        }
+        this.suppressFileWriteCapture = true;
+        try {
+            entry.model.setValue(nextContent);
+        } finally {
+            this.suppressFileWriteCapture = false;
+        }
+        entry.content = nextContent;
+    }
+
+    async readTextFileSnapshot(session, filePath) {
+        if (!session || !filePath) {
+            throw new Error('File path required');
+        }
+        const response = await session.server.fetch(
+            `/api/fs/read?path=${encodeURIComponent(filePath)}`
+        );
+        if (!response.ok) {
+            await throwResponseError(response, 'Failed to read file');
+        }
+        return await response.json();
+    }
+
+    async readTextFileInfo(session, filePath) {
+        if (!session || !filePath) {
+            throw new Error('File path required');
+        }
+        const response = await session.server.fetch(
+            `/api/fs/info?path=${encodeURIComponent(filePath)}`
+        );
+        if (!response.ok) {
+            await throwResponseError(response, 'Failed to inspect file');
+        }
+        return await response.json();
+    }
+
+    applyTextFileSnapshot(session, filePath, snapshot, options = {}) {
+        const entry = this.getTextFileEntry(filePath, session);
+        if (!entry || !snapshot || typeof snapshot !== 'object') {
+            return null;
+        }
+        const useLocalContent = options.useLocalContent === true;
+        const nextReadonly = !!snapshot.readonly;
+        const nextVersion = typeof snapshot.version === 'string'
+            ? snapshot.version
+            : entry.version || '';
+        const nextContent = typeof snapshot.content === 'string'
+            ? snapshot.content
+            : entry.content || '';
+
+        if (!entry.model && this.monacoInstance) {
+            const uri = this.monacoInstance.Uri.file(filePath);
+            const existing = this.monacoInstance.editor.getModel(uri);
+            entry.model = existing || this.monacoInstance.editor.createModel(
+                typeof entry.content === 'string' ? entry.content : '',
+                undefined,
+                uri
+            );
+        }
+
+        if (!useLocalContent) {
+            const restoreViewState = (
+                this.isActiveTextFile(session, filePath)
+                && this.editor
+                && this.editor.getModel?.() === entry.model
+            )
+                ? this.editor.saveViewState()
+                : null;
+            this.applyProgrammaticTextContent(entry, nextContent);
+            if (restoreViewState && this.editor) {
+                this.editor.restoreViewState(restoreViewState);
+            }
+            entry.contentVersion = nextVersion;
+        } else if (typeof snapshot.content === 'string') {
+            entry.content = snapshot.content;
+            entry.contentVersion = nextVersion;
+        }
+
+        entry.version = nextVersion;
+        entry.readonly = nextReadonly;
+        entry.size = Number.isFinite(snapshot.size) ? snapshot.size : entry.size;
+        entry.mtimeMs = Number.isFinite(snapshot.mtimeMs)
+            ? snapshot.mtimeMs
+            : entry.mtimeMs;
+        entry.lastDismissedRemoteVersion = '';
+        this.updateActiveEditorReadOnlyState(session, filePath, nextReadonly);
+        if (
+            this.currentSession?.key === session.key
+            && isSupportedMarkdownPath(filePath)
+            && this.currentSession.editorState.activeFilePath === filePath
+        ) {
+            this.scheduleMarkdownPreviewRender(filePath, session);
+        }
+        return entry;
+    }
+
+    getFileConflictDialogKey(session, filePath, version, source) {
+        return [
+            session?.key || '',
+            filePath || '',
+            version || '',
+            source || ''
+        ].join(':');
+    }
+
+    async promptTextFileConflict(session, filePath, snapshot, source) {
+        if (!session || !filePath || !snapshot) {
+            return 'dismiss';
+        }
+        const version = typeof snapshot.version === 'string'
+            ? snapshot.version
+            : '';
+        const dialogKey = this.getFileConflictDialogKey(
+            session,
+            filePath,
+            version,
+            source
+        );
+        if (this.fileConflictDialogKey === dialogKey) {
+            return 'dismiss';
+        }
+        this.fileConflictDialogKey = dialogKey;
+        const fileName = filePath.split('/').pop() || filePath;
+        const keepLocal = await showConfirmModal({
+            title: source === 'save-conflict'
+                ? 'Save Conflict'
+                : 'File Changed on Disk',
+            message: source === 'save-conflict'
+                ? `“${fileName}” changed on disk before Tabminal could save it.`
+                : `“${fileName}” was modified outside Tabminal.`,
+            note: 'Use Remote reloads the disk version. Use Local keeps your '
+                + 'current editor contents and overwrites the remote change '
+                + 'on the next save.',
+            confirmLabel: 'Use Local',
+            cancelLabel: 'Use Remote',
+            preferredFocus: 'cancel',
+            allowDismiss: false,
+            returnFocus: this.isActiveTextFile(session, filePath)
+                ? this.monacoContainer
+                : document.activeElement
+        });
+        this.fileConflictDialogKey = '';
+        return keepLocal ? 'local' : 'remote';
+    }
+
+    async resolveTextFileConflict(session, filePath, snapshot, source) {
+        const entry = this.getTextFileEntry(filePath, session);
+        if (!entry || !snapshot) {
+            return;
+        }
+        const decision = await this.promptTextFileConflict(
+            session,
+            filePath,
+            snapshot,
+            source
+        );
+        if (decision === 'remote') {
+            const remoteSnapshot = typeof snapshot.content === 'string'
+                ? snapshot
+                : await this.readTextFileSnapshot(session, filePath);
+            this.applyTextFileSnapshot(session, filePath, remoteSnapshot);
+            this.clearPendingFileWrite(session.key, filePath);
+            if (this.isActiveTextFile(session, filePath)) {
+                this.renderEditorTabs();
+            }
+            return;
+        }
+
+        if (decision === 'local') {
+            const currentContent = this.getCurrentTextFileContent(
+                filePath,
+                session
+            );
+            this.applyTextFileSnapshot(session, filePath, snapshot, {
+                useLocalContent: true
+            });
+            this.queuePendingFileWrite(session, filePath, currentContent, {
+                expectedVersion: typeof snapshot.version === 'string'
+                    ? snapshot.version
+                    : entry.version || '',
+                blocked: false,
+                force: false
+            });
+            requestImmediateServerSync(session.server, 0);
+        }
+    }
+
+    async applyFileWriteResults(server, sessionResults, sentFileWrites) {
+        if (!server || !Array.isArray(sessionResults)) {
+            return;
+        }
+        for (const update of sessionResults) {
+            const session = state.sessions.get(
+                makeSessionKey(server.id, update?.id)
+            );
+            if (!session || !Array.isArray(update?.fileWrites)) {
+                continue;
+            }
+            for (const result of update.fileWrites) {
+                const filePath = typeof result?.path === 'string'
+                    ? result.path
+                    : '';
+                if (!filePath) continue;
+                const entry = this.getTextFileEntry(filePath, session);
+                const sentWrite = sentFileWrites?.get(update.id)?.get(filePath)
+                    || null;
+                if (!entry) {
+                    this.clearPendingFileWrite(session.key, filePath);
+                    continue;
+                }
+                if (result.status === 'ok') {
+                    const currentWrite = this.getPendingFileWrite(
+                        session,
+                        filePath
+                    );
+                    const sentContent = sentWrite?.content
+                        ?? this.getCurrentTextFileContent(filePath, session);
+                    entry.content = sentContent;
+                    entry.version = typeof result.version === 'string'
+                        ? result.version
+                        : entry.version || '';
+                    entry.contentVersion = entry.version;
+                    entry.readonly = !!result.readonly;
+                    entry.lastDismissedRemoteVersion = '';
+                    const hasNewerPendingWrite = !!(
+                        currentWrite
+                        && sentWrite
+                        && (
+                            currentWrite.content !== sentWrite.content
+                            || currentWrite.expectedVersion
+                                !== sentWrite.expectedVersion
+                            || currentWrite.force !== sentWrite.force
+                        )
+                    );
+                    if (hasNewerPendingWrite) {
+                        this.queuePendingFileWrite(
+                            session,
+                            filePath,
+                            currentWrite.content,
+                            {
+                                expectedVersion: entry.version,
+                                blocked: false,
+                                force: currentWrite.force
+                            }
+                        );
+                    } else {
+                        this.clearPendingFileWrite(session.key, filePath);
+                    }
+                    this.updateActiveEditorReadOnlyState(
+                        session,
+                        filePath,
+                        entry.readonly
+                    );
+                    continue;
+                }
+                if (result.status === 'conflict') {
+                    this.queuePendingFileWrite(
+                        session,
+                        filePath,
+                        this.getCurrentTextFileContent(filePath, session),
+                        {
+                            expectedVersion: typeof result.version === 'string'
+                                ? result.version
+                                : entry.version || '',
+                            blocked: true,
+                            force: false
+                        }
+                    );
+                    await this.resolveTextFileConflict(
+                        session,
+                        filePath,
+                        result,
+                        'save-conflict'
+                    );
+                    continue;
+                }
+                this.queuePendingFileWrite(
+                    session,
+                    filePath,
+                    this.getCurrentTextFileContent(filePath, session),
+                    {
+                        blocked: true
+                    }
+                );
+                alert(result?.error || 'Failed to save file.', {
+                    type: 'error',
+                    title: 'Save Error'
+                });
+            }
+        }
+    }
+
+    async checkActiveFileVersion() {
+        if (
+            this.fileVersionCheckPromise
+            || document.visibilityState === 'hidden'
+            || isConfirmModalOpen()
+        ) {
+            return;
+        }
+        const session = this.currentSession;
+        const filePath = session?.editorState?.activeFilePath || '';
+        if (!this.isActiveTextFile(session, filePath)) {
+            return;
+        }
+        const entry = this.getTextFileEntry(filePath, session);
+        if (!entry || entry.readonly) {
+            return;
+        }
+        this.fileVersionCheckPromise = (async () => {
+            try {
+                const info = await this.readTextFileInfo(session, filePath);
+                if (
+                    !info
+                    || typeof info.version !== 'string'
+                    || !info.version
+                    || info.version === entry.version
+                    || info.version === entry.lastDismissedRemoteVersion
+                ) {
+                    return;
+                }
+                const pendingWrite = this.getPendingFileWrite(session, filePath);
+                if (pendingWrite?.blocked) {
+                    return;
+                }
+                await this.resolveTextFileConflict(
+                    session,
+                    filePath,
+                    info,
+                    'remote-change'
+                );
+            } catch (error) {
+                console.warn('Failed to check file version:', error);
+            }
+        })();
+        try {
+            await this.fileVersionCheckPromise;
+        } finally {
+            this.fileVersionCheckPromise = null;
+        }
+    }
+
+    clearPendingFileWrite(sessionKey, filePath) {
+        const pending = pendingChanges.sessions.get(sessionKey);
+        pending?.fileWrites?.delete(filePath);
+    }
+
+    remapTreePath(pathValue, oldPath, newPath, isDirectory) {
+        if (typeof pathValue !== 'string' || pathValue.length === 0) {
+            return pathValue;
+        }
+        if (pathValue === oldPath) {
+            return newPath;
+        }
+        if (
+            isDirectory
+            && pathValue.startsWith(`${oldPath}/`)
+        ) {
+            return `${newPath}${pathValue.slice(oldPath.length)}`;
+        }
+        return pathValue;
+    }
+
+    remapWorkspaceTabKey(key, oldPath, newPath, isDirectory) {
+        if (!isFileWorkspaceTabKey(key)) return key;
+        const filePath = workspaceKeyToFilePath(key);
+        const nextPath = this.remapTreePath(
+            filePath,
+            oldPath,
+            newPath,
+            isDirectory
+        );
+        if (!nextPath) {
+            return key;
+        }
+        return isMarkdownPreviewWorkspaceTabKey(key)
+            ? makeMarkdownPreviewWorkspaceTabKey(nextPath)
+            : makeFileWorkspaceTabKey(nextPath);
+    }
+
+    cloneRenamedModelEntry(entry, nextPath) {
+        if (!entry || typeof entry !== 'object') return entry;
+        const nextEntry = {
+            ...entry
+        };
+        if (nextEntry.model) {
+            let nextContent = nextEntry.content;
+            try {
+                if (typeof nextEntry.model.getValue === 'function') {
+                    nextContent = nextEntry.model.getValue();
+                }
+            } catch {
+                // Ignore content extraction failure and keep cached content.
+            }
+            nextEntry.content = nextContent;
+
+            if (
+                this.monacoInstance
+                && typeof nextEntry.model.getLanguageId === 'function'
+            ) {
+                const oldModel = nextEntry.model;
+                const languageId = oldModel.getLanguageId();
+                const uri = this.monacoInstance.Uri.file(nextPath);
+                const existingModel = this.monacoInstance.editor.getModel(uri);
+                if (existingModel && existingModel !== oldModel) {
+                    existingModel.setValue(nextContent ?? '');
+                    nextEntry.model = existingModel;
+                } else {
+                    nextEntry.model = this.monacoInstance.editor.createModel(
+                        nextContent ?? '',
+                        languageId,
+                        uri
+                    );
+                }
+                if (nextEntry.model !== oldModel) {
+                    try {
+                        oldModel.dispose();
+                    } catch {
+                        // Ignore disposal failures for stale models.
+                    }
+                }
+                return nextEntry;
+            }
+        }
+        return nextEntry;
+    }
+
+    remapModelStorePaths(server, oldPath, newPath, isDirectory) {
         if (!server?.modelStore) return false;
         const nextEntries = [];
         let changed = false;
@@ -1712,6 +2628,17 @@ class EditorManager {
             visualChanged = true;
         }
 
+        const nextMarkdownSplitPath = this.remapTreePath(
+            this.getMarkdownSplitPath(session),
+            oldPath,
+            newPath,
+            isDirectory
+        );
+        if (nextMarkdownSplitPath !== this.getMarkdownSplitPath(session)) {
+            session.workspaceState.markdownSplitPath = nextMarkdownSplitPath;
+            visualChanged = true;
+        }
+
         const nextActiveTabKey = this.remapWorkspaceTabKey(
             session.workspaceState.activeTabKey,
             oldPath,
@@ -1840,6 +2767,17 @@ class EditorManager {
             visualChanged = true;
         }
 
+        if (
+            this.pathMatchesTarget(
+                this.getMarkdownSplitPath(session),
+                targetPath,
+                isDirectory
+            )
+        ) {
+            session.workspaceState.markdownSplitPath = '';
+            visualChanged = true;
+        }
+
         if (session.editorState.viewStates.size > 0) {
             const nextViewStates = new Map();
             let changed = false;
@@ -2138,24 +3076,7 @@ class EditorManager {
     }
 
     refreshSessionTree(session) {
-        if (!session || !session.fileTreeElement) return;
-        session.fileTreeRenderToken = (session.fileTreeRenderToken || 0) + 1;
-        const renderToken = session.fileTreeRenderToken;
-        const scrollTop = session.fileTreeElement.scrollTop;
-        void this.renderTree(
-            session.cwd,
-            session.fileTreeElement,
-            session,
-            renderToken
-        ).finally(() => {
-            if (
-                session.fileTreeElement
-                && session.fileTreeRenderToken === renderToken
-            ) {
-                session.fileTreeElement.scrollTop = scrollTop;
-            }
-        });
-        this.updateTreeAutoRefresh();
+        this.requestSessionTreeRefresh(session);
     }
 
     isSessionTreeVisible(session) {
@@ -2166,29 +3087,186 @@ class EditorManager {
         return this.isSessionTreeVisible(session) && !session.treeEditingPath;
     }
 
-    refreshVisibleSessionTrees() {
-        for (const session of state.sessions.values()) {
-            if (this.canRefreshSessionTree(session)) {
-                this.requestSessionTreeRefresh(session);
+    refreshVisibleSessionTrees() {
+        this.requestVisibleTreeRefresh();
+    }
+
+    requestSessionTreeRefresh(session, { force = false } = {}) {
+        if (!session?.fileTreeElement) {
+            this.updateTreeAutoRefresh();
+            return;
+        }
+        if (!force && !this.canRefreshSessionTree(session)) {
+            this.updateTreeAutoRefresh();
+            return;
+        }
+        if (force) {
+            this.pendingForcedTreeRefreshSessions.add(session.key);
+        }
+        this.scheduleTreeRefreshBatch();
+    }
+
+    requestVisibleTreeRefresh() {
+        this.scheduleTreeRefreshBatch();
+    }
+
+    scheduleTreeRefreshBatch() {
+        if (this.treeRefreshBatchQueued) {
+            return;
+        }
+        this.treeRefreshBatchQueued = true;
+        requestAnimationFrame(() => {
+            this.treeRefreshBatchQueued = false;
+            void this.flushTreeRefreshBatch();
+        });
+    }
+
+    getTreeRefreshRequestKey(server, dirPath) {
+        return `${server?.id || 'main'}:${dirPath}`;
+    }
+
+    getSessionTreeRefreshPaths(session) {
+        if (!session?.cwd) {
+            return [];
+        }
+        return uniqueStringList([
+            session.cwd,
+            ...(session.sharedWorkspaceState?.expandedPaths || [])
+        ]);
+    }
+
+    collectTreeRefreshSessions() {
+        const sessions = [];
+        for (const session of state.sessions.values()) {
+            if (this.canRefreshSessionTree(session)) {
+                sessions.push(session);
+                continue;
+            }
+            if (
+                this.pendingForcedTreeRefreshSessions.has(session.key)
+                && this.isSessionTreeVisible(session)
+            ) {
+                sessions.push(session);
+            }
+        }
+        return sessions;
+    }
+
+    async fetchTreeDirectoryListing(server, dirPath) {
+        const key = this.getTreeRefreshRequestKey(server, dirPath);
+        const existing = this.treeDirectoryFetches.get(key);
+        if (existing) {
+            return existing;
+        }
+
+        const request = (async () => {
+            const response = await server.fetch(
+                `/api/fs/list?path=${encodeURIComponent(dirPath)}`
+            );
+            if (!response.ok) {
+                throw new Error(`Failed to list path: ${dirPath}`);
+            }
+            const payload = await response.json();
+            return {
+                files: Array.isArray(payload)
+                    ? payload
+                    : Array.isArray(payload?.items)
+                        ? payload.items
+                        : [],
+                creatable: Array.isArray(payload)
+                    ? false
+                    : !!payload?.creatable
+            };
+        })().finally(() => {
+            this.treeDirectoryFetches.delete(key);
+        });
+
+        this.treeDirectoryFetches.set(key, request);
+        return request;
+    }
+
+    async flushTreeRefreshBatch() {
+        if (this.treeRefreshInFlight) {
+            this.treeRefreshRerunRequested = true;
+            return;
+        }
+
+        const sessions = this.collectTreeRefreshSessions();
+        this.pendingForcedTreeRefreshSessions.clear();
+        if (sessions.length === 0) {
+            this.updateTreeAutoRefresh();
+            return;
+        }
+
+        this.treeRefreshInFlight = true;
+        const renderPlans = sessions.map((session) => {
+            session.fileTreeRenderToken = (session.fileTreeRenderToken || 0) + 1;
+            return {
+                session,
+                renderToken: session.fileTreeRenderToken,
+                scrollTop: session.fileTreeElement?.scrollTop || 0
+            };
+        });
+
+        const requestEntries = new Map();
+        for (const { session } of renderPlans) {
+            for (const dirPath of this.getSessionTreeRefreshPaths(session)) {
+                requestEntries.set(
+                    this.getTreeRefreshRequestKey(session.server, dirPath),
+                    {
+                        server: session.server,
+                        dirPath
+                    }
+                );
+            }
+        }
+
+        const directorySnapshots = new Map();
+        await Promise.all(
+            Array.from(requestEntries.entries()).map(
+                async ([key, entry]) => {
+                    try {
+                        directorySnapshots.set(
+                            key,
+                            await this.fetchTreeDirectoryListing(
+                                entry.server,
+                                entry.dirPath
+                            )
+                        );
+                    } catch (error) {
+                        console.error(
+                            'Failed to fetch tree directory:',
+                            entry.dirPath,
+                            error
+                        );
+                    }
+                }
+            )
+        );
+
+        for (const plan of renderPlans) {
+            const { session, renderToken, scrollTop } = plan;
+            if (!session.fileTreeElement) {
+                continue;
+            }
+            this.renderTreeFromSnapshots(
+                session.cwd,
+                session.fileTreeElement,
+                session,
+                directorySnapshots,
+                renderToken
+            );
+            if (session.fileTreeRenderToken === renderToken) {
+                session.fileTreeElement.scrollTop = scrollTop;
             }
         }
-    }
 
-    requestSessionTreeRefresh(session, { force = false } = {}) {
-        if (!force && !this.canRefreshSessionTree(session)) {
-            this.updateTreeAutoRefresh();
-            return;
+        this.treeRefreshInFlight = false;
+        this.updateTreeAutoRefresh();
+        if (this.treeRefreshRerunRequested) {
+            this.treeRefreshRerunRequested = false;
+            this.scheduleTreeRefreshBatch();
         }
-        if (session.fileTreeRefreshQueued) return;
-        session.fileTreeRefreshQueued = true;
-        requestAnimationFrame(() => {
-            session.fileTreeRefreshQueued = false;
-            if (force || this.canRefreshSessionTree(session)) {
-                this.refreshSessionTree(session);
-            } else {
-                this.updateTreeAutoRefresh();
-            }
-        });
     }
 
     updateTreeAutoRefresh() {
@@ -2198,7 +3276,7 @@ class EditorManager {
                 (session) => this.canRefreshSessionTree(session)
             )
         );
-        if (shouldRun && !this.treeRefreshTimer) {
+            if (shouldRun && !this.treeRefreshTimer) {
             this.treeRefreshTimer = window.setInterval(() => {
                 if (document.visibilityState !== 'visible') {
                     this.updateTreeAutoRefresh();
@@ -2211,7 +3289,7 @@ class EditorManager {
                     this.updateTreeAutoRefresh();
                     return;
                 }
-                this.refreshVisibleSessionTrees();
+                this.requestVisibleTreeRefresh();
             }, FILE_TREE_REFRESH_INTERVAL_MS);
             return;
         }
@@ -2405,7 +3483,7 @@ class EditorManager {
                 isDirectory: !!payload.isDirectory,
                 renameable: true
             });
-        } catch (error) {
+        } catch (_error) {
             alert(error.message || 'Failed to create path', {
                 type: 'error',
                 title: 'Files'
@@ -2477,7 +3555,7 @@ class EditorManager {
             );
             this.requestSessionTreeRefresh(session);
             session.fileTreeElement?.focus({ preventScroll: true });
-        } catch (error) {
+        } catch (_error) {
             alert(error.message || 'Failed to delete path', {
                 type: 'error',
                 title: 'Files'
@@ -2652,7 +3730,7 @@ class EditorManager {
         list.appendChild(row);
     }
 
-    updateTreeItem(li, file, session, renderToken) {
+    updateTreeItem(li, file, session) {
         li.dataset.path = file.path;
         li.dataset.isDirectory = file.isDirectory ? '1' : '0';
         li.dataset.renameable = file.renameable ? '1' : '0';
@@ -2870,7 +3948,7 @@ class EditorManager {
                 });
 
                 icon.innerHTML = this.getIcon(file.name, true, true);
-                await this.renderTree(file.path, li, session, renderToken);
+                this.requestSessionTreeRefresh(session);
                 this.updateTreeAutoRefresh();
                 session.fileTreeElement?.focus({ preventScroll: true });
                 return;
@@ -2914,7 +3992,7 @@ class EditorManager {
         }
     }
 
-    reconcileTreeList(list, dirPath, files, creatable, session, renderToken) {
+    reconcileTreeList(list, dirPath, files, creatable, session) {
         const existingItems = new Map();
         Array.from(list.children).forEach((child) => {
             if (child.tagName === 'LI' && child.dataset.path) {
@@ -2930,7 +4008,7 @@ class EditorManager {
             } else {
                 existingItems.delete(file.path);
             }
-            this.updateTreeItem(li, file, session, renderToken);
+            this.updateTreeItem(li, file, session);
             orderedItems.push(li);
         }
 
@@ -2962,12 +4040,32 @@ class EditorManager {
             });
             
             this.editor.onDidChangeModelContent(() => {
+                if (this.suppressFileWriteCapture) return;
                 if (!this.currentSession) return;
                 const filePath = this.currentSession.editorState.activeFilePath;
                 if (!filePath) return;
-                
-                const pending = getPendingSession(this.currentSession.key);
-                pending.fileWrites.set(filePath, this.editor.getValue());
+                const entry = this.getTextFileEntry(filePath, this.currentSession);
+                if (!entry) return;
+                const nextContent = this.editor.getValue();
+                if (
+                    nextContent === (entry.content || '')
+                    && (entry.contentVersion || '') === (entry.version || '')
+                ) {
+                    this.clearPendingFileWrite(this.currentSession.key, filePath);
+                    return;
+                }
+                entry.lastDismissedRemoteVersion = '';
+                this.queuePendingFileWrite(
+                    this.currentSession,
+                    filePath,
+                    nextContent
+                );
+                if (isSupportedMarkdownPath(filePath)) {
+                    this.scheduleMarkdownPreviewRender(
+                        filePath,
+                        this.currentSession
+                    );
+                }
             });
             
             monaco.editor.defineTheme('solarized-dark', {
@@ -2987,22 +4085,569 @@ class EditorManager {
                     'editor.lineHighlightBackground': '#073642',
                     'editorLineNumber.foreground': '#586e75',
                 }
-            });
-            monaco.editor.setTheme('solarized-dark');
-            
-            // Process pending models
-            for (const server of state.servers.values()) {
-                for (const [path, file] of server.modelStore) {
-                    if (file.type === 'text' && !file.model && file.content !== null) {
-                        file.model = monaco.editor.createModel(file.content, undefined, monaco.Uri.file(path));
-                    }
+            });
+            monaco.editor.setTheme('solarized-dark');
+            
+            // Process pending models
+            for (const server of state.servers.values()) {
+                for (const [path, file] of server.modelStore) {
+                    if (file.type === 'text' && !file.model && file.content !== null) {
+                        file.model = monaco.editor.createModel(file.content, undefined, monaco.Uri.file(path));
+                    }
+                }
+            }
+
+            if (this.currentSession) {
+                this.switchTo(this.currentSession);
+            }
+        });
+    }
+
+    clearMarkdownPreview() {
+        const state = this.markdownPreviewState;
+        state.renderToken += 1;
+        clearTimeout(state.renderTimer);
+        state.renderTimer = 0;
+        state.path = '';
+        state.sessionKey = '';
+        state.pendingHash = '';
+        if (this.markdownPreviewContent) {
+            this.markdownPreviewContent.innerHTML = '';
+        }
+        if (this.markdownPreviewScroll) {
+            this.markdownPreviewScroll.scrollTop = 0;
+        }
+    }
+
+    hideMarkdownPreview() {
+        if (this.contentContainer) {
+            this.contentContainer.classList.remove('markdown-split-active');
+        }
+        if (this.markdownPreviewContainer) {
+            this.markdownPreviewContainer.style.display = 'none';
+        }
+    }
+
+    getMarkdownSourceContent(filePath, session = this.currentSession) {
+        const entry = this.getModel(filePath, session);
+        if (!entry || entry.type !== 'text') {
+            return '';
+        }
+        if (entry.model && typeof entry.model.getValue === 'function') {
+            return entry.model.getValue();
+        }
+        return typeof entry.content === 'string' ? entry.content : '';
+    }
+
+    resolveMarkdownPreviewImageUrl(filePath, src, session) {
+        const resolved = resolveMarkdownLocalTarget(filePath, src);
+        if (resolved && isSupportedImagePath(resolved.path)) {
+            return session.server.resolveUrl(
+                `/api/fs/raw?path=${encodeURIComponent(resolved.path)}`
+                + `&token=${session.server.token}`
+            );
+        }
+        return src;
+    }
+
+    decorateMarkdownPreviewContent(root, filePath, session) {
+        if (!(root instanceof DocumentFragment) && !(root instanceof Element)) {
+            return;
+        }
+        const headingIds = new Map();
+        for (const heading of root.querySelectorAll('h1, h2, h3, h4, h5, h6')) {
+            const baseId = slugifyMarkdownHeading(heading.textContent || '')
+                || 'section';
+            const nextCount = (headingIds.get(baseId) || 0) + 1;
+            headingIds.set(baseId, nextCount);
+            heading.id = nextCount === 1
+                ? baseId
+                : `${baseId}-${nextCount}`;
+        }
+
+        for (const image of root.querySelectorAll('img[src]')) {
+            const src = String(image.getAttribute('src') || '').trim();
+            if (!src) {
+                continue;
+            }
+            image.loading = 'lazy';
+            image.decoding = 'async';
+            image.src = this.resolveMarkdownPreviewImageUrl(
+                filePath,
+                src,
+                session
+            );
+        }
+
+        for (const link of root.querySelectorAll('a[href]')) {
+            const href = String(link.getAttribute('href') || '').trim();
+            if (!href) {
+                continue;
+            }
+            const resolved = resolveMarkdownLocalTarget(filePath, href);
+            if (resolved) {
+                link.dataset.markdownLocalPath = resolved.path;
+                link.dataset.markdownLocalHash = resolved.hash || '';
+                continue;
+            }
+            if (!href.startsWith('#')) {
+                link.target = '_blank';
+                link.rel = 'noreferrer noopener';
+            }
+        }
+    }
+
+    scrollMarkdownPreviewHash(hash) {
+        const nextHash = String(hash || '').trim();
+        if (!nextHash || !this.markdownPreviewScroll) {
+            return;
+        }
+        const id = nextHash.startsWith('#') ? nextHash.slice(1) : nextHash;
+        if (!id) {
+            return;
+        }
+        const target = this.markdownPreviewContent?.querySelector(
+            `#${CSS.escape(id)}`
+        );
+        if (!target) {
+            return;
+        }
+        target.scrollIntoView({
+            behavior: 'smooth',
+            block: 'start'
+        });
+    }
+
+    scheduleMarkdownPreviewRender(filePath, session = this.currentSession) {
+        if (
+            !session
+            || !filePath
+            || !isSupportedMarkdownPath(filePath)
+        ) {
+            return;
+        }
+        const state = this.markdownPreviewState;
+        clearTimeout(state.renderTimer);
+        state.renderTimer = window.setTimeout(() => {
+            if (
+                this.currentSession?.key !== session.key
+                || this.currentSession?.editorState.activeFilePath !== filePath
+            ) {
+                return;
+            }
+            const activeKey = this.getActiveWorkspaceTabKey(session);
+            const shouldShow = (
+                isMarkdownPreviewWorkspaceTabKey(activeKey)
+                || this.isMarkdownSplitViewEnabled(session, filePath)
+            );
+            void this.renderMarkdownPreview(filePath, {
+                session,
+                show: shouldShow
+            });
+        }, 60);
+    }
+
+    async renderMarkdownPreview(filePath, options = {}) {
+        const session = options.session || this.currentSession;
+        const show = options.show === true;
+        if (
+            !session
+            || !filePath
+            || !this.markdownPreviewContainer
+            || !this.markdownPreviewContent
+            || !isSupportedMarkdownPath(filePath)
+        ) {
+            return;
+        }
+        const state = this.markdownPreviewState;
+        const renderToken = state.renderToken + 1;
+        state.renderToken = renderToken;
+        state.path = filePath;
+        state.sessionKey = session.key;
+        if (show) {
+            this.markdownPreviewContainer.style.display = 'flex';
+        }
+
+        try {
+            const { renderer } = await loadMarkdownPreviewBundle();
+            if (
+                state.renderToken !== renderToken
+                || state.path !== filePath
+                || state.sessionKey !== session.key
+            ) {
+                return;
+            }
+            const source = this.getMarkdownSourceContent(filePath, session);
+            const rendered = renderer.render(source || '');
+            const sanitized = DOMPurify.sanitize(rendered, {
+                USE_PROFILES: {
+                    html: true,
+                    mathMl: true,
+                    svg: true
+                }
+            });
+            const template = document.createElement('template');
+            template.innerHTML = sanitized;
+            this.decorateMarkdownPreviewContent(
+                template.content,
+                filePath,
+                session
+            );
+            this.markdownPreviewContent.replaceChildren(template.content);
+            const pendingHash = state.pendingHash;
+            state.pendingHash = '';
+            if (pendingHash) {
+                requestAnimationFrame(() => {
+                    this.scrollMarkdownPreviewHash(pendingHash);
+                });
+            }
+        } catch (error) {
+            console.error('Failed to render markdown preview:', error);
+            this.markdownPreviewContent.innerHTML = '';
+            const fallback = document.createElement('div');
+            fallback.className = 'markdown-preview-error';
+            fallback.textContent = 'Failed to render markdown preview.';
+            this.markdownPreviewContent.appendChild(fallback);
+        }
+    }
+
+    async openLocalMarkdownLink(filePath, hash = '') {
+        const session = this.currentSession;
+        if (!session || !filePath) {
+            return;
+        }
+        if (isSupportedMarkdownPath(filePath)) {
+            this.markdownPreviewState.pendingHash = hash || '';
+            await this.openFile(filePath, session, {
+                activatePreview: true,
+                focusEditor: false
+            });
+            return;
+        }
+        await this.openFile(filePath, session, {
+            focusEditor: false
+        });
+    }
+
+    clearPdfPreview(preserveDocument = false) {
+        const state = this.pdfPreviewState;
+        state.renderToken += 1;
+        clearTimeout(state.relayoutTimer);
+        state.relayoutTimer = 0;
+        if (!preserveDocument) {
+            const documentRef = state.document;
+            state.document = null;
+            state.loadingTask = null;
+            state.path = '';
+            state.sessionKey = '';
+            state.metadata = '';
+            state.renderedWidth = 0;
+            if (documentRef && typeof documentRef.destroy === 'function') {
+                Promise.resolve(documentRef.destroy()).catch(() => {});
+            }
+        }
+        if (this.pdfPreviewPages) {
+            this.pdfPreviewPages.innerHTML = '';
+        }
+        this.setPdfPreviewStatus('', '');
+    }
+
+    hidePdfPreview() {
+        this.pdfPreviewContainer.style.display = 'none';
+    }
+
+    getPdfPreviewUrl(filePath, session = this.currentSession) {
+        if (!session) return '';
+        return session.server.resolveUrl(
+            `/api/fs/raw?path=${encodeURIComponent(filePath)}`
+            + `&token=${session.server.token}`
+        );
+    }
+
+    getPdfPreviewTargetWidth() {
+        if (!this.pdfPreviewPages) {
+            return 0;
+        }
+        const width = this.pdfPreviewPages.clientWidth - 36;
+        return Math.max(240, Math.floor(Math.min(width, 960)));
+    }
+
+    setPdfPreviewStatus(primary = '', secondary = '') {
+        const nextPrimary = String(primary || '').trim();
+        const nextSecondary = String(secondary || '').trim();
+        if (this.pdfPreviewStatusPrimary) {
+            this.pdfPreviewStatusPrimary.textContent = nextPrimary;
+        }
+        if (this.pdfPreviewStatusSecondary) {
+            this.pdfPreviewStatusSecondary.textContent = nextSecondary;
+            this.pdfPreviewStatusSecondary.title = nextSecondary;
+        }
+        if (this.pdfPreviewStatus) {
+            this.pdfPreviewStatus.classList.toggle(
+                'is-empty',
+                !nextPrimary && !nextSecondary
+            );
+        }
+    }
+
+    formatPdfByteSize(bytes) {
+        if (!Number.isFinite(bytes) || bytes <= 0) {
+            return '';
+        }
+        const units = ['B', 'KB', 'MB', 'GB'];
+        let value = bytes;
+        let unitIndex = 0;
+        while (value >= 1024 && unitIndex < units.length - 1) {
+            value /= 1024;
+            unitIndex += 1;
+        }
+        const decimals = value >= 100 || unitIndex === 0 ? 0 : 1;
+        return `${value.toFixed(decimals)} ${units[unitIndex]}`;
+    }
+
+    describePdfPageSize(viewport) {
+        if (!viewport) {
+            return '';
+        }
+        const width = Math.min(viewport.width, viewport.height);
+        const height = Math.max(viewport.width, viewport.height);
+        const near = (targetWidth, targetHeight) => (
+            Math.abs(width - targetWidth) < 2
+            && Math.abs(height - targetHeight) < 2
+        );
+        if (near(595.276, 841.89)) return 'A4';
+        if (near(612, 792)) return 'Letter';
+        return '';
+    }
+
+    async loadPdfMetadata(documentRef) {
+        const parts = [];
+        try {
+            const meta = await documentRef.getMetadata();
+            const version = String(meta?.info?.PDFFormatVersion || '').trim();
+            parts.push(version ? `PDF ${version}` : 'PDF');
+        } catch {
+            parts.push('PDF');
+        }
+
+        try {
+            const firstPage = await documentRef.getPage(1);
+            const pageSize = this.describePdfPageSize(
+                firstPage.getViewport({ scale: 1 })
+            );
+            if (pageSize) {
+                parts.push(pageSize);
+            }
+        } catch {
+            // Ignore optional page-size metadata failures.
+        }
+
+        try {
+            const downloadInfo = await documentRef.getDownloadInfo();
+            const byteSize = this.formatPdfByteSize(downloadInfo?.length);
+            if (byteSize) {
+                parts.push(byteSize);
+            }
+        } catch {
+            // Ignore optional size metadata failures.
+        }
+
+        return parts.join(' · ');
+    }
+
+    schedulePdfPreviewRelayout() {
+        const state = this.pdfPreviewState;
+        if (
+            !this.pdfPreviewContainer
+            || this.pdfPreviewContainer.style.display === 'none'
+            || !state.document
+            || !state.path
+        ) {
+            return;
+        }
+        clearTimeout(state.relayoutTimer);
+        state.relayoutTimer = window.setTimeout(() => {
+            const nextWidth = this.getPdfPreviewTargetWidth();
+            if (
+                nextWidth > 0
+                && Math.abs(nextWidth - state.renderedWidth) > 24
+            ) {
+                void this.renderPdfPreview(state.path);
+            }
+        }, 120);
+    }
+
+    async loadPdfDocument(filePath, session, renderToken) {
+        const state = this.pdfPreviewState;
+        const url = this.getPdfPreviewUrl(filePath, session);
+        const pdfjsLib = await loadPdfJs();
+        if (state.renderToken !== renderToken) {
+            return null;
+        }
+
+        let loadingTask = pdfjsLib.getDocument({
+            url
+        });
+        state.loadingTask = loadingTask;
+        try {
+            return await loadingTask.promise;
+        } catch (_error) {
+            if (state.renderToken !== renderToken) {
+                return null;
+            }
+            loadingTask = pdfjsLib.getDocument({
+                url,
+                disableWorker: true
+            });
+            state.loadingTask = loadingTask;
+            return await loadingTask.promise;
+        }
+    }
+
+    async renderPdfPreview(filePath) {
+        const session = this.currentSession;
+        if (!session || !filePath) {
+            return;
+        }
+        const state = this.pdfPreviewState;
+        const renderToken = state.renderToken + 1;
+        const targetSessionKey = session.key;
+        const nextWidth = this.getPdfPreviewTargetWidth();
+        if (nextWidth <= 0) {
+            requestAnimationFrame(() => {
+                if (
+                    this.currentSession?.key === targetSessionKey
+                    && this.currentSession?.editorState.activeFilePath === filePath
+                ) {
+                    void this.renderPdfPreview(filePath);
+                }
+            });
+            return;
+        }
+
+        if (
+            state.path !== filePath
+            || state.sessionKey !== targetSessionKey
+        ) {
+            this.clearPdfPreview();
+        } else {
+            this.clearPdfPreview(true);
+        }
+        state.renderToken = renderToken;
+        state.path = filePath;
+        state.sessionKey = targetSessionKey;
+        this.setPdfPreviewStatus('Loading PDF…', '');
+
+        try {
+            let documentRef = state.document;
+            if (!documentRef) {
+                documentRef = await this.loadPdfDocument(
+                    filePath,
+                    session,
+                    renderToken
+                );
+                if (!documentRef || state.renderToken !== renderToken) {
+                    return;
+                }
+                state.document = documentRef;
+                state.metadata = await this.loadPdfMetadata(documentRef);
+                if (state.renderToken !== renderToken) {
+                    return;
+                }
+            }
+
+            state.renderedWidth = nextWidth;
+            if (this.pdfPreviewPages) {
+                this.pdfPreviewPages.innerHTML = '';
+            }
+            const pageCount = documentRef.numPages;
+            this.setPdfPreviewStatus(
+                `${pageCount} page${pageCount === 1 ? '' : 's'}`,
+                state.metadata || 'PDF'
+            );
+
+            for (let pageNumber = 1; pageNumber <= documentRef.numPages; pageNumber += 1) {
+                if (state.renderToken !== renderToken) {
+                    return;
+                }
+                const page = await documentRef.getPage(pageNumber);
+                if (state.renderToken !== renderToken) {
+                    return;
+                }
+                const baseViewport = page.getViewport({ scale: 1 });
+                const scale = nextWidth / baseViewport.width;
+                const viewport = page.getViewport({ scale });
+                const canvas = document.createElement('canvas');
+                const context = canvas.getContext('2d', {
+                    alpha: false
+                });
+                if (!context) {
+                    throw new Error('Failed to create PDF canvas context');
+                }
+                const outputScale = Math.max(1, window.devicePixelRatio || 1);
+                canvas.width = Math.ceil(viewport.width * outputScale);
+                canvas.height = Math.ceil(viewport.height * outputScale);
+                canvas.style.width = `${Math.ceil(viewport.width)}px`;
+                canvas.style.height = `${Math.ceil(viewport.height)}px`;
+                context.setTransform(outputScale, 0, 0, outputScale, 0, 0);
+                const textLayer = document.createElement('div');
+                textLayer.className = 'textLayer';
+                const sheet = document.createElement('div');
+                sheet.className = 'pdf-preview-sheet';
+                sheet.style.width = `${Math.ceil(viewport.width)}px`;
+                sheet.style.height = `${Math.ceil(viewport.height)}px`;
+                sheet.style.setProperty('--user-unit', '1');
+                sheet.style.setProperty('--scale-factor', String(scale));
+                sheet.style.setProperty(
+                    '--total-scale-factor',
+                    String(scale)
+                );
+                sheet.style.setProperty('--scale-round-x', '1px');
+                sheet.style.setProperty('--scale-round-y', '1px');
+                await page.render({
+                    canvasContext: context,
+                    viewport
+                }).promise;
+                if (state.renderToken !== renderToken) {
+                    return;
+                }
+                const textContent = await page.getTextContent();
+                if (state.renderToken !== renderToken) {
+                    return;
+                }
+                const textLayerBuilder = new pdfjsLib.TextLayer({
+                    textContentSource: textContent,
+                    container: textLayer,
+                    viewport
+                });
+                await textLayerBuilder.render();
+                if (state.renderToken !== renderToken) {
+                    return;
                 }
+                const wrapper = document.createElement('div');
+                wrapper.className = 'pdf-preview-page';
+                wrapper.dataset.pageNumber = String(pageNumber);
+                sheet.appendChild(canvas);
+                sheet.appendChild(textLayer);
+                wrapper.appendChild(sheet);
+                this.pdfPreviewPages?.appendChild(wrapper);
             }
-
-            if (this.currentSession) {
-                this.switchTo(this.currentSession);
+        } catch (error) {
+            console.error('Failed to render PDF preview:', error);
+            if (state.renderToken !== renderToken) {
+                return;
             }
-        });
+            this.clearPdfPreview();
+            this.hidePdfPreview();
+            alert(
+                `Failed to load PDF: ${filePath.split('/').pop()}`,
+                {
+                    type: 'error',
+                    title: 'PDF Preview Error'
+                }
+            );
+            this.closeFile(filePath);
+        }
     }
 
     updateEditorPaneVisibility() {
@@ -3089,6 +4734,7 @@ class EditorManager {
         }
 
         this.currentSession = session;
+        this.syncMarkdownSplitSupport(session);
         if (!session) {
             this.pane.style.display = 'none';
             this.resizer.style.display = 'none';
@@ -3126,10 +4772,13 @@ class EditorManager {
     layout() {
         // console.log('[Editor] layout called');
         if (!this.currentSession) return;
+        this.syncMarkdownSplitSupport(this.currentSession);
         this.currentSession.fitMainTerminalIfVisible();
         if (this.editor && this.pane.style.display !== 'none') {
-            const width = this.pane.clientWidth;
-            const height = this.pane.clientHeight - 35; // Subtract fixed safety margin
+            const width = this.monacoContainer?.clientWidth
+                || this.pane.clientWidth;
+            const height = this.monacoContainer?.clientHeight
+                || (this.pane.clientHeight - 35);
             
             if (width > 0 && height > 0) {
                 this.editor.layout({ width, height });
@@ -3137,56 +4786,56 @@ class EditorManager {
                 this.editor.layout();
             }
         }
+        this.schedulePdfPreviewRelayout();
     }
 
-    async renderTree(
+    renderTreeFromSnapshots(
         dirPath,
         container,
         session,
+        directorySnapshots,
         renderToken = session?.fileTreeRenderToken || 0
     ) {
-        try {
-            const res = await session.server.fetch(
-                `/api/fs/list?path=${encodeURIComponent(dirPath)}`
-            );
-            if (!res.ok) return;
-            const payload = await res.json();
-            const files = Array.isArray(payload)
-                ? payload
-                : Array.isArray(payload?.items)
-                    ? payload.items
-                    : [];
-            const creatable = Array.isArray(payload)
-                ? false
-                : !!payload?.creatable;
-            if ((session.fileTreeRenderToken || 0) !== renderToken) return;
-
-            const list = this.ensureTreeList(container);
-            this.reconcileTreeList(
-                list,
-                dirPath,
-                files,
-                creatable,
-                session,
-                renderToken
-            );
-            if ((session.fileTreeRenderToken || 0) !== renderToken) return;
+        const listing = directorySnapshots.get(
+            this.getTreeRefreshRequestKey(session.server, dirPath)
+        );
+        if (!listing) {
+            return;
+        }
+        if ((session.fileTreeRenderToken || 0) !== renderToken) {
+            return;
+        }
 
-            for (const file of files) {
-                if (
-                    file.isDirectory
-                    && this.getTreeItemExpanded(file.path, session)
-                ) {
-                    const item = Array.from(list.children).find(
-                        (child) => child.dataset.path === file.path
+        const list = this.ensureTreeList(container);
+        this.reconcileTreeList(
+            list,
+            dirPath,
+            listing.files,
+            listing.creatable,
+            session
+        );
+        if ((session.fileTreeRenderToken || 0) !== renderToken) {
+            return;
+        }
+
+        for (const file of listing.files) {
+            if (
+                file.isDirectory
+                && this.getTreeItemExpanded(file.path, session)
+            ) {
+                const item = Array.from(list.children).find(
+                    (child) => child.dataset.path === file.path
+                );
+                if (item) {
+                    this.renderTreeFromSnapshots(
+                        file.path,
+                        item,
+                        session,
+                        directorySnapshots,
+                        renderToken
                     );
-                    if (item) {
-                        void this.renderTree(file.path, item, session, renderToken);
-                    }
                 }
             }
-        } catch (err) {
-            console.error('Failed to render tree:', err);
         }
     }
 
@@ -3209,34 +4858,31 @@ class EditorManager {
         const state = targetSession.editorState;
         const wasOpen = state.openFiles.includes(filePath);
         const isImage = isSupportedImagePath(filePath);
+        const isPdf = isSupportedPdfPath(filePath);
 
-        if (!this.getModel(filePath)) {
+        if (!this.getModel(filePath, targetSession)) {
             let model = null;
             let content = null;
             let readonly = false;
+            let version = '';
+            let size = 0;
+            let mtimeMs = 0;
 
-            if (!isImage) {
+            if (!isImage && !isPdf) {
                 try {
-                    const res = await targetSession.server.fetch(
-                        `/api/fs/read?path=${encodeURIComponent(filePath)}`
+                    const data = await this.readTextFileSnapshot(
+                        targetSession,
+                        filePath
                     );
-                    if (res.status === 415) {
-                        await showConfirmModal({
-                            title: 'Unsupported File Type',
-                            message: 'This file type is not supported yet.',
-                            note: 'Only text files and supported images can be opened right now.',
-                            confirmLabel: 'OK',
-                            hideCancel: true,
-                            returnFocus: document.activeElement
-                        });
-                        return;
-                    }
-                    if (!res.ok) {
-                        throw new Error('Failed to read file');
-                    }
-                    const data = await res.json();
                     content = data.content;
                     readonly = data.readonly;
+                    version = typeof data.version === 'string'
+                        ? data.version
+                        : '';
+                    size = Number.isFinite(data.size) ? data.size : 0;
+                    mtimeMs = Number.isFinite(data.mtimeMs)
+                        ? data.mtimeMs
+                        : 0;
                     
                     if (this.monacoInstance) {
                         const uri = this.monacoInstance.Uri.file(filePath);
@@ -3249,6 +4895,17 @@ class EditorManager {
                         }
                     }
                 } catch (err) {
+                    if (err?.message === 'Unsupported file type') {
+                        await showConfirmModal({
+                            title: 'Unsupported File Type',
+                            message: 'This file type is not supported yet.',
+                            note: 'Only text files, supported images, and PDFs can be opened right now.',
+                            confirmLabel: 'OK',
+                            hideCancel: true,
+                            returnFocus: document.activeElement
+                        });
+                        return;
+                    }
                     alert(`Failed to open file: ${err.message}`, { type: 'error', title: 'Error' });
                     this.closeFile(filePath);
                     return;
@@ -3256,11 +4913,16 @@ class EditorManager {
             }
 
             this.setModel(filePath, {
-                type: isImage ? 'image' : 'text',
+                type: isImage ? 'image' : isPdf ? 'pdf' : 'text',
                 model: model,
                 content: content,
-                readonly: readonly
-            });
+                readonly: readonly,
+                version,
+                contentVersion: version,
+                size,
+                mtimeMs,
+                lastDismissedRemoteVersion: ''
+            }, targetSession);
         }
 
         let touchedWorkspace = false;
@@ -3272,7 +4934,11 @@ class EditorManager {
         
         this.updateEditorPaneVisibility();
 
-        this.activateFileTab(filePath, false, options);
+        if (options.activatePreview && isSupportedMarkdownPath(filePath)) {
+            this.activateMarkdownPreviewTab(filePath, false);
+        } else {
+            this.activateFileTab(filePath, false, options);
+        }
         if (touchedWorkspace) {
             targetSession.saveState({ touchWorkspace: true });
         }
@@ -3281,6 +4947,9 @@ class EditorManager {
     closeFile(filePath) {
         if (!this.currentSession) return;
         const state = this.currentSession.editorState;
+        if (this.getMarkdownSplitPath(this.currentSession) === filePath) {
+            this.currentSession.workspaceState.markdownSplitPath = '';
+        }
 
         const index = state.openFiles.indexOf(filePath);
         let touchedWorkspace = false;
@@ -3319,8 +4988,10 @@ class EditorManager {
 
     renderEditorTabs() {
         if (!this.currentSession) return;
+        this.syncMarkdownSplitSupport(this.currentSession);
         const state = this.currentSession.editorState;
         const activeWorkspaceTabKey = this.getActiveWorkspaceTabKey();
+        const splitPath = this.getMarkdownSplitPath(this.currentSession);
 
         this.tabsContainer.innerHTML = '';
         if (this.hasCompactWorkspaceTabs(this.currentSession)) {
@@ -3349,11 +5020,28 @@ class EditorManager {
         }
 
         for (const path of state.openFiles) {
+            const splitEnabled = this.isMarkdownSplitViewEnabled(
+                this.currentSession,
+                path
+            );
             const tab = document.createElement('div');
             tab.className = 'editor-tab';
-            if (makeFileWorkspaceTabKey(path) === activeWorkspaceTabKey) {
+            if (
+                makeFileWorkspaceTabKey(path) === activeWorkspaceTabKey
+                || (
+                    splitEnabled
+                    && makeMarkdownPreviewWorkspaceTabKey(path)
+                        === activeWorkspaceTabKey
+                )
+            ) {
                 tab.classList.add('active');
             }
+            if (isSupportedMarkdownPath(path)) {
+                tab.classList.add('bound-tab', 'bound-tab-primary');
+            }
+            if (splitEnabled) {
+                tab.classList.add('is-split');
+            }
             
             const fileModel = this.getModel(path);
             if (fileModel && fileModel.readonly) {
@@ -3375,16 +5063,96 @@ class EditorManager {
                 e.stopPropagation();
                 this.closeFile(path);
             };
+            let unsplitBtn = null;
+
+            if (splitEnabled) {
+                unsplitBtn = document.createElement('span');
+                unsplitBtn.className = 'tab-action-btn markdown-unsplit-btn';
+                unsplitBtn.innerHTML = MARKDOWN_SPLIT_DISABLE_ICON_SVG;
+                unsplitBtn.title = 'Restore tabbed markdown view';
+                unsplitBtn.onclick = (e) => {
+                    e.stopPropagation();
+                    this.setMarkdownSplitView(
+                        path,
+                        false,
+                        this.currentSession
+                    );
+                    this.activateFileTab(path, false, {
+                        focusEditor: false
+                    });
+                };
+                tab.appendChild(unsplitBtn);
+            }
             
             tab.onclick = () => this.activateFileTab(path);
             bindSingleTapActivation(tab, () => this.activateFileTab(path), {
-                ignoreSelector: '.close-btn'
+                ignoreSelector: '.close-btn, .tab-action-btn'
             });
             
             tab.appendChild(icon);
             tab.appendChild(span);
+            if (unsplitBtn) {
+                tab.appendChild(unsplitBtn);
+            }
             tab.appendChild(closeBtn);
             this.tabsContainer.appendChild(tab);
+
+            if (
+                isSupportedMarkdownPath(path)
+                && !splitEnabled
+            ) {
+                const previewTab = document.createElement('div');
+                previewTab.className = 'editor-tab markdown-preview-tab bound-tab bound-tab-secondary';
+                if (
+                    makeMarkdownPreviewWorkspaceTabKey(path)
+                    === activeWorkspaceTabKey
+                ) {
+                    previewTab.classList.add('active');
+                }
+
+                const previewIcon = document.createElement('span');
+                previewIcon.className = 'file-editor-tab-icon';
+                previewIcon.innerHTML = MARKDOWN_PREVIEW_ICON_SVG;
+
+                const previewLabel = document.createElement('span');
+                previewLabel.textContent = 'Preview';
+                let splitBtn = null;
+
+                if (
+                    path !== splitPath
+                    && canUseMarkdownSplitTabsMode()
+                ) {
+                    splitBtn = document.createElement('span');
+                    splitBtn.className = 'tab-action-btn markdown-split-btn';
+                    splitBtn.innerHTML = MARKDOWN_SPLIT_ENABLE_ICON_SVG;
+                    splitBtn.title = 'Show markdown editor and preview side by side';
+                    splitBtn.onclick = (event) => {
+                        event.stopPropagation();
+                        this.setMarkdownSplitView(
+                            path,
+                            true,
+                            this.currentSession
+                        );
+                    };
+                    previewTab.appendChild(splitBtn);
+                }
+
+                previewTab.onclick = () => this.activateMarkdownPreviewTab(path);
+                bindSingleTapActivation(
+                    previewTab,
+                    () => this.activateMarkdownPreviewTab(path),
+                    {
+                        ignoreSelector: '.tab-action-btn'
+                    }
+                );
+
+                previewTab.appendChild(previewIcon);
+                previewTab.appendChild(previewLabel);
+                if (splitBtn) {
+                    previewTab.appendChild(splitBtn);
+                }
+                this.tabsContainer.appendChild(previewTab);
+            }
         }
 
         for (const agentTab of getAgentTabsForSession(this.currentSession)) {
@@ -3436,6 +5204,13 @@ class EditorManager {
             this.activateAgentTab(workspaceTabKey, isRestore);
             return;
         }
+        if (isMarkdownPreviewWorkspaceTabKey(workspaceTabKey)) {
+            this.activateMarkdownPreviewTab(
+                workspaceKeyToFilePath(workspaceTabKey),
+                isRestore
+            );
+            return;
+        }
         this.activateFileTab(workspaceKeyToFilePath(workspaceTabKey), isRestore);
     }
 
@@ -3461,12 +5236,14 @@ class EditorManager {
             TERMINAL_WORKSPACE_TAB_KEY;
         this.currentSession.needsAttention = false;
         if (!isRestore) {
-            this.currentSession.saveState();
+            this.currentSession.saveState({ touchWorkspace: true });
         }
         this.renderEditorTabs();
         this.currentSession.updateTabUI();
         this.monacoContainer.style.display = 'none';
         this.imagePreviewContainer.style.display = 'none';
+        this.hidePdfPreview();
+        this.hideMarkdownPreview();
         this.agentContainer.style.display = 'none';
         this.emptyState.style.display = 'none';
         this.syncTerminalWorkspacePlacement(TERMINAL_WORKSPACE_TAB_KEY);
@@ -3479,6 +5256,60 @@ class EditorManager {
         });
     }
 
+    activateMarkdownPreviewTab(filePath, isRestore = false) {
+        if (!this.currentSession || !filePath) return;
+
+        const state = this.currentSession.editorState;
+        if (!isRestore && state.activeFilePath && state.activeFilePath !== filePath) {
+            const currentGlobal = this.getModel(state.activeFilePath);
+            if (currentGlobal && currentGlobal.type === 'text' && this.editor) {
+                state.viewStates.set(
+                    state.activeFilePath,
+                    this.editor.saveViewState()
+                );
+            }
+        }
+
+        state.activeFilePath = filePath;
+        this.currentSession.workspaceState.activeTabKey =
+            makeMarkdownPreviewWorkspaceTabKey(filePath);
+        this.currentSession.workspaceState.lastNonTerminalTabKey =
+            makeMarkdownPreviewWorkspaceTabKey(filePath);
+        if (!isRestore) {
+            this.currentSession.saveState({ touchWorkspace: true });
+        }
+        const file = this.getModel(filePath);
+
+        this.renderEditorTabs();
+        this.emptyState.style.display = 'none';
+        this.syncTerminalWorkspacePlacement();
+
+        if (!file) {
+            void this.openFile(filePath, true, {
+                activatePreview: true,
+                focusEditor: false
+            });
+            return;
+        }
+
+        this.agentContainer.style.display = 'none';
+        this.imagePreviewContainer.style.display = 'none';
+        this.hidePdfPreview();
+        if (this.isMarkdownSplitViewEnabled(this.currentSession, filePath)) {
+            this.showMarkdownSplitView(filePath, {
+                session: this.currentSession,
+                focusEditor: false
+            });
+        } else {
+            this.contentContainer.classList.remove('markdown-split-active');
+            this.monacoContainer.style.display = 'none';
+            this.markdownPreviewContainer.style.display = 'flex';
+            void this.renderMarkdownPreview(filePath, {
+                show: true
+            });
+        }
+    }
+
     activateFileTab(filePath, isRestore = false, options = {}) {
         if (!this.currentSession) return;
         if (!filePath) return;
@@ -3496,7 +5327,9 @@ class EditorManager {
         this.currentSession.workspaceState.activeTabKey = makeFileWorkspaceTabKey(filePath);
         this.currentSession.workspaceState.lastNonTerminalTabKey =
             makeFileWorkspaceTabKey(filePath);
-        this.currentSession.saveState();
+        if (!isRestore) {
+            this.currentSession.saveState({ touchWorkspace: true });
+        }
         const file = this.getModel(filePath);
         
         this.renderEditorTabs();
@@ -3511,7 +5344,9 @@ class EditorManager {
         if (file.type === 'image') {
             this.agentContainer.style.display = 'none';
             this.monacoContainer.style.display = 'none';
+            this.hideMarkdownPreview();
             this.imagePreviewContainer.style.display = 'flex';
+            this.hidePdfPreview();
             
             this.imagePreview.onerror = () => {
                 alert(`Failed to load image: ${filePath.split('/').pop()}`, { type: 'error', title: 'Error' });
@@ -3522,9 +5357,55 @@ class EditorManager {
             this.imagePreview.src = this.currentSession.server.resolveUrl(
                 `/api/fs/raw?path=${encodeURIComponent(filePath)}&token=${this.currentSession.server.token}`
             );
+        } else if (file.type === 'pdf') {
+            this.agentContainer.style.display = 'none';
+            this.monacoContainer.style.display = 'none';
+            this.imagePreviewContainer.style.display = 'none';
+            this.hideMarkdownPreview();
+            this.pdfPreviewContainer.style.display = 'flex';
+            void this.renderPdfPreview(filePath);
+        } else if (isSupportedMarkdownPath(filePath)) {
+            if (this.isMarkdownSplitViewEnabled(this.currentSession, filePath)) {
+                this.showMarkdownSplitView(filePath, {
+                    session: this.currentSession,
+                    focusEditor
+                });
+                this.scheduleMarkdownPreviewRender(
+                    filePath,
+                    this.currentSession
+                );
+                return;
+            }
+            this.agentContainer.style.display = 'none';
+            this.imagePreviewContainer.style.display = 'none';
+            this.hidePdfPreview();
+            this.hideMarkdownPreview();
+            this.monacoContainer.style.display = 'block';
+            if (!file.model && file.content !== null && this.monacoInstance) {
+                file.model = this.monacoInstance.editor.createModel(
+                    file.content,
+                    undefined,
+                    this.monacoInstance.Uri.file(filePath)
+                );
+            }
+            if (this.editor && file.model) {
+                this.editor.setModel(file.model);
+                this.editor.updateOptions({ readOnly: !!file.readonly });
+                const savedViewState = state.viewStates.get(filePath);
+                if (savedViewState) {
+                    this.editor.restoreViewState(savedViewState);
+                }
+                if (focusEditor) {
+                    this.editor.focus();
+                }
+                requestAnimationFrame(() => this.editor.layout());
+            }
+            this.scheduleMarkdownPreviewRender(filePath, this.currentSession);
         } else {
             this.agentContainer.style.display = 'none';
             this.imagePreviewContainer.style.display = 'none';
+            this.hidePdfPreview();
+            this.hideMarkdownPreview();
             this.monacoContainer.style.display = 'block';
             
             if (!file.model && file.content !== null && this.monacoInstance) {
@@ -3545,6 +5426,7 @@ class EditorManager {
                 // Force layout to ensure content is visible
                 requestAnimationFrame(() => this.editor.layout());
             }
+            void this.checkActiveFileVersion();
         }
     }
 
@@ -3581,12 +5463,16 @@ class EditorManager {
         this.currentSession.workspaceState.lastNonTerminalTabKey = agentTabKey;
         noteRecentAgentTab(this.currentSession, agentTabKey);
         agentTab.needsAttention = false;
-        this.currentSession.saveState();
+        if (!isRestore) {
+            this.currentSession.saveState({ touchWorkspace: true });
+        }
         this.renderEditorTabs();
         this.currentSession.updateTabUI();
         this.syncTerminalWorkspacePlacement(agentTabKey);
         this.monacoContainer.style.display = 'none';
         this.imagePreviewContainer.style.display = 'none';
+        this.hidePdfPreview();
+        this.hideMarkdownPreview();
         this.emptyState.style.display = 'none';
         this.agentContainer.style.display = 'flex';
         this.renderAgentPanel(agentTab);
@@ -5292,20 +7178,57 @@ class EditorManager {
             const session = agentTab.getLinkedSession();
             if (!session) return;
             try {
+                let targetAgentTab = null;
+                let targetPromptDraft = '';
                 if (command.openTabKey) {
                     const existingTab = state.agentTabs.get(command.openTabKey);
                     const existingSession = existingTab?.getLinkedSession() || null;
                     if (existingTab && existingSession) {
-                        await activateAgentTab(existingSession, existingTab, {
+                        targetPromptDraft = String(
+                            existingTab.promptDraft || ''
+                        );
+                        targetAgentTab = await activateAgentTab(
+                            existingSession,
+                            existingTab,
+                            {
                             switchSession: true
-                        });
+                            }
+                        );
                     } else {
-                        await resumeAgentTabFromHistory(session, agentTab, command);
+                        targetAgentTab = await resumeAgentTabFromHistory(
+                            session,
+                            agentTab,
+                            command
+                        );
+                        targetPromptDraft = String(
+                            targetAgentTab?.promptDraft || ''
+                        );
                     }
                 } else {
-                    await resumeAgentTabFromHistory(session, agentTab, command);
+                    targetAgentTab = await resumeAgentTabFromHistory(
+                        session,
+                        agentTab,
+                        command
+                    );
+                    targetPromptDraft = String(
+                        targetAgentTab?.promptDraft || ''
+                    );
                 }
-                this.hideAgentCommandMenu();
+                const targetPromptIntent = getAgentPromptIntent(
+                    targetAgentTab,
+                    targetPromptDraft
+                );
+                if (targetPromptIntent.kind === 'resume') {
+                    targetPromptDraft = '';
+                    if (targetAgentTab) {
+                        targetAgentTab.promptDraft = '';
+                    }
+                }
+                agentTab.promptDraft = '';
+                this.setAgentPromptValue(
+                    targetPromptDraft,
+                    targetAgentTab || getActiveAgentTab() || agentTab
+                );
             } catch (error) {
                 alert(error.message, {
                     type: 'error',
@@ -5327,6 +7250,8 @@ class EditorManager {
     showEmptyState() {
         this.monacoContainer.style.display = 'none';
         this.imagePreviewContainer.style.display = 'none';
+        this.hidePdfPreview();
+        this.hideMarkdownPreview();
         this.agentContainer.style.display = 'none';
         this.emptyState.style.display = 'flex';
         this.syncTerminalWorkspacePlacement('');
@@ -5994,13 +7919,31 @@ class Session {
                     : Array.from(this.server.expandedPaths)
             }
         );
+        const sharedActiveWorkspaceTabKey = typeof (
+            this.sharedWorkspaceState.activeWorkspaceTabKey
+        ) === 'string'
+            ? this.sharedWorkspaceState.activeWorkspaceTabKey
+            : '';
+        const initialActiveWorkspaceTabKey = (
+            isFileWorkspaceTabKey(sharedActiveWorkspaceTabKey)
+            && !this.sharedWorkspaceState.openFiles.includes(
+                workspaceKeyToFilePath(sharedActiveWorkspaceTabKey)
+            )
+        )
+            ? ''
+            : sharedActiveWorkspaceTabKey;
+        const preferredActiveFilePath = isFileWorkspaceTabKey(
+            initialActiveWorkspaceTabKey
+        )
+            ? workspaceKeyToFilePath(initialActiveWorkspaceTabKey)
+            : legacyEditorState.activeFilePath;
         const initialActiveFilePath = (
-            typeof legacyEditorState.activeFilePath === 'string'
+            typeof preferredActiveFilePath === 'string'
             && this.sharedWorkspaceState.openFiles.includes(
-                legacyEditorState.activeFilePath
+                preferredActiveFilePath
             )
         )
-            ? legacyEditorState.activeFilePath
+            ? preferredActiveFilePath
             : (this.sharedWorkspaceState.openFiles[0] || null);
 
         this.editorState = {
@@ -6011,15 +7954,15 @@ class Session {
             viewStates: new Map() // Path -> ViewState
         };
         this.workspaceState = {
-            activeTabKey: legacyEditorState.activeWorkspaceTabKey
+            activeTabKey: initialActiveWorkspaceTabKey
                 || (initialActiveFilePath
                     ? makeFileWorkspaceTabKey(initialActiveFilePath)
                     : ''),
-            lastNonTerminalTabKey: legacyEditorState.activeWorkspaceTabKey
+            lastNonTerminalTabKey: initialActiveWorkspaceTabKey
                 && !isTerminalWorkspaceTabKey(
-                    legacyEditorState.activeWorkspaceTabKey
+                    initialActiveWorkspaceTabKey
                 )
-                ? legacyEditorState.activeWorkspaceTabKey
+                ? initialActiveWorkspaceTabKey
                 : (initialActiveFilePath
                     ? makeFileWorkspaceTabKey(initialActiveFilePath)
                     : ''),
@@ -6029,7 +7972,8 @@ class Session {
                 ? legacyEditorState.recentAgentTabKeys.filter(
                     (key) => typeof key === 'string' && key.length > 0
                 )
-                : []
+                : [],
+            markdownSplitPath: this.sharedWorkspaceState.markdownSplitPath || ''
         };
         
         this.layoutState = {
@@ -6166,6 +8110,7 @@ class Session {
         this.sharedWorkspaceState = normalized;
         this.editorState.isVisible = normalized.isVisible;
         this.editorState.openFiles = [...normalized.openFiles];
+        this.workspaceState.markdownSplitPath = normalized.markdownSplitPath;
 
         if (
             this.editorState.activeFilePath
@@ -6180,7 +8125,13 @@ class Session {
         const activeKey = this.workspaceState.activeTabKey || '';
         if (isFileWorkspaceTabKey(activeKey)) {
             const filePath = workspaceKeyToFilePath(activeKey);
-            if (!this.editorState.openFiles.includes(filePath)) {
+            if (
+                !this.editorState.openFiles.includes(filePath)
+                || (
+                    isMarkdownPreviewWorkspaceTabKey(activeKey)
+                    && !isSupportedMarkdownPath(filePath)
+                )
+            ) {
                 this.workspaceState.activeTabKey = resolveFallbackActiveKey();
             }
         } else if (
@@ -6194,7 +8145,13 @@ class Session {
             this.workspaceState.lastNonTerminalTabKey || '';
         if (isFileWorkspaceTabKey(lastNonTerminalKey)) {
             const filePath = workspaceKeyToFilePath(lastNonTerminalKey);
-            if (!this.editorState.openFiles.includes(filePath)) {
+            if (
+                !this.editorState.openFiles.includes(filePath)
+                || (
+                    isMarkdownPreviewWorkspaceTabKey(lastNonTerminalKey)
+                    && !isSupportedMarkdownPath(filePath)
+                )
+            ) {
                 this.workspaceState.lastNonTerminalTabKey = '';
             }
         }
@@ -7818,6 +9775,25 @@ function getActiveServer() {
     return getActiveSession()?.server || getMainServer();
 }
 
+function getDocumentTitle() {
+    const server = getActiveServer();
+    if (!server) {
+        return 'Tabminal';
+    }
+    const host = String(getDisplayHost(server) || '').trim();
+    if (!host || host.toLowerCase() === 'unknown') {
+        return 'Tabminal';
+    }
+    return `Tabminal: ${host}`;
+}
+
+function updateDocumentTitle() {
+    const nextTitle = getDocumentTitle();
+    if (document.title !== nextTitle) {
+        document.title = nextTitle;
+    }
+}
+
 function getSessionsForServer(serverId) {
     return Array.from(state.sessions.values()).filter(
         session => session.serverId === serverId
@@ -7984,6 +9960,9 @@ function getWorkspaceTabKeysForSession(session) {
     }
     for (const path of session.editorState?.openFiles || []) {
         keys.push(makeFileWorkspaceTabKey(path));
+        if (isSupportedMarkdownPath(path)) {
+            keys.push(makeMarkdownPreviewWorkspaceTabKey(path));
+        }
     }
     for (const agentTab of getAgentTabsForSession(session)) {
         keys.push(agentTab.key);
@@ -8147,6 +10126,7 @@ function normalizeAgentSessionCapabilities(sessionCapabilities) {
     return {
         load: !!source.load,
         list: !!source.list,
+        listAll: !!source.listAll,
         resume: !!source.resume,
         fork: !!source.fork
     };
@@ -8564,6 +10544,9 @@ function getAgentResumeSuggestions(agentTab, promptValue, sessions = []) {
     const intent = getAgentPromptIntent(agentTab, promptValue);
     if (intent.kind !== 'resume') return [];
     const query = String(intent.query || '').toLowerCase();
+    const currentCwd = String(
+        agentTab?.cwd || agentTab?.getLinkedSession?.()?.cwd || ''
+    ).trim().toLowerCase();
     const openSessions = getOpenAgentSessionsForServer(
         agentTab?.serverId,
         agentTab?.agentId
@@ -8577,24 +10560,30 @@ function getAgentResumeSuggestions(agentTab, promptValue, sessions = []) {
             ).toLowerCase();
             const cwd = String(session.cwd || '').toLowerCase();
             const sessionId = String(session.sessionId || '').toLowerCase();
+            const cwdMatch = !!currentCwd && cwd === currentCwd;
             const titleMatch = !query || displayName.includes(query);
-            const otherMatch = !query || cwd.includes(query) || sessionId.includes(query);
+            const otherMatch = !query
+                || cwd.includes(query)
+                || sessionId.includes(query);
             return {
                 session,
                 index,
+                cwdMatch,
                 titleMatch,
                 matched: titleMatch || otherMatch
             };
         })
         .filter(({ matched }) => matched)
         .sort((left, right) => {
+            if (left.cwdMatch !== right.cwdMatch) {
+                return left.cwdMatch ? -1 : 1;
+            }
             if (left.titleMatch !== right.titleMatch) {
                 return left.titleMatch ? -1 : 1;
             }
             return left.index - right.index;
         })
         .map(({ session }) => session)
-        .slice(0, 12)
         .map((session) => ({
             ...session,
             openTabKey: openSessions.get(session.sessionId)?.key || '',
@@ -11135,7 +13124,7 @@ async function syncAgentsForServer(server, { force = false } = {}) {
             && state.agentTabs.has(activeKey)
         ) {
             noteRecentAgentTab(session, activeKey);
-            session.saveState();
+            session.saveState({ touchWorkspace: true });
         }
     }
 
@@ -11169,7 +13158,7 @@ async function syncAgentsForServer(server, { force = false } = {}) {
                 getAgentTabsForSession(preferredSession)[0]?.key || ''
             );
         }
-        preferredSession.saveState();
+        preferredSession.saveState({ touchWorkspace: true });
         if (state.activeSessionKey === preferredSession.key) {
             restoreWorkspaceForSession(preferredSession);
         } else {
@@ -11208,7 +13197,7 @@ async function activateAgentTab(session, agentTab, options = {}) {
     }
     session.workspaceState.activeTabKey = agentTab.key;
     noteRecentAgentTab(session, agentTab.key);
-    session.saveState();
+    session.saveState({ touchWorkspace: true });
     if (state.activeSessionKey === session.key) {
         restoreWorkspaceForSession(session);
         requestAnimationFrame(() => {
@@ -11481,6 +13470,7 @@ async function syncServer(server) {
         }
 
         const updates = { sessions: [] };
+        const sentFileWrites = new Map();
         for (const [sessionKey, pending] of pendingChanges.sessions) {
             const { serverId, sessionId } = splitSessionKey(sessionKey);
             if (serverId !== server.id) continue;
@@ -11497,10 +13487,31 @@ async function syncServer(server) {
                 hasUpdate = true;
             }
             if (pending.fileWrites && pending.fileWrites.size > 0) {
-                sessionUpdate.fileWrites = Array.from(
+                const fileWrites = Array.from(
                     pending.fileWrites.entries()
-                ).map(([path, content]) => ({ path, content }));
-                hasUpdate = true;
+                )
+                    .map(([path, write]) => ({
+                        path,
+                        write: editorManager.normalizePendingFileWrite(write)
+                    }))
+                    .filter(({ write }) => !write.blocked);
+                if (fileWrites.length > 0) {
+                    sessionUpdate.fileWrites = fileWrites.map(
+                        ({ path, write }) => ({
+                            path,
+                            content: write.content,
+                            expectedVersion: write.expectedVersion,
+                            force: write.force === true
+                        })
+                    );
+                    sentFileWrites.set(
+                        sessionUpdate.id,
+                        new Map(
+                            fileWrites.map(({ path, write }) => [path, write])
+                        )
+                    );
+                    hasUpdate = true;
+                }
             }
 
             if (hasUpdate) {
@@ -11544,11 +13555,6 @@ async function syncServer(server) {
 
                 if (update.resize) delete pending.resize;
                 if (update.workspaceState) delete pending.workspaceState;
-                if (update.fileWrites) {
-                    for (const file of update.fileWrites) {
-                        pending.fileWrites.delete(file.path);
-                    }
-                }
             }
 
             const data = await response.json();
@@ -11575,6 +13581,33 @@ async function syncServer(server) {
             const sessions = Array.isArray(data) ? data : data.sessions;
             reconcileSessions(server, sessions || []);
             reconcileAgentInventory(server, data.agents);
+            await editorManager.applyFileWriteResults(
+                server,
+                Array.isArray(data?.fileWriteResults)
+                    ? data.fileWriteResults
+                    : [],
+                sentFileWrites
+            );
+
+            for (const [sessionId, writes] of sentFileWrites.entries()) {
+                const pending = pendingChanges.sessions.get(
+                    makeSessionKey(server.id, sessionId)
+                );
+                if (!pending?.fileWrites) {
+                    continue;
+                }
+                for (const [path] of writes.entries()) {
+                    if (!pending.fileWrites.has(path)) {
+                        continue;
+                    }
+                    const current = editorManager.normalizePendingFileWrite(
+                        pending.fileWrites.get(path)
+                    );
+                    if (!current.blocked) {
+                        pending.fileWrites.delete(path);
+                    }
+                }
+            }
         } catch (error) {
             if (!wasReconnecting) {
                 console.warn(
@@ -12096,7 +14129,7 @@ function reconcileSessions(server, remoteSessions) {
     }
 }
 
-async function createNewSession(server = getActiveServer()) {
+async function createNewSession(server = getActiveServer(), options = {}) {
     if (!server) return;
     if (server.needsLogin || !server.isAuthenticated) {
         const password = window.prompt(`Password for ${getDisplayHost(server)}`);
@@ -12104,16 +14137,15 @@ async function createNewSession(server = getActiveServer()) {
         await server.login(password);
     }
     try {
-        const options = {};
-        const activeSession = getActiveSession();
-        if (activeSession && activeSession.serverId === server.id && activeSession.cwd) {
-            options.cwd = activeSession.cwd;
+        const request = {};
+        if (typeof options.cwd === 'string' && options.cwd.trim()) {
+            request.cwd = options.cwd.trim();
         }
 
         const response = await server.fetch('/api/sessions', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(options)
+            body: JSON.stringify(request)
         });
         if (!response.ok) throw new Error('Failed to create session');
         const newSession = await response.json();
@@ -12141,6 +14173,7 @@ function removeSession(key) {
 
 // #region UI Logic
 function renderTabs() {
+    updateDocumentTitle();
     if (!tabListEl) return;
 
     const newTabItem = document.getElementById('new-tab-item');
@@ -12561,7 +14594,8 @@ const confirmModalState = {
     resolve: null,
     returnFocus: null,
     preferredFocus: 'confirm',
-    hideCancel: false
+    hideCancel: false,
+    allowDismiss: true
 };
 
 function isConfirmModalOpen() {
@@ -12600,6 +14634,7 @@ function settleConfirmModal(result) {
     confirmModalState.returnFocus = null;
     confirmModalState.preferredFocus = 'confirm';
     confirmModalState.hideCancel = false;
+    confirmModalState.allowDismiss = true;
     if (returnFocus instanceof HTMLElement) {
         requestAnimationFrame(() => {
             try {
@@ -12617,8 +14652,11 @@ function showConfirmModal({
     message = '',
     note = '',
     confirmLabel = 'Confirm',
+    cancelLabel = 'Cancel',
     danger = false,
     hideCancel = false,
+    preferredFocus = 'confirm',
+    allowDismiss = true,
     returnFocus = null
 } = {}) {
     if (
@@ -12638,13 +14676,17 @@ function showConfirmModal({
     confirmModalMessage.textContent = message;
     confirmModalNote.textContent = note;
     confirmModalNote.style.display = note ? '' : 'none';
+    confirmModalCancel.textContent = cancelLabel;
     confirmModalCancel.style.display = hideCancel ? 'none' : '';
     confirmModalConfirm.textContent = confirmLabel;
     confirmModalConfirm.classList.toggle('danger-button', danger);
     confirmModal.style.display = 'flex';
     confirmModalState.returnFocus = returnFocus;
     confirmModalState.hideCancel = hideCancel;
-    confirmModalState.preferredFocus = 'confirm';
+    confirmModalState.preferredFocus = preferredFocus === 'cancel'
+        ? 'cancel'
+        : 'confirm';
+    confirmModalState.allowDismiss = allowDismiss !== false;
     requestAnimationFrame(() => {
         getConfirmModalPreferredButton()?.focus({ preventScroll: true });
     });
@@ -12679,6 +14721,7 @@ function moveConfirmModalFocus(delta) {
 }
 
 function renderServerControls() {
+    updateDocumentTitle();
     if (!serverControlsEl) return;
     serverControlsEl.innerHTML = '';
 
@@ -12834,12 +14877,14 @@ window.addEventListener('focus', () => {
     enterAppNotificationQuietPeriod();
     editorManager.refreshVisibleSessionTrees();
     editorManager.updateTreeAutoRefresh();
+    void editorManager.checkActiveFileVersion();
 });
 window.addEventListener('pageshow', () => {
     noteAppInteraction();
     enterAppNotificationQuietPeriod();
     editorManager.refreshVisibleSessionTrees();
     editorManager.updateTreeAutoRefresh();
+    void editorManager.checkActiveFileVersion();
 });
 
 document.addEventListener('click', () => {
@@ -12851,6 +14896,7 @@ document.addEventListener('visibilitychange', () => {
         enterAppNotificationQuietPeriod();
         clearVisibleAttentionState();
         editorManager.refreshVisibleSessionTrees();
+        void editorManager.checkActiveFileVersion();
     }
     editorManager.updateTreeAutoRefresh();
 });
@@ -13048,19 +15094,19 @@ window.addEventListener('tabminal:layout-modechange', () => {
         && terminalEl.contains(activeElement)
     );
 
-    if (isForcedTerminalWorkspaceMode()) {
-        if (terminalHasFocus) {
-            session.workspaceState.activeTabKey = TERMINAL_WORKSPACE_TAB_KEY;
-            session.saveState();
+        if (isForcedTerminalWorkspaceMode()) {
+            if (terminalHasFocus) {
+                session.workspaceState.activeTabKey = TERMINAL_WORKSPACE_TAB_KEY;
+                session.saveState({ touchWorkspace: true });
+            }
+        } else if (
+            !editorManager.isTerminalTabPinned(session)
+            && isTerminalWorkspaceTabKey(session.workspaceState?.activeTabKey || '')
+        ) {
+            session.workspaceState.activeTabKey =
+                editorManager.getPreferredNonTerminalWorkspaceTabKey(session);
+            session.saveState({ touchWorkspace: true });
         }
-    } else if (
-        !editorManager.isTerminalTabPinned(session)
-        && isTerminalWorkspaceTabKey(session.workspaceState?.activeTabKey || '')
-    ) {
-        session.workspaceState.activeTabKey =
-            editorManager.getPreferredNonTerminalWorkspaceTabKey(session);
-        session.saveState();
-    }
 
     editorManager.switchTo(session);
     editorManager.updateEditorPaneVisibility();
@@ -13281,7 +15327,10 @@ if (
     });
 
     confirmModal.addEventListener('click', (event) => {
-        if (event.target === confirmModal) {
+        if (
+            event.target === confirmModal
+            && confirmModalState.allowDismiss
+        ) {
             settleConfirmModal(false);
         }
     });
@@ -13292,6 +15341,11 @@ if (
 
     confirmModal.addEventListener('keydown', (event) => {
         if (event.key === 'Escape') {
+            if (!confirmModalState.allowDismiss) {
+                event.preventDefault();
+                event.stopPropagation();
+                return;
+            }
             event.preventDefault();
             settleConfirmModal(false);
             return;