openwriter 0.8.7 → 0.9.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, getIsTemp, getMetadata, save, cancelDebouncedSave, setActiveDocument, registerExternalDoc, unregisterExternalDoc, getExternalDocs, cacheActiveDocument, getCachedDocument, invalidateDocCache, removePendingCacheEntry, } from './state.js';
+import { getDocument, getTitle, getFilePath, getIsTemp, getMetadata, save, cancelDebouncedSave, setActiveDocument, registerExternalDoc, unregisterExternalDoc, getExternalDocs, cacheActiveDocument, getCachedDocument, invalidateDocCache, removePendingCacheEntry, resetDocVersion, } from './state.js';
 import { getDataDir, TEMP_PREFIX, ensureDataDir, filePathForTitle, tempFilePath, generateNodeId, resolveDocPath, isExternalDoc, atomicWriteFileSync } from './helpers.js';
 import { ensureDocId } from './versions.js';
 import { renameDocInAllWorkspaces, removeDocFromAllWorkspaces } from './workspaces.js';
@@ -71,6 +71,22 @@ function writeDocOrder(order) {
 export function reorderDocs(orderedFilenames) {
     writeDocOrder(orderedFilenames);
 }
+/** Derive content_type from frontmatter — explicit field first, then fallback from context keys. */
+function deriveContentType(data) {
+    if (data.content_type)
+        return data.content_type;
+    if (data.tweetContext)
+        return data.tweetContext.mode || 'tweet';
+    if (data.articleContext)
+        return 'article';
+    if (data.linkedinContext)
+        return 'linkedin';
+    if (data.newsletterContext)
+        return 'newsletter';
+    if (data.blogContext)
+        return 'blog';
+    return undefined;
+}
 export function listDocuments() {
     ensureDataDir();
     const currentPath = getFilePath();
@@ -103,6 +119,7 @@ export function listDocuments() {
                 ...(data.newsletterContext?.lastSend?.sentAt ? { lastSent: data.newsletterContext.lastSend.sentAt } : data.tweetContext?.lastPost?.postedAt ? { lastSent: data.tweetContext.lastPost.postedAt } : data.blogContext?.lastPublish?.publishedAt ? { lastSent: data.blogContext.lastPublish.publishedAt } : data.articleContext?.lastPost?.postedAt ? { lastSent: data.articleContext.lastPost.postedAt } : data.manualPost?.postedAt ? { lastSent: data.manualPost.postedAt } : {}),
                 ...(data.tweetContext?.lastPost?.tweetUrl ? { postedUrl: data.tweetContext.lastPost.tweetUrl } : {}),
                 ...(data.newsletterContext ? { isNewsletter: true } : {}),
+                ...(deriveContentType(data) ? { contentType: deriveContentType(data) } : {}),
             };
         }
         catch {
@@ -140,6 +157,7 @@ export function listDocuments() {
                 ...(data.newsletterContext?.lastSend?.sentAt ? { lastSent: data.newsletterContext.lastSend.sentAt } : data.tweetContext?.lastPost?.postedAt ? { lastSent: data.tweetContext.lastPost.postedAt } : data.blogContext?.lastPublish?.publishedAt ? { lastSent: data.blogContext.lastPublish.publishedAt } : {}),
                 ...(data.tweetContext?.lastPost?.tweetUrl ? { postedUrl: data.tweetContext.lastPost.tweetUrl } : {}),
                 ...(data.newsletterContext ? { isNewsletter: true } : {}),
+                ...(deriveContentType(data) ? { contentType: deriveContentType(data) } : {}),
             });
         }
         catch { /* skip unreadable external files */ }
@@ -363,6 +381,8 @@ export function switchDocument(filename) {
     save();
     // Cache current doc before switching (preserves node IDs)
     cacheActiveDocument();
+    // Reset version counter — new document starts a fresh version lineage
+    resetDocVersion();
     // Read target from disk — markdownToTiptap rehydrates pending state
     const targetPath = resolveDocPath(filename);
     if (!existsSync(targetPath)) {
@@ -673,3 +693,121 @@ export function promoteTempFile(newTitle) {
     renameMark(oldFilename, newFilename);
     return newFilename;
 }
+// ============================================================================
+// BATCH RESOLVE — accept/reject pending changes across multiple docs
+// ============================================================================
+const PENDING_ATTRS = ['pendingStatus', 'pendingOriginalContent', 'pendingGroupId', 'pendingSelectionFrom', 'pendingSelectionTo', 'pendingOriginalFrom', 'pendingOriginalTo'];
+function clearPendingAttrs(attrs) {
+    const clean = { ...attrs };
+    for (const key of PENDING_ATTRS)
+        delete clean[key];
+    return clean;
+}
+/** Walk TipTap JSON, accept all pending changes in-place. Returns count of resolved nodes. */
+function acceptAllInDoc(doc) {
+    let count = 0;
+    function walk(nodes) {
+        const result = [];
+        for (const node of nodes) {
+            const status = node.attrs?.pendingStatus;
+            if (status === 'delete') {
+                count++;
+                continue; // Remove delete nodes
+            }
+            if (status === 'insert' || status === 'rewrite') {
+                node.attrs = clearPendingAttrs(node.attrs);
+                count++;
+            }
+            if (node.content) {
+                node.content = walk(node.content);
+            }
+            result.push(node);
+        }
+        return result;
+    }
+    if (doc.content)
+        doc.content = walk(doc.content);
+    return count;
+}
+/** Walk TipTap JSON, reject all pending changes in-place. Returns count of resolved nodes. */
+function rejectAllInDoc(doc) {
+    let count = 0;
+    function walk(nodes) {
+        const result = [];
+        for (const node of nodes) {
+            const status = node.attrs?.pendingStatus;
+            if (status === 'insert') {
+                count++;
+                continue; // Remove inserted nodes
+            }
+            if (status === 'rewrite') {
+                const original = node.attrs?.pendingOriginalContent;
+                if (original) {
+                    // Replace with original content
+                    result.push(original);
+                }
+                // If no original, just drop the node
+                count++;
+                continue;
+            }
+            if (status === 'delete') {
+                // Keep the node, just clear pending status
+                node.attrs = clearPendingAttrs(node.attrs);
+                count++;
+            }
+            if (node.content) {
+                node.content = walk(node.content);
+            }
+            result.push(node);
+        }
+        return result;
+    }
+    if (doc.content)
+        doc.content = walk(doc.content);
+    return count;
+}
+/** Resolve a single doc file on disk. Returns number of changes resolved. */
+function resolveDocFile(filePath, action) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const { data } = matter(raw);
+    // Skip docs with no pending changes
+    if (!data.pending)
+        return 0;
+    // Pass full raw file — markdownToTiptap calls matter() internally and rehydrates pending state
+    const parsed = markdownToTiptap(raw);
+    const doc = parsed.document;
+    const count = action === 'accept' ? acceptAllInDoc(doc) : rejectAllInDoc(doc);
+    if (count === 0)
+        return 0;
+    // Re-serialize — pending attrs are cleared so pending key will be removed from frontmatter
+    const newRaw = tiptapToMarkdown(doc, parsed.title, parsed.metadata);
+    atomicWriteFileSync(filePath, newRaw);
+    return count;
+}
+export function batchResolve(filenames, action) {
+    let docsResolved = 0;
+    let changesResolved = 0;
+    for (const filename of filenames) {
+        const filePath = isExternalDoc(filename) ? filename : join(getDataDir(), filename);
+        if (!existsSync(filePath))
+            continue;
+        try {
+            const count = resolveDocFile(filePath, action);
+            if (count > 0) {
+                docsResolved++;
+                changesResolved += count;
+                // Active doc: update in-memory state directly (no reload flicker)
+                if (filePath === getFilePath()) {
+                    const currentDoc = getDocument();
+                    if (action === 'accept')
+                        acceptAllInDoc(currentDoc);
+                    else
+                        rejectAllInDoc(currentDoc);
+                    save();
+                }
+            }
+        }
+        catch { /* skip unreadable files */ }
+    }
+    return { docsResolved, changesResolved };
+}

package/dist/server/index.js

@@ -11,9 +11,9 @@ import { setupWebSocket, broadcastAgentStatus, broadcastDocumentSwitched, broadc
 import { TOOL_REGISTRY } from './mcp.js';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
-import { save, cancelDebouncedSave, load, getDocument, getTitle, getFilePath, getDocId, getMetadata, getStatus, updateDocument, setMetadata, applyTextEdits, isAgentLocked, getPendingDocInfo, getDocTagsByFilename, addDocTag, removeDocTag, markAllNodesAsPending, updatePendingCacheForActiveDoc, clearAllCaches } from './state.js';
+import { save, cancelDebouncedSave, load, getDocument, getTitle, getFilePath, getDocId, getMetadata, getStatus, updateDocument, setMetadata, applyTextEdits, isAgentLocked, getPendingDocInfo, getDocTagsByFilename, addDocTag, removeDocTag, markAllNodesAsPending, updatePendingCacheForActiveDoc, removePendingCacheEntry, clearAllCaches } from './state.js';
 import { syncPostHistory } from './post-sync.js';
-import { listDocuments, switchDocument, createDocument, deleteDocument, duplicateDocument, reloadDocument, updateDocumentTitle, openFile, reorderDocs, searchDocuments, listArchivedDocuments, archiveDocument, unarchiveDocument, getActiveFilename } from './documents.js';
+import { listDocuments, switchDocument, createDocument, deleteDocument, duplicateDocument, reloadDocument, updateDocumentTitle, openFile, reorderDocs, searchDocuments, listArchivedDocuments, archiveDocument, unarchiveDocument, getActiveFilename, batchResolve } from './documents.js';
 import { createWorkspaceRouter } from './workspace-routes.js';
 import { createLinkRouter } from './link-routes.js';
 import { createTweetRouter } from './tweet-routes.js';
@@ -267,6 +267,32 @@ export async function startHttpServer(options = {}) {
             res.status(400).json({ error: err.message });
         }
     });
+    app.post('/api/documents/batch-resolve', (req, res) => {
+        try {
+            const { filenames, action } = req.body;
+            if (!Array.isArray(filenames) || !filenames.length) {
+                res.status(400).json({ error: 'filenames array is required' });
+                return;
+            }
+            if (action !== 'accept' && action !== 'reject') {
+                res.status(400).json({ error: 'action must be "accept" or "reject"' });
+                return;
+            }
+            const result = batchResolve(filenames, action);
+            if (result.docsResolved > 0) {
+                // Clear pending cache for resolved docs + broadcast
+                for (const fn of filenames)
+                    removePendingCacheEntry(fn);
+                updatePendingCacheForActiveDoc();
+                broadcastPendingDocsChanged();
+                broadcastDocumentsChanged();
+            }
+            res.json(result);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
     app.post('/api/documents/open', (req, res) => {
         try {
             const { path } = req.body;

package/dist/server/mcp.js

@@ -24,15 +24,15 @@ import { markdownToTiptap, tiptapToMarkdown } from './markdown.js';
 import { getMarks, getMarkCount, getGlobalMarkSummary, resolveMarks } from './marks.js';
 import { readTasks, addTask, updateTask, removeTask } from './tasks.js';
 /** Map a content type string to its frontmatter metadata object. */
-function resolveTypeMeta(type) {
+function resolveTypeMeta(type, url) {
     switch (type) {
-        case 'tweet': return { tweetContext: { mode: 'tweet' } };
-        case 'reply': return { tweetContext: { mode: 'reply' } };
-        case 'quote': return { tweetContext: { mode: 'quote' } };
-        case 'article': return { articleContext: { active: true } };
-        case 'linkedin': return { linkedinContext: { active: true } };
-        case 'newsletter': return { newsletterContext: { active: true } };
-        case 'blog': return { blogContext: { active: true } };
+        case 'tweet': return { content_type: 'tweet', tweetContext: { mode: 'tweet' } };
+        case 'reply': return { content_type: 'reply', tweetContext: { mode: 'reply', ...(url ? { url } : {}) } };
+        case 'quote': return { content_type: 'quote', tweetContext: { mode: 'quote', ...(url ? { url } : {}) } };
+        case 'article': return { content_type: 'article', articleContext: { active: true } };
+        case 'linkedin': return { content_type: 'linkedin', linkedinContext: { active: true } };
+        case 'newsletter': return { content_type: 'newsletter', newsletterContext: { active: true } };
+        case 'blog': return { content_type: 'blog', blogContext: { active: true } };
         default: return undefined;
     }
 }
@@ -271,18 +271,23 @@ export const TOOL_REGISTRY = [
     },
     {
         name: 'create_document',
-        description: 'Create a new document. Always provide a title. By default shows a sidebar spinner — call populate_document next to deliver content and clear it. This two-step flow is REQUIRED for all content documents: create_document → populate_document. Do NOT use empty=true to skip this — empty=true is ONLY for content_type template docs (tweets, articles) that start blank and get metadata via set_metadata. If workspace is provided, the doc is automatically added to it (workspace is created if it doesn\'t exist). If container is also provided, the doc is placed inside that container (created if it doesn\'t exist).',
+        description: 'Create a new document. content_type is REQUIRED — use "document" for plain docs, or "tweet"/"reply"/"quote"/"article"/"linkedin"/"newsletter"/"blog" for typed docs. Always provide a title. By default shows a sidebar spinner — call populate_document next to deliver content and clear it. This two-step flow is REQUIRED for all content documents: create_document → populate_document. Use empty=true ONLY for typed docs (tweets, articles) that start blank and get written to incrementally via write_to_pad. If workspace is provided, the doc is automatically added to it (workspace is created if it doesn\'t exist). If container is also provided, the doc is placed inside that container (created if it doesn\'t exist).',
         schema: {
             title: z.string().optional().describe('Title for the new document. Defaults to "Untitled".'),
             path: z.string().optional().describe('Absolute file path to create the document at (e.g. "C:/projects/doc.md"). If omitted, creates in ~/.openwriter/.'),
             workspace: z.string().optional().describe('Workspace title to add this doc to. Creates the workspace if it doesn\'t exist.'),
             container: z.string().optional().describe('Container name within the workspace (e.g. "Chapters", "Notes", "References"). Creates the container if it doesn\'t exist. Requires workspace.'),
             empty: z.boolean().optional().describe('ONLY for content_type template docs (tweets, articles) that start blank. Skips the spinner and switches immediately. Do NOT set this for content documents — use the two-step flow (create_document → populate_document) instead.'),
-            content_type: z.string().optional().describe('Content type: tweet, reply, quote, article, linkedin, newsletter, or blog. Sets metadata so the doc is recognized as that type. For reply/quote, use set_metadata after creation to set the target tweet URL.'),
+            content_type: z.enum(['document', 'tweet', 'reply', 'quote', 'article', 'linkedin', 'newsletter', 'blog']).describe('Required. Use "document" for plain documents. Tweet/reply/quote/article/linkedin/newsletter/blog set type-specific metadata automatically.'),
+            url: z.string().optional().describe('Tweet URL — REQUIRED for content_type "reply" or "quote" (e.g. "https://x.com/user/status/123"). Sets tweetContext.url automatically. Ignored for other content types.'),
         },
-        handler: async ({ title, path, workspace, container, empty, content_type }) => {
+        handler: async ({ title, path, workspace, container, empty, content_type, url }) => {
+            // Require url for reply/quote
+            if ((content_type === 'reply' || content_type === 'quote') && !url) {
+                return { content: [{ type: 'text', text: `Error: content_type "${content_type}" requires a url parameter (e.g. "https://x.com/user/status/123").` }] };
+            }
             // Default title from content_type if not provided
-            if (!title && content_type) {
+            if (!title && content_type && content_type !== 'document') {
                 const typeDefaults = {
                     tweet: 'Tweet', reply: 'Reply', quote: 'Quote Tweet', article: 'Article',
                     linkedin: 'LinkedIn Post', newsletter: 'Newsletter', blog: 'Blog Post',
@@ -313,7 +318,7 @@ export const TOOL_REGISTRY = [
                     const result = createDocument(title, undefined, path);
                     // Apply type-specific metadata
                     if (content_type) {
-                        const typeMeta = resolveTypeMeta(content_type);
+                        const typeMeta = resolveTypeMeta(content_type, url);
                         if (typeMeta) {
                             setMetadata(typeMeta);
                         }
@@ -337,7 +342,7 @@ export const TOOL_REGISTRY = [
                 }
                 // Two-step flow: create file on disk WITHOUT switching the user's view.
                 // The spinner persists in the sidebar until populate_document is called.
-                const typeMeta = content_type ? resolveTypeMeta(content_type) : undefined;
+                const typeMeta = content_type ? resolveTypeMeta(content_type, url) : undefined;
                 const result = createDocumentFile(title, path, typeMeta);
                 let wsInfo = '';
                 if (wsTarget) {
@@ -875,7 +880,7 @@ export const TOOL_REGISTRY = [
     },
     {
         name: 'insert_image',
-        description: 'Generate an image via Gemini and optionally insert it inline or set it as article cover. Three modes: (1) docId + afterNodeId → generate + insert inline with pending decoration. (2) set_cover: true → generate + set as article cover. (3) Neither → generate to disk only, returns path. Requires GEMINI_API_KEY env var.',
+        description: 'Generate an image via Gemini and optionally insert it inline or set it as article cover. Three modes: (1) docId + afterNodeId → generate + insert inline with pending decoration. (2) set_cover: true → generate + set as article cover. (3) Neither → generate to disk only, returns path. Uses local GEMINI_API_KEY if set, otherwise falls back to publish platform API.',
         schema: {
             prompt: z.string().max(1000).describe('Gemini image generation prompt (max 1000 chars).'),
             docId: z.string().optional().describe('Target document by docId (8-char hex). Required for inline insert.'),
@@ -885,10 +890,6 @@ export const TOOL_REGISTRY = [
             set_cover: z.boolean().optional().describe('If true, set the generated image as the article cover (articleContext.coverImage in metadata).'),
         },
         handler: async ({ prompt, docId, afterNodeId, aspect_ratio, alt, set_cover }) => {
-            const apiKey = process.env.GEMINI_API_KEY;
-            if (!apiKey) {
-                return { content: [{ type: 'text', text: 'Error: GEMINI_API_KEY environment variable is not set.' }] };
-            }
             const inlineMode = docId && afterNodeId;
             const filename = inlineMode ? resolveDocId(docId) : undefined;
             const targetIsNonActive = filename && filename !== getActiveFilename();
@@ -905,32 +906,70 @@ export const TOOL_REGISTRY = [
                 applyChanges([loadingChange]);
             }
             try {
-                // Generate image via Gemini
-                const { GoogleGenAI } = await import('@google/genai');
-                const ai = new GoogleGenAI({ apiKey });
-                const response = await ai.models.generateContent({
-                    model: 'gemini-3.1-flash-image-preview',
-                    contents: `Generate a ${aspect_ratio || '16:9'} aspect ratio image: ${prompt}`,
-                    config: {
-                        responseModalities: ['IMAGE'],
-                    },
-                });
-                const parts = response.candidates?.[0]?.content?.parts;
-                const imagePart = parts?.find((p) => p.inlineData);
-                if (!imagePart?.inlineData?.data) {
-                    if (inlineMode && !targetIsNonActive) {
-                        applyChanges([{ operation: 'delete', nodeId: loadingNodeId }]);
+                let imgFilename;
+                const apiKey = process.env.GEMINI_API_KEY;
+                if (apiKey) {
+                    // Generate image via local Gemini
+                    const { GoogleGenAI } = await import('@google/genai');
+                    const ai = new GoogleGenAI({ apiKey });
+                    const response = await ai.models.generateContent({
+                        model: 'gemini-3.1-flash-image-preview',
+                        contents: `Generate a ${aspect_ratio || '16:9'} aspect ratio image: ${prompt}`,
+                        config: {
+                            responseModalities: ['IMAGE'],
+                        },
+                    });
+                    const parts = response.candidates?.[0]?.content?.parts;
+                    const imagePart = parts?.find((p) => p.inlineData);
+                    if (!imagePart?.inlineData?.data) {
+                        if (inlineMode && !targetIsNonActive) {
+                            applyChanges([{ operation: 'delete', nodeId: loadingNodeId }]);
+                        }
+                        return { content: [{ type: 'text', text: 'Error: Gemini returned no image data.' }] };
+                    }
+                    ensureDataDir();
+                    const imagesDir = join(getDataDir(), '_images');
+                    if (!existsSync(imagesDir))
+                        mkdirSync(imagesDir, { recursive: true });
+                    imgFilename = `${randomUUID().slice(0, 8)}.png`;
+                    writeFileSync(join(imagesDir, imgFilename), Buffer.from(imagePart.inlineData.data, 'base64'));
+                }
+                else {
+                    // Fallback: generate via publish platform API
+                    const { platformFetch, isAuthenticated } = await import('./connections.js');
+                    if (!isAuthenticated()) {
+                        if (inlineMode && !targetIsNonActive) {
+                            try {
+                                applyChanges([{ operation: 'delete', nodeId: loadingNodeId }]);
+                            }
+                            catch { }
+                        }
+                        return { content: [{ type: 'text', text: 'Error: No GEMINI_API_KEY and publish platform not configured. Set GEMINI_API_KEY or log in to the publish plugin.' }] };
+                    }
+                    const res = await platformFetch('/images/generate', {
+                        method: 'POST',
+                        body: JSON.stringify({ prompt, aspect_ratio: aspect_ratio || '16:9' }),
+                    });
+                    if (!res.ok) {
+                        const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+                        if (inlineMode && !targetIsNonActive) {
+                            try {
+                                applyChanges([{ operation: 'delete', nodeId: loadingNodeId }]);
+                            }
+                            catch { }
+                        }
+                        return { content: [{ type: 'text', text: `Error: ${err.error || 'Platform generation failed'}` }] };
                     }
-                    return { content: [{ type: 'text', text: 'Error: Gemini returned no image data.' }] };
+                    const data = await res.json();
+                    const imageRes = await fetch(data.url);
+                    const imageBuffer = Buffer.from(await imageRes.arrayBuffer());
+                    ensureDataDir();
+                    const imagesDir = join(getDataDir(), '_images');
+                    if (!existsSync(imagesDir))
+                        mkdirSync(imagesDir, { recursive: true });
+                    imgFilename = `${randomUUID().slice(0, 8)}.png`;
+                    writeFileSync(join(imagesDir, imgFilename), imageBuffer);
                 }
-                // Save to ~/.openwriter/_images/
-                ensureDataDir();
-                const imagesDir = join(getDataDir(), '_images');
-                if (!existsSync(imagesDir))
-                    mkdirSync(imagesDir, { recursive: true });
-                const imgFilename = `${randomUUID().slice(0, 8)}.png`;
-                const imgPath = join(imagesDir, imgFilename);
-                writeFileSync(imgPath, Buffer.from(imagePart.inlineData.data, 'base64'));
                 const src = `/_images/${imgFilename}`;
                 // Mode 1: Inline insert
                 if (inlineMode) {

package/dist/server/state.js

@@ -456,6 +456,24 @@ export function setAgentLock() {
 export function isAgentLocked() {
     return Date.now() - lastAgentWriteTime < AGENT_LOCK_MS;
 }
+// ---- Document version counter: prevents stale browser doc-updates ----
+let docVersion = 0;
+/** Increment version after agent writes. Returns the new version. */
+export function bumpDocVersion() {
+    return ++docVersion;
+}
+/** Get current document version. */
+export function getDocVersion() {
+    return docVersion;
+}
+/** Check if a browser doc-update version is current. */
+export function isVersionCurrent(browserVersion) {
+    return browserVersion >= docVersion;
+}
+/** Reset version on document switch (new document = new version lineage). */
+export function resetDocVersion() {
+    docVersion = 0;
+}
 // ---- Debounced save: coalesces rapid agent writes into a single disk write ----
 let saveTimer = null;
 const SAVE_DEBOUNCE_MS = 500;
@@ -477,11 +495,12 @@ export function cancelDebouncedSave() {
 export function applyChanges(changes) {
     // Apply to server-side document (source of truth)
     const processed = applyChangesToDocument(changes);
-    // Lock browser doc-updates to prevent stale state overwrite
+    // Bump version + lock browser doc-updates to prevent stale state overwrite
+    const version = bumpDocVersion();
     setAgentLock();
-    // Broadcast processed changes (with server-assigned IDs) to browser clients
+    // Broadcast processed changes (with server-assigned IDs + version) to browser clients
     for (const listener of listeners) {
-        listener(processed);
+        listener(processed, version);
     }
     // Debounced save — coalesces rapid agent writes into a single disk write
     debouncedSave();
@@ -543,6 +562,10 @@ function findNodeInDoc(nodes, id) {
  */
 function applyChangesToDoc(doc, changes) {
     const processed = [];
+    // Track last insert anchor → last inserted node ID, so consecutive inserts
+    // with the same afterNodeId chain naturally (array order = document order).
+    let lastInsertAnchor = null;
+    let lastInsertedId = null;
     for (const change of changes) {
         if (change.operation === 'rewrite' && change.nodeId && change.content) {
             const found = findNode(doc.content, change.nodeId, doc.content);
@@ -608,6 +631,12 @@ function applyChangesToDoc(doc, changes) {
             // Mark leaf blocks as pending (not containers) for correct serialization
             markLeafBlocksAsPending(contentWithIds, 'insert');
             let resolvedAfterId;
+            // Auto-chain: if this insert targets the same anchor as the previous insert,
+            // redirect it to insert after the last inserted node instead (preserves array order).
+            let effectiveAfterId = change.afterNodeId;
+            if (effectiveAfterId && effectiveAfterId === lastInsertAnchor && lastInsertedId) {
+                effectiveAfterId = lastInsertedId;
+            }
             if (change.nodeId && !change.afterNodeId) {
                 // Replace empty node
                 const found = findNode(doc.content, change.nodeId, doc.content);
@@ -615,8 +644,8 @@ function applyChangesToDoc(doc, changes) {
                     continue;
                 found.parent.splice(found.index, 1, ...contentWithIds);
             }
-            else if (change.afterNodeId) {
-                const found = findNode(doc.content, change.afterNodeId, doc.content);
+            else if (effectiveAfterId) {
+                const found = findNode(doc.content, effectiveAfterId, doc.content);
                 if (!found)
                     continue;
                 // Resolve "end" sentinel to actual node ID so browser can find it
@@ -626,11 +655,21 @@ function applyChangesToDoc(doc, changes) {
             else {
                 continue;
             }
-            // Broadcast with server-assigned IDs so browser uses the same IDs
+            // Track for auto-chaining: remember original anchor + last inserted ID
+            const newLastId = contentWithIds[contentWithIds.length - 1]?.attrs?.id;
+            if (change.afterNodeId && newLastId) {
+                if (change.afterNodeId !== lastInsertAnchor) {
+                    // New anchor — start fresh chain
+                    lastInsertAnchor = change.afterNodeId;
+                }
+                lastInsertedId = newLastId;
+            }
+            // Broadcast with server-assigned IDs and resolved anchor so browser inserts at the correct position
             processed.push({
                 ...change,
-                // Replace "end" with the resolved node ID so browser can look it up
-                ...(resolvedAfterId && change.afterNodeId === 'end' ? { afterNodeId: resolvedAfterId } : {}),
+                afterNodeId: resolvedAfterId && change.afterNodeId === 'end'
+                    ? resolvedAfterId
+                    : effectiveAfterId ?? change.afterNodeId,
                 content: contentWithIds.length === 1 ? contentWithIds[0] : contentWithIds,
             });
         }

package/dist/server/ws.js

@@ -2,7 +2,7 @@
  * WebSocket handler: pushes NodeChanges to browser, receives doc updates + signals.
  */
 import { WebSocketServer, WebSocket } from 'ws';
-import { updateDocument, getDocument, getTitle, getFilePath, getDocId, getMetadata, setMetadata, save, onChanges, isAgentLocked, setAgentLock, getPendingDocInfo, updatePendingCacheForActiveDoc, stripPendingAttrs, saveDocToFile, stripPendingAttrsFromFile, } from './state.js';
+import { updateDocument, getDocument, getTitle, getFilePath, getDocId, getMetadata, setMetadata, save, onChanges, isAgentLocked, setAgentLock, getDocVersion, isVersionCurrent, getPendingDocInfo, updatePendingCacheForActiveDoc, stripPendingAttrs, saveDocToFile, stripPendingAttrsFromFile, } from './state.js';
 import { switchDocument, createDocument, deleteDocument, getActiveFilename, promoteTempFile } from './documents.js';
 import { removeDocFromAllWorkspaces } from './workspaces.js';
 const clients = new Set();
@@ -45,7 +45,7 @@ export function setupWebSocket(server) {
         },
     });
     // Push agent changes to all browser clients
-    onChanges((changes) => {
+    onChanges((changes, version) => {
         // Check if changes include HR nodes in a tweet thread document.
         // Tweet editors don't support horizontalRule in their schema, so individual
         // node-changes with HRs silently fail. Send a full document resync instead,
@@ -81,7 +81,7 @@ export function setupWebSocket(server) {
             }
         }
         else {
-            const msg = JSON.stringify({ type: 'node-changes', changes });
+            const msg = JSON.stringify({ type: 'node-changes', changes, version });
             for (const ws of clients) {
                 if (ws.readyState === WebSocket.OPEN)
                     ws.send(msg);
@@ -123,9 +123,14 @@ export function setupWebSocket(server) {
                     const docContent = msg.document?.content || [];
                     const nodeCount = docContent.length;
                     const currentNodeCount = getDocument()?.content?.length || 0;
+                    const browserVersion = typeof msg.version === 'number' ? msg.version : -1;
+                    const serverVersion = getDocVersion();
                     if (isAgentLocked()) {
                         console.log(`[WS] doc-update BLOCKED by agent lock (browser: ${nodeCount} nodes, server: ${currentNodeCount} nodes)`);
                     }
+                    else if (browserVersion >= 0 && !isVersionCurrent(browserVersion)) {
+                        console.log(`[WS] doc-update BLOCKED by stale version (browser: v${browserVersion}, server: v${serverVersion})`);
+                    }
                     else if (msg.filename && msg.filename !== getActiveFilename()) {
                         // Browser sent a doc-update for a different document (race: server switched away).
                         // Save directly to that file on disk instead of corrupting the active doc.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openwriter",
-  "version": "0.8.7",
+  "version": "0.9.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",