openwriter 0.5.0 → 0.5.1

package/dist/server/documents.js

@@ -9,7 +9,7 @@ import matter from 'gray-matter';
 import trash from 'trash';
 import { tiptapToMarkdown, markdownToTiptap } from './markdown.js';
 import { parseMarkdownContent } from './compact.js';
-import { getDocument, getTitle, getFilePath, save, cancelDebouncedSave, setActiveDocument, registerExternalDoc, unregisterExternalDoc, getExternalDocs, } from './state.js';
+import { getDocument, getTitle, getFilePath, save, cancelDebouncedSave, setActiveDocument, registerExternalDoc, unregisterExternalDoc, getExternalDocs, cacheActiveDocument, getCachedDocument, invalidateDocCache, } from './state.js';
 import { DATA_DIR, TEMP_PREFIX, ensureDataDir, filePathForTitle, tempFilePath, generateNodeId, resolveDocPath, isExternalDoc, atomicWriteFileSync } from './helpers.js';
 import { ensureDocId } from './versions.js';
 const DOC_ORDER_FILE = join(DATA_DIR, '_doc-order.json');
@@ -110,6 +110,8 @@ export function switchDocument(filename) {
     // Cancel any pending debounced save, then save current doc immediately.
     cancelDebouncedSave();
     save();
+    // Cache current doc before switching (preserves node IDs)
+    cacheActiveDocument();
     // Read target from disk — markdownToTiptap rehydrates pending state
     const targetPath = resolveDocPath(filename);
     if (!existsSync(targetPath)) {
@@ -119,6 +121,12 @@ export function switchDocument(filename) {
     if (isExternalDoc(filename)) {
         registerExternalDoc(targetPath);
     }
+    // Check cache first — preserves stable node IDs across switches
+    const cached = getCachedDocument(targetPath);
+    if (cached) {
+        setActiveDocument(cached.document, cached.title, targetPath, cached.isTemp, cached.lastModified, cached.metadata);
+        return { document: getDocument(), title: getTitle(), filename };
+    }
     const raw = readFileSync(targetPath, 'utf-8');
     const parsed = markdownToTiptap(raw);
     const mtime = new Date(statSync(targetPath).mtimeMs);
@@ -132,6 +140,8 @@ export function createDocument(title, content, path) {
     // Cancel any pending debounced save, then save current doc immediately
     cancelDebouncedSave();
     save();
+    // Cache current doc before switching to new one
+    cacheActiveDocument();
     const docTitle = title || 'Untitled';
     let filePath;
     let isTemp;
@@ -190,6 +200,8 @@ export function createDocument(title, content, path) {
 export async function deleteDocument(filename) {
     ensureDataDir();
     const targetPath = resolveDocPath(filename);
+    // Invalidate cache for deleted doc
+    invalidateDocCache(targetPath);
     // Unregister if external
     if (isExternalDoc(filename)) {
         unregisterExternalDoc(targetPath);
@@ -222,6 +234,8 @@ export function reloadDocument() {
     if (!existsSync(filePath)) {
         throw new Error('Active document file not found on disk');
     }
+    // Force fresh parse — invalidate any cached version
+    invalidateDocCache(filePath);
     const filename = filePath.split(/[/\\]/).pop();
     const raw = readFileSync(filePath, 'utf-8');
     const parsed = markdownToTiptap(raw);
@@ -254,10 +268,19 @@ export function openFile(fullPath) {
     // Cancel any pending debounced save, then save current doc immediately
     cancelDebouncedSave();
     save();
+    // Cache current doc before switching
+    cacheActiveDocument();
     // Register as external if not in DATA_DIR
     if (isExternalDoc(fullPath)) {
         registerExternalDoc(fullPath);
     }
+    // Check cache first — preserves stable node IDs
+    const cached = getCachedDocument(fullPath);
+    if (cached) {
+        setActiveDocument(cached.document, cached.title, fullPath, cached.isTemp, cached.lastModified, cached.metadata);
+        const filename = isExternalDoc(fullPath) ? fullPath : (fullPath.split(/[/\\]/).pop() || '');
+        return { document: getDocument(), title: getTitle(), filename };
+    }
     const raw = readFileSync(fullPath, 'utf-8');
     const parsed = markdownToTiptap(raw);
     const mtime = new Date(statSync(fullPath).mtimeMs);

package/dist/server/mcp.js

@@ -10,10 +10,10 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import { DATA_DIR, ensureDataDir } from './helpers.js';
-import { getDocument, getWordCount, getPendingChangeCount, getTitle, getStatus, getNodesByIds, getMetadata, setMetadata, applyChanges, applyTextEdits, updateDocument, save, markAllNodesAsPending, setAgentLock, updatePendingCacheForActiveDoc, getDocId, getFilePath, } from './state.js';
-import { listDocuments, switchDocument, createDocument, deleteDocument, openFile, getActiveFilename } from './documents.js';
+import { getDocument, getWordCount, getPendingChangeCount, getTitle, getStatus, getNodesByIds, getMetadata, setMetadata, applyChanges, applyTextEdits, updateDocument, save, markAllNodesAsPending, setAgentLock, updatePendingCacheForActiveDoc, populateDocumentFile, applyChangesToFile, applyTextEditsToFile, getDocId, getFilePath, } from './state.js';
+import { listDocuments, switchDocument, createDocument, deleteDocument, openFile, getActiveFilename, updateDocumentTitle } from './documents.js';
 import { broadcastDocumentSwitched, broadcastDocumentsChanged, broadcastWorkspacesChanged, broadcastTitleChanged, broadcastMetadataChanged, broadcastPendingDocsChanged, broadcastWritingStarted, broadcastWritingFinished } from './ws.js';
-import { listWorkspaces, getWorkspace, getDocTitle, getItemContext, addDoc, updateWorkspaceContext, createWorkspace, deleteWorkspace, addContainerToWorkspace, findOrCreateWorkspace, findOrCreateContainer, moveDoc } from './workspaces.js';
+import { listWorkspaces, getWorkspace, getDocTitle, getItemContext, addDoc, updateWorkspaceContext, createWorkspace, deleteWorkspace, addContainerToWorkspace, findOrCreateWorkspace, findOrCreateContainer, moveDoc, renameWorkspace, renameContainer } from './workspaces.js';
 import { addDocTag, removeDocTag, getDocTagsByFilename } from './state.js';
 import { importGoogleDoc } from './gdoc-import.js';
 import { toCompactFormat, compactNodes, parseMarkdownContent } from './compact.js';
@@ -33,7 +33,7 @@ export const TOOL_REGISTRY = [
     },
     {
         name: 'write_to_pad',
-        description: 'Preferred tool for all document edits. Send 3-8 changes per call for responsive feel. Multiple rapid calls better than one monolithic call. Content can be a markdown string (preferred) or TipTap JSON. Markdown strings are auto-converted. Changes appear as pending decorations the user accepts or rejects. Use afterNodeId: "end" to append to the document without knowing node IDs. Response includes lastNodeId for chaining subsequent inserts.',
+        description: 'Preferred tool for all document edits. Send 3-8 changes per call for responsive feel. Multiple rapid calls better than one monolithic call. Content can be a markdown string (preferred) or TipTap JSON. Markdown strings are auto-converted. Changes appear as pending decorations the user accepts or rejects. Use afterNodeId: "end" to append to the document without knowing node IDs. Response includes lastNodeId for chaining subsequent inserts. Always specify filename — edits target that file directly without switching the user\'s view.',
         schema: {
             changes: z.array(z.object({
                 operation: z.enum(['rewrite', 'insert', 'delete']),
@@ -41,8 +41,9 @@ export const TOOL_REGISTRY = [
                 afterNodeId: z.string().optional(),
                 content: z.any().optional(),
             })).describe('Array of node changes. Content accepts markdown strings or TipTap JSON.'),
+            filename: z.string().describe('Target filename (e.g. "My Essay.md"). Required — identifies which document to edit.'),
         },
-        handler: async ({ changes }) => {
+        handler: async ({ changes, filename }) => {
             const processed = changes.map((change) => {
                 const resolved = { ...change };
                 if (typeof resolved.content === 'string') {
@@ -50,6 +51,22 @@ export const TOOL_REGISTRY = [
                 }
                 return resolved;
             });
+            const targetIsNonActive = filename && filename !== getActiveFilename();
+            if (targetIsNonActive) {
+                const { count: appliedCount, lastNodeId } = applyChangesToFile(filename, processed);
+                broadcastPendingDocsChanged();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: appliedCount > 0,
+                                appliedCount,
+                                ...(lastNodeId ? { lastNodeId } : {}),
+                                ...(appliedCount < processed.length ? { skipped: processed.length - appliedCount } : {}),
+                            }),
+                        }],
+                };
+            }
             const { count: appliedCount, lastNodeId } = applyChanges(processed);
             // broadcastPendingDocsChanged() already fires via onChanges listener in ws.ts
             return {
@@ -187,11 +204,12 @@ export const TOOL_REGISTRY = [
     },
     {
         name: 'populate_document',
-        description: 'Populate the active document with content. Use after create_document (without content) to complete the two-step creation flow. Content appears as pending decorations for user review. Clears the sidebar creation spinner and shows the document.',
+        description: 'Populate a document with content. Use after create_document (without content) to complete the two-step creation flow. Content appears as pending decorations for user review. Clears the sidebar creation spinner and shows the document. Pass the filename from create_document\'s response to ensure content goes to the right doc even if the user switched away.',
         schema: {
             content: z.any().describe('Document content: markdown string (preferred) or TipTap JSON doc object.'),
+            filename: z.string().optional().describe('Target filename (e.g. "My Essay.md"). If provided and differs from the active doc, writes directly to disk without switching the user\'s view. Recommended — prevents race conditions when the user navigates during content generation.'),
         },
-        handler: async ({ content }) => {
+        handler: async ({ content, filename }) => {
             try {
                 let doc;
                 if (typeof content === 'string') {
@@ -206,6 +224,22 @@ export const TOOL_REGISTRY = [
                         content: [{ type: 'text', text: 'Error: content must be a markdown string or TipTap JSON { type: "doc", content: [...] }' }],
                     };
                 }
+                // Non-active target: write directly to disk without disrupting the user's view
+                const targetIsNonActive = filename && filename !== getActiveFilename();
+                if (targetIsNonActive) {
+                    const result = populateDocumentFile(filename, doc);
+                    broadcastDocumentsChanged();
+                    broadcastWorkspacesChanged();
+                    broadcastPendingDocsChanged();
+                    broadcastWritingFinished();
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Populated "${result.title}" — ${result.wordCount.toLocaleString()} words`,
+                            }],
+                    };
+                }
+                // Active target (or no filename): existing flow
                 setAgentLock(); // Block browser doc-updates during population
                 markAllNodesAsPending(doc, 'insert');
                 updateDocument(doc);
@@ -484,9 +518,44 @@ export const TOOL_REGISTRY = [
             return { content: [{ type: 'text', text: `Moved "${docFile}"${targetContainerId ? ` to container ${targetContainerId}` : ' to root'}` }] };
         },
     },
+    {
+        name: 'rename_item',
+        description: 'Rename a workspace, container, or document. For workspaces: updates the manifest title. For containers: updates the container name in the workspace tree. For documents: updates the title in frontmatter.',
+        schema: {
+            type: z.enum(['workspace', 'container', 'document']).describe('What to rename'),
+            filename: z.string().describe('Workspace manifest filename (for workspace/container) or document filename (for document)'),
+            newName: z.string().describe('The new name/title'),
+            containerId: z.string().optional().describe('Container ID (required for container renames)'),
+            workspaceFile: z.string().optional().describe('Parent workspace filename (required for container renames)'),
+        },
+        handler: async ({ type, filename, newName, containerId, workspaceFile }) => {
+            if (type === 'workspace') {
+                renameWorkspace(filename, newName);
+                broadcastWorkspacesChanged();
+                return { content: [{ type: 'text', text: `Renamed workspace to "${newName}"` }] };
+            }
+            if (type === 'container') {
+                const wsFile = workspaceFile || filename;
+                if (!containerId)
+                    return { content: [{ type: 'text', text: 'Error: containerId is required for container renames' }] };
+                renameContainer(wsFile, containerId, newName);
+                broadcastWorkspacesChanged();
+                return { content: [{ type: 'text', text: `Renamed container ${containerId} to "${newName}"` }] };
+            }
+            if (type === 'document') {
+                updateDocumentTitle(filename, newName);
+                broadcastDocumentsChanged();
+                if (filename === getActiveFilename()) {
+                    broadcastTitleChanged(newName);
+                }
+                return { content: [{ type: 'text', text: `Renamed document "${filename}" to "${newName}"` }] };
+            }
+            return { content: [{ type: 'text', text: `Error: unknown type "${type}"` }] };
+        },
+    },
     {
         name: 'edit_text',
-        description: 'Apply fine-grained text edits within a node. Find text by exact match and replace it, or add/remove marks on matched text. More precise than rewriting the whole node.',
+        description: 'Apply fine-grained text edits within a node. Find text by exact match and replace it, or add/remove marks on matched text. More precise than rewriting the whole node. Always specify filename — edits target that file directly without switching the user\'s view.',
         schema: {
             nodeId: z.string().describe('ID of the node to edit'),
             edits: z.array(z.object({
@@ -498,8 +567,16 @@ export const TOOL_REGISTRY = [
                 }).optional().describe('Mark to add to the matched text (e.g. link, bold)'),
                 removeMark: z.string().optional().describe('Mark type to remove from matched text'),
             })).describe('Array of text edits to apply'),
-        },
-        handler: async ({ nodeId, edits }) => {
+            filename: z.string().describe('Target filename (e.g. "My Essay.md"). Required — identifies which document to edit.'),
+        },
+        handler: async ({ nodeId, edits, filename }) => {
+            const targetIsNonActive = filename && filename !== getActiveFilename();
+            if (targetIsNonActive) {
+                const result = applyTextEditsToFile(filename, nodeId, edits);
+                if (result.success)
+                    broadcastPendingDocsChanged();
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
             return { content: [{ type: 'text', text: JSON.stringify(applyTextEdits(nodeId, edits)) }] };
         },
     },

package/dist/server/state.js

@@ -300,13 +300,11 @@ export function onChanges(listener) {
 // ============================================================================
 // generateNodeId imported from helpers.ts
 /**
- * Find a node by ID in the document tree.
- * Returns the parent array and index for in-place mutation.
+ * Find a node by ID in any document tree.
+ * topLevel is used to resolve the "end" sentinel.
  */
-function findNodeInDoc(nodes, id) {
-    // Special sentinel: "end" resolves to the last top-level node in the document
+function findNode(nodes, id, topLevel) {
     if (id === 'end') {
-        const topLevel = state.document.content;
         if (topLevel && topLevel.length > 0) {
             return { parent: topLevel, index: topLevel.length - 1 };
         }
@@ -317,36 +315,43 @@ function findNodeInDoc(nodes, id) {
             return { parent: nodes, index: i };
         }
         if (nodes[i].content && Array.isArray(nodes[i].content)) {
-            const result = findNodeInDoc(nodes[i].content, id);
+            const result = findNode(nodes[i].content, id, topLevel);
             if (result)
                 return result;
         }
     }
     return null;
 }
+/** Find a node in the active document. */
+function findNodeInDoc(nodes, id) {
+    return findNode(nodes, id, state.document.content);
+}
 /**
- * Apply changes to server-side document and return processed changes
- * with server-assigned IDs for broadcast to browsers.
+ * Core change application logic — operates on any document object.
+ * Mutates doc in place and returns processed changes with server-assigned IDs.
  */
-function applyChangesToDocument(changes) {
+function applyChangesToDoc(doc, changes) {
     const processed = [];
     for (const change of changes) {
         if (change.operation === 'rewrite' && change.nodeId && change.content) {
-            const found = findNodeInDoc(state.document.content, change.nodeId);
+            const found = findNode(doc.content, change.nodeId, doc.content);
             if (!found)
                 continue;
             const contentArray = Array.isArray(change.content) ? change.content : [change.content];
             const originalNode = structuredClone(found.parent[found.index]);
+            // Empty node rewrite → treat as insert (green, not blue)
+            const originalText = extractText(originalNode.content || []);
+            const isEmptyNode = !originalText.trim();
             // Only store original on first rewrite (preserve baseline for reject)
             const existingOriginal = found.parent[found.index].attrs?.pendingOriginalContent;
-            // First node replaces the target (rewrite)
+            // First node replaces the target (rewrite or insert if empty)
             const firstNode = {
                 ...contentArray[0],
                 attrs: {
                     ...contentArray[0].attrs,
                     id: change.nodeId,
-                    pendingStatus: 'rewrite',
-                    pendingOriginalContent: existingOriginal || originalNode,
+                    pendingStatus: isEmptyNode ? 'insert' : 'rewrite',
+                    ...(isEmptyNode ? {} : { pendingOriginalContent: existingOriginal || originalNode }),
                 },
             };
             // Additional nodes get inserted after as pending inserts
@@ -376,17 +381,20 @@ function applyChangesToDocument(changes) {
             }));
             // Mark leaf blocks as pending (not containers) for correct serialization
             markLeafBlocksAsPending(contentWithIds, 'insert');
+            let resolvedAfterId;
             if (change.nodeId && !change.afterNodeId) {
                 // Replace empty node
-                const found = findNodeInDoc(state.document.content, change.nodeId);
+                const found = findNode(doc.content, change.nodeId, doc.content);
                 if (!found)
                     continue;
                 found.parent.splice(found.index, 1, ...contentWithIds);
             }
             else if (change.afterNodeId) {
-                const found = findNodeInDoc(state.document.content, change.afterNodeId);
+                const found = findNode(doc.content, change.afterNodeId, doc.content);
                 if (!found)
                     continue;
+                // Resolve "end" sentinel to actual node ID so browser can find it
+                resolvedAfterId = found.parent[found.index]?.attrs?.id;
                 found.parent.splice(found.index + 1, 0, ...contentWithIds);
             }
             else {
@@ -395,11 +403,13 @@ function applyChangesToDocument(changes) {
             // Broadcast with server-assigned IDs so browser uses the same IDs
             processed.push({
                 ...change,
+                // Replace "end" with the resolved node ID so browser can look it up
+                ...(resolvedAfterId && change.afterNodeId === 'end' ? { afterNodeId: resolvedAfterId } : {}),
                 content: contentWithIds.length === 1 ? contentWithIds[0] : contentWithIds,
             });
         }
         else if (change.operation === 'delete' && change.nodeId) {
-            const found = findNodeInDoc(state.document.content, change.nodeId);
+            const found = findNode(doc.content, change.nodeId, doc.content);
             if (!found)
                 continue;
             found.parent[found.index] = {
@@ -412,6 +422,11 @@ function applyChangesToDocument(changes) {
             processed.push(change);
         }
     }
+    return processed;
+}
+/** Apply changes to the active document singleton. */
+function applyChangesToDocument(changes) {
+    const processed = applyChangesToDoc(state.document, changes);
     if (processed.length > 0) {
         state.lastModified = new Date();
     }
@@ -480,6 +495,15 @@ export function updatePendingCacheForActiveDoc() {
 export function removePendingCacheEntry(filename) {
     pendingDocCache.delete(filename);
 }
+/** Set the pending cache entry for a specific filename (for non-active doc population). */
+export function setPendingCacheEntry(filename, count) {
+    if (count > 0) {
+        pendingDocCache.set(filename, count);
+    }
+    else {
+        pendingDocCache.delete(filename);
+    }
+}
 /** Populate the pending cache from a full disk scan. Called once on startup. */
 function populatePendingCache() {
     pendingDocCache.clear();
@@ -511,6 +535,67 @@ function populatePendingCache() {
         catch { /* skip unreadable files */ }
     }
 }
+const docCache = new Map(); // key = filePath
+/** Cache the active document's full state, keyed by filePath. Call after save(). */
+export function cacheActiveDocument() {
+    if (!state.filePath)
+        return;
+    let fileMtime = 0;
+    try {
+        fileMtime = statSync(state.filePath).mtimeMs;
+    }
+    catch { /* file may not exist yet */ }
+    docCache.set(state.filePath, {
+        document: structuredClone(state.document),
+        metadata: structuredClone(state.metadata),
+        title: state.title,
+        isTemp: state.isTemp,
+        lastModified: state.lastModified,
+        docId: state.docId,
+        fileMtime,
+    });
+}
+/** Get a cached document if the file hasn't been modified externally. Returns null on miss or stale. */
+export function getCachedDocument(filePath) {
+    const cached = docCache.get(filePath);
+    if (!cached)
+        return null;
+    try {
+        const currentMtime = statSync(filePath).mtimeMs;
+        if (currentMtime !== cached.fileMtime) {
+            // File changed on disk — invalidate cache
+            docCache.delete(filePath);
+            return null;
+        }
+    }
+    catch {
+        // File doesn't exist or can't be read — invalidate
+        docCache.delete(filePath);
+        return null;
+    }
+    return cached;
+}
+/** Remove a specific file from the document cache. */
+export function invalidateDocCache(filePath) {
+    docCache.delete(filePath);
+}
+/** Update the cache entry for a file after writing changes (without cloning the active state). */
+function updateCacheEntry(filePath, doc, title, metadata, isTemp, docId) {
+    let fileMtime = 0;
+    try {
+        fileMtime = statSync(filePath).mtimeMs;
+    }
+    catch { /* best-effort */ }
+    docCache.set(filePath, {
+        document: structuredClone(doc),
+        metadata: structuredClone(metadata),
+        title,
+        isTemp,
+        lastModified: new Date(),
+        docId,
+        fileMtime,
+    });
+}
 // ============================================================================
 // PENDING DOCUMENT STORE OPERATIONS
 // ============================================================================
@@ -576,10 +661,20 @@ export function markAllNodesAsPending(doc, status) {
 export function getPendingDocInfo() {
     const filenames = [];
     const counts = {};
+    const stale = [];
     for (const [filename, count] of pendingDocCache) {
+        // Validate file still exists on disk (prunes ghost entries after server restart)
+        const filePath = isExternalDoc(filename) ? filename : join(DATA_DIR, filename);
+        if (!existsSync(filePath)) {
+            stale.push(filename);
+            continue;
+        }
         filenames.push(filename);
         counts[filename] = count;
     }
+    // Clean up stale entries
+    for (const f of stale)
+        pendingDocCache.delete(f);
     return { filenames, counts };
 }
 // ============================================================================
@@ -951,3 +1046,139 @@ export function stripPendingAttrsFromFile(filename, clearAgentCreated) {
     }
     catch { /* best-effort */ }
 }
+/**
+ * Populate a non-active document file with content.
+ * Writes directly to disk without touching the active singleton.
+ * Returns { title, wordCount, pendingCount } for the response message.
+ */
+/** Count pending nodes in a document tree. */
+function countPending(nodes) {
+    let count = 0;
+    if (!nodes)
+        return 0;
+    for (const node of nodes) {
+        if (node.attrs?.pendingStatus)
+            count++;
+        if (node.content)
+            count += countPending(node.content);
+    }
+    return count;
+}
+/** Write a mutated doc back to disk and update the pending cache. */
+function flushDocToFile(filename, doc, title, metadata) {
+    const targetPath = resolveDocPath(filename);
+    const markdown = tiptapToMarkdown(doc, title, metadata);
+    atomicWriteFileSync(targetPath, markdown);
+    setPendingCacheEntry(filename, countPending(doc.content));
+}
+export function populateDocumentFile(filename, doc) {
+    const targetPath = resolveDocPath(filename);
+    const raw = readFileSync(targetPath, 'utf-8');
+    const parsed = markdownToTiptap(raw);
+    markAllNodesAsPending(doc, 'insert');
+    flushDocToFile(filename, doc, parsed.title, parsed.metadata);
+    const pendingCount = countPending(doc.content);
+    const text = extractText(doc.content);
+    const wordCount = text.trim() ? text.trim().split(/\s+/).length : 0;
+    return { title: parsed.title, wordCount, pendingCount };
+}
+/**
+ * Apply node changes to a non-active document file on disk.
+ * Same logic as applyChanges but without touching the active singleton or broadcasting to browser.
+ */
+export function applyChangesToFile(filename, changes) {
+    const targetPath = resolveDocPath(filename);
+    // Try cache first — preserves stable node IDs
+    const cached = getCachedDocument(targetPath);
+    let doc;
+    let title;
+    let metadata;
+    let docId;
+    let isTemp;
+    if (cached) {
+        doc = structuredClone(cached.document);
+        title = cached.title;
+        metadata = cached.metadata;
+        docId = cached.docId;
+        isTemp = cached.isTemp;
+    }
+    else {
+        const raw = readFileSync(targetPath, 'utf-8');
+        const parsed = markdownToTiptap(raw);
+        doc = parsed.document;
+        title = parsed.title;
+        metadata = parsed.metadata;
+        docId = metadata.docId || '';
+        isTemp = false;
+    }
+    const processed = applyChangesToDoc(doc, changes);
+    if (processed.length > 0) {
+        flushDocToFile(filename, doc, title, metadata);
+        updateCacheEntry(targetPath, doc, title, metadata, isTemp, docId);
+    }
+    // Find the last created node ID for chaining inserts
+    let lastNodeId = null;
+    for (let i = processed.length - 1; i >= 0; i--) {
+        const change = processed[i];
+        if (change.content) {
+            const contentArr = Array.isArray(change.content) ? change.content : [change.content];
+            const lastNode = contentArr[contentArr.length - 1];
+            if (lastNode?.attrs?.id) {
+                lastNodeId = lastNode.attrs.id;
+                break;
+            }
+        }
+    }
+    return { count: processed.length, lastNodeId };
+}
+/**
+ * Apply fine-grained text edits to a node in a non-active document file on disk.
+ */
+export function applyTextEditsToFile(filename, nodeId, edits) {
+    const targetPath = resolveDocPath(filename);
+    // Try cache first — preserves stable node IDs
+    const cached = getCachedDocument(targetPath);
+    let doc;
+    let title;
+    let metadata;
+    let docId;
+    let isTemp;
+    if (cached) {
+        doc = structuredClone(cached.document);
+        title = cached.title;
+        metadata = cached.metadata;
+        docId = cached.docId;
+        isTemp = cached.isTemp;
+    }
+    else {
+        const raw = readFileSync(targetPath, 'utf-8');
+        const parsed = markdownToTiptap(raw);
+        doc = parsed.document;
+        title = parsed.title;
+        metadata = parsed.metadata;
+        docId = metadata.docId || '';
+        isTemp = false;
+    }
+    const found = findNode(doc.content, nodeId, doc.content);
+    if (!found)
+        return { success: false, error: `Node ${nodeId} not found` };
+    const originalNode = found.parent[found.index];
+    const result = applyTextEditsToNode(originalNode, edits);
+    if (!result)
+        return { success: false, error: 'No edits matched' };
+    result.node.attrs = {
+        ...result.node.attrs,
+        pendingTextEdits: result.textEdits,
+    };
+    // Apply as a rewrite to the doc
+    const processed = applyChangesToDoc(doc, [{
+            operation: 'rewrite',
+            nodeId,
+            content: result.node,
+        }]);
+    if (processed.length > 0) {
+        flushDocToFile(filename, doc, title, metadata);
+        updateCacheEntry(targetPath, doc, title, metadata, isTemp, docId);
+    }
+    return { success: true };
+}

package/dist/server/workspace-routes.js

@@ -3,7 +3,7 @@
  * Mounted in index.ts to keep the main file lean.
  */
 import { Router } from 'express';
-import { listWorkspaces, getWorkspace, createWorkspace, deleteWorkspace, reorderWorkspaces, addDoc, removeDoc, moveDoc, reorderDoc, addContainerToWorkspace, removeContainer, renameContainer, reorderContainer, } from './workspaces.js';
+import { listWorkspaces, getWorkspace, createWorkspace, deleteWorkspace, reorderWorkspaces, addDoc, removeDoc, moveDoc, reorderDoc, addContainerToWorkspace, removeContainer, renameContainer, renameWorkspace, reorderContainer, } from './workspaces.js';
 export function createWorkspaceRouter(b) {
     const router = Router();
     router.get('/api/workspaces', (_req, res) => {
@@ -30,6 +30,16 @@ export function createWorkspaceRouter(b) {
             res.status(404).json({ error: err.message });
         }
     });
+    router.put('/api/workspaces/:filename', (req, res) => {
+        try {
+            const ws = renameWorkspace(req.params.filename, req.body.title);
+            b.broadcastWorkspacesChanged();
+            res.json(ws);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
     router.delete('/api/workspaces/:filename', async (req, res) => {
         try {
             await deleteWorkspace(req.params.filename);

package/dist/server/workspaces.js

@@ -234,6 +234,12 @@ export function renameContainer(wsFile, containerId, name) {
     writeWorkspace(wsFile, ws);
     return ws;
 }
+export function renameWorkspace(wsFile, newTitle) {
+    const ws = getWorkspace(wsFile);
+    ws.title = newTitle;
+    writeWorkspace(wsFile, ws);
+    return ws;
+}
 export function reorderContainer(wsFile, containerId, afterIdentifier) {
     const ws = getWorkspace(wsFile);
     reorderNode(ws.root, containerId, afterIdentifier);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openwriter",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "The open-source writing surface for AI agents. Markdown-native editor with pending change review — your agent writes, you accept or reject.",
   "type": "module",
   "license": "MIT",

package/skill/SKILL.md

@@ -3,7 +3,7 @@ name: openwriter
 description: |
   OpenWriter — the writing surface for AI agents. A markdown-native rich text
   editor where agents write via MCP tools and users accept or reject changes
-  in-browser. 30 MCP tools for document editing, multi-doc workspaces, and
+  in-browser. 31 MCP tools for document editing, multi-doc workspaces, and
   organization. Tweet compose mode for drafting replies/QTs with pixel-accurate
   X/Twitter UI. Plain .md files on disk — no database, no lock-in.
 
@@ -14,7 +14,7 @@ description: |
   Requires: OpenWriter MCP server configured. Browser UI at localhost:5050.
 metadata:
   author: travsteward
-  version: "0.4.0"
+  version: "0.5.0"
   repository: https://github.com/travsteward/openwriter
 license: MIT
 ---
@@ -38,7 +38,7 @@ Skip to [Writing Strategy](#writing-strategy) below.
 
 ### MCP tools are NOT available (skill-first install)
 
-The user installed this skill from a directory but hasn't set up the MCP server yet. OpenWriter needs an MCP server to provide the 30 editing tools.
+The user installed this skill from a directory but hasn't set up the MCP server yet. OpenWriter needs an MCP server to provide the 31 editing tools.
 
 **Step 1:** Tell the user to install globally and add the MCP server:
 
@@ -123,6 +123,7 @@ After editing, tell the user:
 | `tag_doc` | Add a tag to a document (stored in doc frontmatter) |
 | `untag_doc` | Remove a tag from a document (stored in doc frontmatter) |
 | `move_doc` | Move a document to a different container or root level |
+| `rename_item` | Rename a workspace, container, or document (type: workspace/container/document) |
 
 ### Text Operations
 
@@ -153,7 +154,7 @@ OpenWriter has two distinct modes: **editing** existing documents and **creating
 
 For making changes to existing documents — rewrites, insertions, deletions:
 
-- Use `write_to_pad` for all edits
+- Use `write_to_pad` for all edits — **`filename` is required**
 - Send **3-8 changes per call** for a responsive, streaming feel
 - Always `read_pad` before editing to get fresh node IDs
 - Respect `pendingChanges > 0` — wait for the user to accept/reject before sending more
@@ -202,7 +203,7 @@ This eliminates the need for separate `create_workspace`, `create_container`, an
 ```
 1. get_pad_status  → check pendingChanges and userSignaledReview
 2. read_pad        → get full document with node IDs
-3. write_to_pad    → send changes (3-8 per call)
+3. write_to_pad({ filename: "Doc.md", changes: [...] })
 4. Wait            → user accepts/rejects in browser
 ```
 
@@ -210,9 +211,9 @@ This eliminates the need for separate `create_workspace`, `create_container`, an
 
 ```
 1. list_documents    → see all docs, find target
-2. switch_document   → save current, load target (returns content)
-3. read_pad          → read full content with node IDs
-4. write_to_pad      → apply edits
+2. read_pad          → read active doc (or switch_document first)
+3. write_to_pad({ filename: "Target.md", changes: [...] })
+                     → edits go to the named file, no view switch needed
 ```
 
 ### Creating new content (two-step)