npm - openwriter - Versions diffs - 0.9.3 → 0.11.0 - Mend

openwriter 0.9.3 → 0.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/dist/client/assets/index-Cc-WcvZz.css +1 -0
package/dist/client/assets/index-DCMxNd__.js +211 -0
package/dist/client/index.html +2 -2
package/dist/plugins/authors-voice/dist/index.js +13 -11
package/dist/plugins/publish/dist/helpers.d.ts +12 -0
package/dist/plugins/publish/dist/index.js +138 -0
package/dist/server/documents.js +6 -0
package/dist/server/index.js +23 -5
package/dist/server/mcp.js +81 -11
package/dist/server/ws.js +68 -15
package/package.json +1 -1
package/skill/SKILL.md +33 -1
package/skill/docs/anti-ai.md +71 -0
package/skill/docs/voices.md +88 -0
package/skill/voices/authority.md +102 -0
package/skill/voices/business.md +103 -0
package/skill/voices/logical.md +104 -0
package/skill/voices/provocateur.md +101 -0
package/skill/voices/storyteller.md +104 -0
package/dist/client/assets/index-ZQ1BICWp.css +0 -1
package/dist/client/assets/index-wRyjoTwK.js +0 -211
package/dist/server/prompt-debug.js +0 -58
package/dist/server/workspace-tags.js +0 -30

package/dist/client/index.html CHANGED Viewed

@@ -10,8 +10,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Charter:ital,wght@0,400;0,700;1,400&family=Crimson+Pro:ital,wght@0,300;0,400;0,600;0,700;1,400&family=DM+Sans:ital,wght@0,400;0,500;0,600;0,700;1,400&family=DM+Serif+Display&family=IBM+Plex+Mono:wght@400;500;600&family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600;700&family=Libre+Baskerville:ital,wght@0,400;0,700;1,400&family=Literata:ital,opsz,wght@0,7..72,400;0,7..72,600;0,7..72,700;1,7..72,400&family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,600;1,6..72,400&family=Playfair+Display:wght@400;600;700;900&family=Source+Serif+4:ital,opsz,wght@0,8..60,400;0,8..60,600;0,8..60,700;1,8..60,400&family=Space+Grotesk:wght@400;500;600;700&family=Space+Mono:wght@400;700&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-wRyjoTwK.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-ZQ1BICWp.css">
+    <script type="module" crossorigin src="/assets/index-DCMxNd__.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Cc-WcvZz.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/plugins/authors-voice/dist/index.js CHANGED Viewed

@@ -189,16 +189,18 @@ const plugin = {
             { label: 'Fill sentence', action: 'av:fill-sentence', condition: 'empty-node' },
         ];
     },
-    sidebarMenuItems() {
-        return [
-            { label: 'Vary', action: 'voice:vary', promptForFocus: true },
-            { label: 'Shrinkify', action: 'voice:shrinkify', promptForFocus: true },
-            { label: 'Expandify', action: 'voice:expandify', promptForFocus: true },
-            { label: 'Threadify', action: 'voice:threadify', promptForFocus: true },
-            { label: 'Storify', action: 'voice:storify', promptForFocus: true },
-            { label: 'Emailify', action: 'voice:emailify', promptForFocus: true },
-            { label: 'Postify', action: 'voice:postify', promptForFocus: true },
-        ];
-    },
+    // Sidebar transforms disabled — now handled by publish plugin.
+    // Kept commented for reference during transition.
+    // sidebarMenuItems() {
+    //   return [
+    //     { label: 'Vary', action: 'voice:vary', promptForFocus: true },
+    //     { label: 'Shrinkify', action: 'voice:shrinkify', promptForFocus: true },
+    //     { label: 'Expandify', action: 'voice:expandify', promptForFocus: true },
+    //     { label: 'Threadify', action: 'voice:threadify', promptForFocus: true },
+    //     { label: 'Storify', action: 'voice:storify', promptForFocus: true },
+    //     { label: 'Emailify', action: 'voice:emailify', promptForFocus: true },
+    //     { label: 'Postify', action: 'voice:postify', promptForFocus: true },
+    //   ];
+    // },
 };
 export default plugin;

package/dist/plugins/publish/dist/helpers.d.ts CHANGED Viewed

@@ -22,13 +22,25 @@ export interface PluginMcpTool {
     inputSchema: Record<string, unknown>;
     handler: (params: Record<string, unknown>) => Promise<unknown>;
 }
+export interface PluginRouteContext {
+    app: import('express').Router;
+    config: Record<string, string>;
+    dataDir: string;
+}
+export interface PluginSidebarMenuItem {
+    label: string;
+    action: string;
+    promptForFocus?: boolean;
+}
 export interface OpenWriterPlugin {
     name: string;
     version: string;
     description?: string;
     category?: 'writing' | 'social-media' | 'image-generation' | 'publishing' | 'productivity' | 'analytics';
     configSchema?: Record<string, PluginConfigField>;
+    registerRoutes?(ctx: PluginRouteContext): void | Promise<void>;
     mcpTools?(config: Record<string, string>): PluginMcpTool[];
+    sidebarMenuItems?(): PluginSidebarMenuItem[];
 }
 export declare const md: MarkdownIt;
 /** Strip YAML frontmatter and TipTap empty markers from markdown output */

package/dist/plugins/publish/dist/index.js CHANGED Viewed

@@ -2,6 +2,41 @@ import { getServerModules, publishFetch } from './helpers.js';
 import { newsletterTools } from './newsletter-tools.js';
 import { readFileSync, existsSync } from 'fs';
 import { join, extname } from 'path';
+/** Extract docId from raw markdown frontmatter (JSON or YAML) */
+function extractDocId(rawContent) {
+    // JSON frontmatter: "docId":"abc123"
+    const jsonMatch = rawContent.match(/"docId"\s*:\s*"([^"]+)"/);
+    if (jsonMatch)
+        return jsonMatch[1];
+    // YAML frontmatter: docId: abc123
+    const yamlMatch = rawContent.match(/^docId:\s*["']?(\S+?)["']?\s*$/m);
+    if (yamlMatch)
+        return yamlMatch[1];
+    return null;
+}
+/** Map transform action to variant content type */
+const ACTION_VARIANT_TYPE = {
+    vary: 'document',
+    shrinkify: 'document',
+    expandify: 'document',
+    threadify: 'tweet',
+    storify: 'document',
+    emailify: 'newsletter',
+    postify: 'tweet',
+};
+/** Simple HTML → markdown conversion for document creation */
+function htmlToMarkdown(html) {
+    let md = html;
+    md = md.replace(/<hr\s*\/?>/gi, '\n---\n');
+    md = md.replace(/<br\s*\/?>/gi, '\n');
+    md = md.replace(/<(strong|b)>([\s\S]*?)<\/\1>/gi, '**$2**');
+    md = md.replace(/<(em|i)>([\s\S]*?)<\/\1>/gi, '*$2*');
+    md = md.replace(/<p[^>]*>/gi, '');
+    md = md.replace(/<\/p>/gi, '\n\n');
+    md = md.replace(/<[^>]+>/g, '');
+    md = md.replace(/\n{3,}/g, '\n\n');
+    return md.trim();
+}
 const plugin = {
     name: '@openwriter/plugin-publish',
     version: '0.1.0',
@@ -988,5 +1023,108 @@ const plugin = {
             },
         ];
     },
+    registerRoutes(ctx) {
+        // Sidebar action handler for document transforms
+        ctx.app.post('/api/publish/sidebar-action', async (req, res) => {
+            try {
+                const { action, filename, title, instructions, content } = req.body;
+                console.log(`[Publish Plugin] Sidebar action: ${action} on "${title}"`);
+                if (!content) {
+                    res.status(400).json({ error: 'Document content is required' });
+                    return;
+                }
+                // Call publish worker /transforms endpoint
+                const transformRes = await publishFetch(ctx.config, '/transforms', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ action, content, title, instructions }),
+                });
+                if (!transformRes.ok) {
+                    const errData = await transformRes.json().catch(() => ({}));
+                    console.error('[Publish Plugin] Transform failed:', transformRes.status, errData);
+                    res.status(transformRes.status).json(errData);
+                    return;
+                }
+                const transformResult = await transformRes.json();
+                // Convert HTML output to markdown for document creation
+                let markdownContent = htmlToMarkdown(transformResult.html);
+                // Extract source doc's docId for variant relationship
+                const masterDocId = extractDocId(content);
+                const variantType = ACTION_VARIANT_TYPE[action] || 'document';
+                // Build document creation payload
+                const createBody = {
+                    title: transformResult.newTitle,
+                    content: markdownContent,
+                    markPending: true,
+                    agentCreated: true,
+                    ...(masterDocId ? { masterDocId, variantType } : {}),
+                };
+                if (action === 'threadify') {
+                    // Build TipTap JSON directly — markdown parser converts "- item" lines
+                    // to bulletList nodes the tweet editor can't render. Using paragraph +
+                    // hardBreak nodes keeps all tweet text as plain text.
+                    if (transformResult.thread?.tweets?.length) {
+                        const docContent = [];
+                        transformResult.thread.tweets.forEach((t, i) => {
+                            const lines = t.text.split('\n');
+                            const nodes = [];
+                            lines.forEach((line, j) => {
+                                if (j > 0)
+                                    nodes.push({ type: 'hardBreak' });
+                                if (line)
+                                    nodes.push({ type: 'text', text: line });
+                            });
+                            if (nodes.length) {
+                                docContent.push({ type: 'paragraph', content: nodes });
+                            }
+                            if (i < transformResult.thread.tweets.length - 1) {
+                                docContent.push({ type: 'horizontalRule' });
+                            }
+                        });
+                        createBody.content = { type: 'doc', content: docContent };
+                    }
+                    createBody.metadata = { tweetContext: { mode: 'tweet' } };
+                }
+                // Create new document via internal HTTP call
+                const host = req.get('host') || 'localhost:5050';
+                const protocol = req.protocol || 'http';
+                const createUrl = `${protocol}://${host}/api/documents`;
+                const createRes = await fetch(createUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(createBody),
+                });
+                if (!createRes.ok) {
+                    const errData = await createRes.json().catch(() => ({}));
+                    console.error('[Publish Plugin] Document creation failed:', errData);
+                    res.status(500).json({ error: 'Failed to create result document' });
+                    return;
+                }
+                const docResult = await createRes.json();
+                res.json({
+                    success: true,
+                    action,
+                    filename: docResult.filename,
+                    title: transformResult.newTitle,
+                    metadata: transformResult.metadata,
+                });
+            }
+            catch (err) {
+                console.error('[Publish Plugin] Sidebar action error:', err?.message || err);
+                res.status(500).json({ error: 'Sidebar action failed' });
+            }
+        });
+    },
+    sidebarMenuItems() {
+        return [
+            { label: 'Vary', action: 'publish:vary', promptForFocus: true },
+            { label: 'Shrinkify', action: 'publish:shrinkify', promptForFocus: true },
+            { label: 'Expandify', action: 'publish:expandify', promptForFocus: true },
+            { label: 'Threadify', action: 'publish:threadify', promptForFocus: true },
+            { label: 'Storify', action: 'publish:storify', promptForFocus: true },
+            { label: 'Emailify', action: 'publish:emailify', promptForFocus: true },
+            { label: 'Postify', action: 'publish:postify', promptForFocus: true },
+        ];
+    },
 };
 export default plugin;

package/dist/server/documents.js CHANGED Viewed

@@ -120,6 +120,8 @@ export function listDocuments() {
                 ...(data.tweetContext?.lastPost?.tweetUrl ? { postedUrl: data.tweetContext.lastPost.tweetUrl } : {}),
                 ...(data.newsletterContext ? { isNewsletter: true } : {}),
                 ...(deriveContentType(data) ? { contentType: deriveContentType(data) } : {}),
+                ...(data.masterDocId ? { masterDocId: data.masterDocId } : {}),
+                ...(data.variantType ? { variantType: data.variantType } : {}),
             };
         }
         catch {
@@ -158,6 +160,8 @@ export function listDocuments() {
                 ...(data.tweetContext?.lastPost?.tweetUrl ? { postedUrl: data.tweetContext.lastPost.tweetUrl } : {}),
                 ...(data.newsletterContext ? { isNewsletter: true } : {}),
                 ...(deriveContentType(data) ? { contentType: deriveContentType(data) } : {}),
+                ...(data.masterDocId ? { masterDocId: data.masterDocId } : {}),
+                ...(data.variantType ? { variantType: data.variantType } : {}),
             });
         }
         catch { /* skip unreadable external files */ }
@@ -217,6 +221,8 @@ export function listArchivedDocuments() {
                 wordCount,
                 isActive: false,
                 ...(data.docId ? { docId: data.docId } : {}),
+                ...(data.masterDocId ? { masterDocId: data.masterDocId } : {}),
+                ...(data.variantType ? { variantType: data.variantType } : {}),
                 archivedAt: data.archivedAt,
             };
         }

package/dist/server/index.js CHANGED Viewed

@@ -230,6 +230,16 @@ export async function startHttpServer(options = {}) {
                 setMetadata(req.body.metadata);
                 save();
             }
+            // Variant relationship — set masterDocId and variantType in frontmatter
+            if (req.body.masterDocId || req.body.variantType) {
+                const variantMeta = {};
+                if (req.body.masterDocId)
+                    variantMeta.masterDocId = req.body.masterDocId;
+                if (req.body.variantType)
+                    variantMeta.variantType = req.body.variantType;
+                setMetadata(variantMeta);
+                save();
+            }
             // Plugin flags: mark all content as pending + tag as agent-created
             if (req.body.markPending) {
                 markAllNodesAsPending(getDocument(), 'insert');
@@ -708,13 +718,20 @@ export async function startHttpServer(options = {}) {
                 }
             }
             catch { /* content stays empty */ }
-            // Show sidebar spinner while plugin processes
+            // Extract source doc's docId for variant spinner positioning
+            let sourceDocId;
+            const docIdMatch = docContent.match(/"docId"\s*:\s*"([^"]+)"/);
+            if (docIdMatch)
+                sourceDocId = docIdMatch[1];
+            // Show sidebar spinner while plugin processes. Unique key so concurrent
+            // writes (e.g. declare_writes in flight) aren't cleared alongside this one.
             const spinnerTitle = label ? `${label}: ${title}` : title;
-            broadcastWritingStarted(spinnerTitle);
+            const spinnerKey = `sidebar-action:${action}:${filename}:${Date.now()}`;
+            broadcastWritingStarted(spinnerTitle, sourceDocId ? { wsFilename: '', containerId: null, parentDocId: sourceDocId } : undefined, spinnerKey);
             // Intercept res.json to clear spinner when plugin handler responds
             const origJson = res.json.bind(res);
             res.json = (body) => {
-                broadcastWritingFinished();
+                broadcastWritingFinished(spinnerKey);
                 return origJson(body);
             };
             // Forward to plugin route: POST /api/{prefix}/sidebar-action
@@ -722,12 +739,13 @@ export async function startHttpServer(options = {}) {
             req.url = `/api/${prefix}/sidebar-action`;
             req.body = { action: actionName, filename, title, instructions, content: docContent };
             app.handle(req, res, () => {
-                broadcastWritingFinished();
+                broadcastWritingFinished(spinnerKey);
                 res.status(404).json({ error: `No handler registered for action "${action}"` });
             });
         }
         catch (err) {
-            broadcastWritingFinished();
+            // spinnerKey is out of scope here (try body may have thrown before it
+            // was declared). The 60s timeout on the server entry cleans it up.
             res.status(500).json({ error: err.message });
         }
     });

package/dist/server/mcp.js CHANGED Viewed

@@ -306,11 +306,9 @@ export const TOOL_REGISTRY = [
                 wsTarget = { wsFilename: ws.filename, containerId };
                 broadcastWorkspacesChanged(); // Browser sees container structure before spinner
             }
-            if (!empty) {
-                broadcastWritingStarted(title || 'Untitled', wsTarget);
-                // Yield so the browser receives and renders the spinner before heavy work
-                await new Promise((resolve) => setTimeout(resolve, 200));
-            }
+            // Track the spinner key so catch can clear exactly this entry
+            // (not siblings from a concurrent declare_writes).
+            let spinnerKey = null;
             try {
                 if (empty) {
                     // Immediate switch — no spinner, no populate_document needed
@@ -349,6 +347,11 @@ export const TOOL_REGISTRY = [
                     addDoc(wsTarget.wsFilename, wsTarget.containerId, result.filename, result.title);
                     wsInfo = ` → workspace "${workspace}"${container ? ` / ${container}` : ''}`;
                 }
+                // Broadcast spinner keyed by filename so populate_document can clear exactly
+                // this entry. Fires after the file exists, so documents-changed arrives with
+                // the real entry that the sidebar filters behind the spinner until populate.
+                spinnerKey = result.filename;
+                broadcastWritingStarted(title || 'Untitled', wsTarget, spinnerKey);
                 broadcastDocumentsChanged();
                 return {
                     content: [{
@@ -358,8 +361,8 @@ export const TOOL_REGISTRY = [
                 };
             }
             catch (err) {
-                if (!empty)
-                    broadcastWritingFinished();
+                if (spinnerKey)
+                    broadcastWritingFinished(spinnerKey);
                 throw err;
             }
         },
@@ -387,7 +390,7 @@ export const TOOL_REGISTRY = [
                     doc = content;
                 }
                 else {
-                    broadcastWritingFinished();
+                    broadcastWritingFinished(filename);
                     return {
                         content: [{ type: 'text', text: 'Error: content must be a markdown string or TipTap JSON { type: "doc", content: [...] }' }],
                     };
@@ -399,7 +402,7 @@ export const TOOL_REGISTRY = [
                     broadcastDocumentsChanged();
                     broadcastWorkspacesChanged();
                     broadcastPendingDocsChanged();
-                    broadcastWritingFinished();
+                    broadcastWritingFinished(filename);
                     return {
                         content: [{
                                 type: 'text',
@@ -419,7 +422,7 @@ export const TOOL_REGISTRY = [
                 broadcastWorkspacesChanged();
                 broadcastDocumentSwitched(doc, getTitle(), getActiveFilename());
                 broadcastPendingDocsChanged();
-                broadcastWritingFinished();
+                broadcastWritingFinished(filename || getActiveFilename());
                 const wordCount = getWordCount();
                 return {
                     content: [{
@@ -429,11 +432,78 @@ export const TOOL_REGISTRY = [
                 };
             }
             catch (err) {
-                broadcastWritingFinished();
+                broadcastWritingFinished(filename);
                 throw err;
             }
         },
     },
+    {
+        name: 'declare_writes',
+        description: 'Declare a batch of documents to create at once. Use this when creating multiple documents in parallel (e.g. a series of blog drafts, a tweet thread saved as separate docs, newsletter variants). Each write gets its own sidebar spinner keyed to its filename — spinners persist across app refreshes and only clear when you call populate_document for that specific doc. Returns an array of { docId, filename, title }. Next step: call populate_document once per docId (in parallel is fine). For creating a single document, prefer create_document.',
+        schema: {
+            writes: z.array(z.object({
+                title: z.string().describe('Title for the document.'),
+                content_type: z.enum(['document', 'tweet', 'reply', 'quote', 'article', 'linkedin', 'newsletter', 'blog']).describe('Content type. Use "document" for plain docs.'),
+                workspace: z.string().optional().describe('Workspace title to add this doc to. Creates the workspace if it does not exist.'),
+                container: z.string().optional().describe('Container name within the workspace (e.g. "Chapters"). Requires workspace.'),
+                url: z.string().optional().describe('Tweet URL — REQUIRED for content_type "reply" or "quote".'),
+                path: z.string().optional().describe('Absolute file path to create the document at. If omitted, creates in ~/.openwriter/.'),
+            })).min(1).describe('List of documents to declare (minimum 1).'),
+        },
+        handler: async ({ writes }) => {
+            const results = [];
+            let workspacesChanged = false;
+            const broadcastedKeys = [];
+            for (const w of writes) {
+                try {
+                    if ((w.content_type === 'reply' || w.content_type === 'quote') && !w.url) {
+                        results.push({ docId: '', filename: '', title: w.title, error: `content_type "${w.content_type}" requires a url parameter` });
+                        continue;
+                    }
+                    let wsTarget;
+                    if (w.workspace) {
+                        const ws = findOrCreateWorkspace(w.workspace);
+                        let containerId = null;
+                        if (w.container) {
+                            const c = findOrCreateContainer(ws.filename, w.container);
+                            containerId = c.containerId;
+                        }
+                        wsTarget = { wsFilename: ws.filename, containerId };
+                        workspacesChanged = true;
+                    }
+                    const typeMeta = resolveTypeMeta(w.content_type, w.url);
+                    const result = createDocumentFile(w.title, w.path, typeMeta);
+                    if (wsTarget) {
+                        addDoc(wsTarget.wsFilename, wsTarget.containerId, result.filename, result.title);
+                    }
+                    broadcastWritingStarted(w.title, wsTarget, result.filename);
+                    broadcastedKeys.push(result.filename);
+                    results.push({ docId: result.docId, filename: result.filename, title: result.title });
+                }
+                catch (err) {
+                    results.push({ docId: '', filename: '', title: w.title, error: err.message });
+                }
+            }
+            broadcastDocumentsChanged();
+            if (workspacesChanged)
+                broadcastWorkspacesChanged();
+            const successes = results.filter((r) => !r.error);
+            const failures = results.filter((r) => r.error);
+            const lines = [
+                `Declared ${successes.length} write${successes.length === 1 ? '' : 's'}${failures.length ? ` (${failures.length} failed)` : ''}:`,
+                ...successes.map((r) => `  "${r.title}" [${r.docId}] → ${r.filename}`),
+            ];
+            if (failures.length) {
+                lines.push('', 'Errors:');
+                for (const r of failures)
+                    lines.push(`  "${r.title}" — ${r.error}`);
+            }
+            if (successes.length) {
+                lines.push('', 'Next: call populate_document once per docId to fill in content.');
+            }
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        },
+    },
     {
         name: 'open_file',
         description: 'Open an existing .md file from any location on disk. Saves the current document first, then loads the file and sets it as active. The file appears in the sidebar and edits save back to the original path.',

package/dist/server/ws.js CHANGED Viewed

@@ -116,6 +116,11 @@ export function setupWebSocket(server) {
             type: 'pending-docs-changed',
             pendingDocs: getPendingDocInfo(),
         }));
+        // Rehydrate in-flight writing spinners across app refreshes
+        const pendingWritesSnapshot = getPendingWritesSnapshot();
+        if (pendingWritesSnapshot.length > 0) {
+            ws.send(JSON.stringify({ type: 'pending-writes-sync', writes: pendingWritesSnapshot }));
+        }
         ws.on('message', async (data) => {
             try {
                 const msg = JSON.parse(data.toString());
@@ -377,32 +382,80 @@ export function broadcastAgentStatus(connected) {
     }
 }
 let lastSyncStatus = null;
-// Safety net: auto-clear spinner if writing-finished never arrives
-let writingTimer = null;
+const pendingWrites = new Map();
 const WRITING_TIMEOUT_MS = 60_000;
-export function broadcastWritingStarted(title, target) {
-    if (writingTimer)
-        clearTimeout(writingTimer);
-    writingTimer = setTimeout(() => {
-        console.log('[WS] Writing spinner timed out — auto-clearing');
-        broadcastWritingFinished();
+export function broadcastWritingStarted(title, target, key) {
+    const writeKey = key || target?.wsFilename || `write:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
+    const existing = pendingWrites.get(writeKey);
+    if (existing)
+        clearTimeout(existing.timer);
+    const timer = setTimeout(() => {
+        console.log(`[WS] Writing spinner timed out for ${writeKey} — auto-clearing`);
+        broadcastWritingFinished(writeKey);
     }, WRITING_TIMEOUT_MS);
-    const msg = JSON.stringify({ type: 'writing-started', title, target: target || null });
+    pendingWrites.set(writeKey, {
+        key: writeKey,
+        title,
+        target: target || null,
+        startedAt: Date.now(),
+        timer,
+    });
+    const msg = JSON.stringify({ type: 'writing-started', title, target: target || null, key: writeKey });
     for (const ws of clients) {
         if (ws.readyState === WebSocket.OPEN)
             ws.send(msg);
     }
+    return writeKey;
 }
-export function broadcastWritingFinished() {
-    if (writingTimer) {
-        clearTimeout(writingTimer);
-        writingTimer = null;
+// key omitted → clear all (legacy single-write flows). Pass a key for multi-doc.
+export function broadcastWritingFinished(key) {
+    if (key) {
+        const entry = pendingWrites.get(key);
+        if (entry) {
+            clearTimeout(entry.timer);
+            pendingWrites.delete(key);
+        }
+    }
+    else {
+        for (const entry of pendingWrites.values())
+            clearTimeout(entry.timer);
+        pendingWrites.clear();
     }
-    const msg = JSON.stringify({ type: 'writing-finished' });
+    // Always send writing-finished with the key so the client can drop it from
+    // its pending set. Then, if siblings remain, re-surface the latest with a
+    // writing-started so the spinner doesn't vanish mid-batch.
+    const finishedMsg = JSON.stringify({ type: 'writing-finished', key: key || null });
     for (const ws of clients) {
         if (ws.readyState === WebSocket.OPEN)
-            ws.send(msg);
+            ws.send(finishedMsg);
     }
+    if (key && pendingWrites.size > 0) {
+        let next = null;
+        for (const e of pendingWrites.values()) {
+            if (!next || e.startedAt > next.startedAt)
+                next = e;
+        }
+        if (next) {
+            const startedMsg = JSON.stringify({
+                type: 'writing-started',
+                title: next.title,
+                target: next.target,
+                key: next.key,
+            });
+            for (const ws of clients) {
+                if (ws.readyState === WebSocket.OPEN)
+                    ws.send(startedMsg);
+            }
+        }
+    }
+}
+export function getPendingWritesSnapshot() {
+    return Array.from(pendingWrites.values()).map(({ key, title, target, startedAt }) => ({
+        key,
+        title,
+        target,
+        startedAt,
+    }));
 }
 export function broadcastMarksChanged(filename) {
     const msg = JSON.stringify({ type: 'marks-changed', filename });

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "openwriter",
-  "version": "0.9.3",
+  "version": "0.11.0",
   "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 CHANGED Viewed

@@ -16,7 +16,7 @@ description: |
   Requires: OpenWriter MCP server configured. Browser UI at localhost:5050.
 metadata:
   author: travsteward
-  version: "0.4.5"
+  version: "0.5.0"
   repository: https://github.com/travsteward/openwriter
 license: MIT
 ---
@@ -244,6 +244,38 @@ create_document({
 This eliminates the need for separate `create_workspace`, `create_container`, and `move_item` calls when building up a workspace.
+### Batched Creation (multiple docs at once)
+When creating **two or more documents together** — a tweet thread saved as separate docs, a series of blog drafts, newsletter variants, a workspace populated with several files — use `declare_writes` instead of looping `create_document`. It's one tool call, registers all sidebar spinners atomically, and survives app refreshes.
+```
+1. declare_writes({
+     writes: [
+       { title: "Post 1", content_type: "tweet" },
+       { title: "Post 2", content_type: "tweet" },
+       { title: "Post 3", content_type: "tweet" },
+     ]
+   })
+   → returns [{ docId, filename, title }, ...]
+2. populate_document({ docId: "...", content: "..." })  ← one call per doc, parallel is fine
+```
+**Rules:**
+- Each write in the batch gets its own sidebar spinner keyed to its filename — a spinner only clears when you `populate_document` that specific `docId`
+- Spinners persist across app refreshes (server-side registry)
+- Same per-write fields as `create_document`: `title`, `content_type`, optional `workspace`/`container`/`url`/`path`
+- `reply` / `quote` types still require `url`
+- For a **single** document, use `create_document` — don't reach for `declare_writes` just to wrap one entry
+## Voice Frames
+Pre-built voice postures for when the user wants a specific style but has no custom voice profile. Five frames cover the common needs: authority, provocateur, logical, storyteller, business.
+**Triggers** — any of the following should make you load frames: "write authoritatively", "authority voice", "contrarian take", "provocateur", "first principles", "logical/analytical essay", "tell the story", "storyteller", "business email", "high-status brevity", or an explicit frame name.
+**Protocol** — load `docs/voices.md` for the full selection guide and 4-step protocol. Then read the specific `voices/<frame>.md` for the rules. Apply all 6 category rules as hard constraints while drafting in the editor, and run the `docs/anti-ai.md` Tier 1 pass before leaving the output.
 ## Workflow
 ### Single document