openwriter 0.12.1 → 0.14.0

package/dist/server/state.js

@@ -6,10 +6,43 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, statSync, utimesSync } from 'fs';
 import { join } from 'path';
 import matter from 'gray-matter';
-import { tiptapToMarkdown, tiptapToBody, markdownToTiptap } from './markdown.js';
+import { tiptapToMarkdown, tiptapToMarkdownChecked, tiptapToBody, markdownToTiptap } from './markdown.js';
 import { applyTextEditsToNode } from './text-edit.js';
 import { getDataDir, TEMP_PREFIX, ensureDataDir, filePathForTitle, tempFilePath, generateNodeId, LEAF_BLOCK_TYPES, resolveDocPath, isExternalDoc, atomicWriteFileSync } from './helpers.js';
 import { snapshotIfNeeded, ensureDocId } from './versions.js';
+import { extractForwardLinks, extractForwardLinksFromDisk, updateBacklinksForSource } from './backlinks.js';
+import { isAutoAcceptInheritedForDoc } from './workspaces.js';
+import { matchNodes } from './node-matcher.js';
+import { tiptapToBlocks, applyIdsToTiptap } from './node-blocks.js';
+/** Read the persisted identity graph (nodes + graveyard) from a file's
+ *  frontmatter. This is the matcher's previousNodes baseline at save time —
+ *  the disk is the source of truth, not a parallel in-memory cache. Returns
+ *  empty arrays for a brand-new file or unreadable frontmatter. */
+function readPersistedIdentity(filePath) {
+    if (!filePath || !existsSync(filePath))
+        return { previousNodes: [], graveyard: [] };
+    try {
+        const raw = readFileSync(filePath, 'utf-8');
+        const { data } = matter(raw);
+        return {
+            previousNodes: normalizeNodeEntries(data.nodes),
+            graveyard: normalizeNodeEntries(data.graveyard),
+        };
+    }
+    catch {
+        return { previousNodes: [], graveyard: [] };
+    }
+}
+/** Defensive parse of frontmatter node entries — drops any malformed rows.
+ *  Mirrors the same-named helper in markdown-parse.ts so save and load apply
+ *  identical validation. */
+function normalizeNodeEntries(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .filter((entry) => entry && typeof entry === 'object' && entry.id && entry.fp)
+        .map((entry) => ({ id: String(entry.id), fingerprint: entry.fp }));
+}
 const DEFAULT_DOC = {
     type: 'doc',
     content: [{ type: 'paragraph', content: [] }],
@@ -576,43 +609,109 @@ function applyChangesToDoc(doc, changes, autoAccept = false) {
             const found = findNode(doc.content, change.nodeId, doc.content);
             if (!found)
                 continue;
-            const contentArray = Array.isArray(change.content) ? change.content : [change.content];
+            let contentArray = Array.isArray(change.content) ? change.content : [change.content];
             const originalNode = structuredClone(found.parent[found.index]);
+            // Preserve target node type when plain text would otherwise demote it.
+            // Markdown-it parses plain text as a paragraph, so rewriting a heading or
+            // list item with plain prose silently changes the type. Two adaptations:
+            //   - Block wrappers (listItem, blockquote) wrap the parsed paragraph as
+            //     their child, keeping the wrapper's type and attrs.
+            //   - Inline-content leaves (heading, codeBlock) take the paragraph's
+            //     inline text and host it inside the original type, preserving level
+            //     and other attrs.
+            // Explicit markdown (e.g. "## Foo", "- bar") still wins because the
+            // parser produces a matching node type before we get here.
+            const targetType = originalNode.type;
+            const parsedType = contentArray[0]?.type;
+            const BLOCK_WRAPPERS = new Set(['listItem', 'blockquote']);
+            const INLINE_LEAVES = new Set(['heading', 'codeBlock']);
+            let isWrappedRewrite = false;
+            if (parsedType === 'paragraph' && targetType !== 'paragraph') {
+                if (BLOCK_WRAPPERS.has(targetType)) {
+                    contentArray = [{
+                            type: targetType,
+                            attrs: { ...originalNode.attrs },
+                            content: contentArray,
+                        }];
+                    isWrappedRewrite = true;
+                }
+                else if (INLINE_LEAVES.has(targetType)) {
+                    // Standard stamping handles the leaf case — heading/codeBlock are
+                    // themselves the decoration target, so no special branch needed below.
+                    contentArray = [{
+                            type: targetType,
+                            attrs: { ...originalNode.attrs },
+                            content: contentArray[0].content || [],
+                        }];
+                }
+            }
             // 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;
             // Detect partial change: if only a sub-range of the node text changed,
-            // attach selection range attrs so the frontend decorates only that part
+            // attach selection range attrs so the frontend decorates only that part.
+            // For wrapped rewrites (listItem), compare paragraph content against the
+            // listItem's inner paragraph so offsets align with what the user sees.
             let partialRange = null;
             if (!isEmptyNode && contentArray.length === 1 && !autoAccept) {
-                // Use true original for partial range when a prior pending rewrite exists,
-                // so offsets align with pendingOriginalContent
-                const baseContent = existingOriginal?.content || originalNode.content || [];
-                partialRange = computePartialRange(baseContent, contentArray[0].content || []);
+                const baseContent = isWrappedRewrite
+                    ? (existingOriginal?.content?.[0]?.content || originalNode.content?.[0]?.content || [])
+                    : (existingOriginal?.content || originalNode.content || []);
+                const newContent = isWrappedRewrite
+                    ? (contentArray[0].content?.[0]?.content || [])
+                    : (contentArray[0].content || []);
+                partialRange = computePartialRange(baseContent, newContent);
+            }
+            // Build first node. For wrapped rewrites, pendingStatus and related attrs
+            // belong on the inner leaf (paragraph) so the decoration renderer — which
+            // keys off LEAF_BLOCK_TYPES — picks them up. The wrapper keeps the original
+            // node's id/attrs so subsequent calls can still target it.
+            let firstNode;
+            if (isWrappedRewrite && !autoAccept) {
+                const innerLeaf = contentArray[0].content?.[0] || { type: 'paragraph', content: [] };
+                const innerWithPending = {
+                    ...innerLeaf,
+                    attrs: {
+                        ...innerLeaf.attrs,
+                        id: innerLeaf.attrs?.id || generateNodeId(),
+                        pendingStatus: isEmptyNode ? 'insert' : 'rewrite',
+                        ...(isEmptyNode ? {} : { pendingOriginalContent: existingOriginal || originalNode }),
+                        ...(partialRange ? {
+                            pendingSelectionFrom: partialRange.selectionFrom,
+                            pendingSelectionTo: partialRange.selectionTo,
+                            pendingOriginalFrom: partialRange.originalFrom,
+                            pendingOriginalTo: partialRange.originalTo,
+                        } : {}),
+                    },
+                };
+                firstNode = {
+                    type: 'listItem',
+                    attrs: { ...contentArray[0].attrs, id: change.nodeId },
+                    content: [innerWithPending, ...contentArray[0].content.slice(1)],
+                };
+            }
+            else {
+                firstNode = {
+                    ...contentArray[0],
+                    attrs: autoAccept ? {
+                        ...contentArray[0].attrs,
+                        id: change.nodeId,
+                    } : {
+                        ...contentArray[0].attrs,
+                        id: change.nodeId,
+                        pendingStatus: isEmptyNode ? 'insert' : 'rewrite',
+                        ...(isEmptyNode ? {} : { pendingOriginalContent: existingOriginal || originalNode }),
+                        ...(partialRange ? {
+                            pendingSelectionFrom: partialRange.selectionFrom,
+                            pendingSelectionTo: partialRange.selectionTo,
+                            pendingOriginalFrom: partialRange.originalFrom,
+                            pendingOriginalTo: partialRange.originalTo,
+                        } : {}),
+                    },
+                };
             }
-            // First node replaces the target (rewrite or insert if empty).
-            // In autoAccept mode, omit all pendingStatus/pendingOriginalContent attrs
-            // so the change commits cleanly with no review surface.
-            const firstNode = {
-                ...contentArray[0],
-                attrs: autoAccept ? {
-                    ...contentArray[0].attrs,
-                    id: change.nodeId,
-                } : {
-                    ...contentArray[0].attrs,
-                    id: change.nodeId,
-                    pendingStatus: isEmptyNode ? 'insert' : 'rewrite',
-                    ...(isEmptyNode ? {} : { pendingOriginalContent: existingOriginal || originalNode }),
-                    ...(partialRange ? {
-                        pendingSelectionFrom: partialRange.selectionFrom,
-                        pendingSelectionTo: partialRange.selectionTo,
-                        pendingOriginalFrom: partialRange.originalFrom,
-                        pendingOriginalTo: partialRange.originalTo,
-                    } : {}),
-                },
-            };
             // Additional nodes get inserted after — as pending inserts in normal mode,
             // as plain blocks in autoAccept mode.
             const extraNodes = contentArray.slice(1).map((node) => ({
@@ -733,9 +832,22 @@ function applyChangesToDoc(doc, changes, autoAccept = false) {
     }
     return processed;
 }
+/**
+ * Effective auto-accept for a doc: true if the doc's own frontmatter has it,
+ * OR if any workspace/container ancestor in the workspace tree has it on.
+ */
+export function isAutoAcceptActive(filename, metadata) {
+    if (metadata?.autoAccept === true)
+        return true;
+    if (metadata?.autoAccept === false)
+        return false; // explicit doc-level override of inheritance
+    if (!filename)
+        return false;
+    return isAutoAcceptInheritedForDoc(filename);
+}
 /** Apply changes to the active document singleton. */
 function applyChangesToDocument(changes) {
-    const autoAccept = state.metadata?.autoAccept === true;
+    const autoAccept = isAutoAcceptActive(activeDocFilename(), state.metadata);
     const processed = applyChangesToDoc(state.document, changes, autoAccept);
     if (processed.length > 0) {
         state.lastModified = new Date();
@@ -755,7 +867,7 @@ export function applyTextEdits(nodeId, edits) {
     if (!result)
         return { success: false, error: 'No edits matched' };
     // Inline edit decoration only matters when there's a review surface — skip in autoAccept.
-    if (state.metadata?.autoAccept !== true) {
+    if (!isAutoAcceptActive(activeDocFilename(), state.metadata)) {
         result.node.attrs = {
             ...result.node.attrs,
             pendingTextEdits: result.textEdits,
@@ -769,7 +881,12 @@ export function applyTextEdits(nodeId, edits) {
         }]);
     return { success: true };
 }
-/** Set the active document state. Used by documents.ts for multi-doc operations. */
+/** Set the active document state. Used by documents.ts for multi-doc operations.
+ *
+ *  Identity tracking is NOT cached on PadState — the save-time matcher reads
+ *  previousNodes + graveyard directly from disk frontmatter every write
+ *  (Option B in adr/node-identity-matcher.md). Markdown is the source of
+ *  truth; memory is an ephemeral working copy. */
 export function setActiveDocument(doc, title, filePath, isTemp, lastModified, metadata, originalFrontmatter) {
     state.document = doc;
     state.title = title;
@@ -849,7 +966,11 @@ function populatePendingCache() {
     }
 }
 const docCache = new Map(); // key = filePath
-/** Cache the active document's full state, keyed by filePath. Call after save(). */
+/** Cache the active document's full state, keyed by filePath. Call after save().
+ *
+ *  Identity (nodes + graveyard) is NOT cached — the save-time matcher reads
+ *  it from disk frontmatter each write, so the cache stays a pure content
+ *  snapshot. */
 export function cacheActiveDocument() {
     if (!state.filePath)
         return;
@@ -1015,6 +1136,16 @@ export function getPendingDocInfo() {
 // ============================================================================
 function writeToDisk() {
     ensureDataDir();
+    // Capture old forward links BEFORE we overwrite the file — needed by the
+    // backlinks engine to know which target docs to refresh when source changes.
+    // Skip for external docs (they don't participate in the doc graph).
+    let oldForwardLinks = [];
+    if (!isExternalDoc(state.filePath) && state.docId) {
+        try {
+            oldForwardLinks = extractForwardLinksFromDisk(state.filePath, state.docId);
+        }
+        catch { /* best-effort */ }
+    }
     let markdown;
     if (isExternalDoc(state.filePath)) {
         // External files: preserve original frontmatter verbatim, no OpenWriter metadata injected
@@ -1024,7 +1155,36 @@ function writeToDisk() {
             : body;
     }
     else {
-        markdown = tiptapToMarkdown(state.document, state.title, state.metadata);
+        // Save-time matcher pass (Option B: disk is the source of truth).
+        //
+        // Read the existing file's frontmatter to recover previousNodes +
+        // graveyard, run the matcher against the current TipTap tree, and apply
+        // pinned IDs back onto the tree. Without this, type-change and
+        // graveyard-restore never fire within a session — the editor mints fresh
+        // IDs at insert time and the load-time matcher only sees the post-edit
+        // state. Memory holds no identity cache; identity always re-derives from
+        // disk at the save boundary.
+        //
+        // adr: adr/node-identity-matcher.md
+        const { previousNodes, graveyard } = readPersistedIdentity(state.filePath);
+        let nextGraveyard = graveyard;
+        if (previousNodes.length > 0) {
+            const newBlocks = tiptapToBlocks(state.document);
+            const matchResult = matchNodes(previousNodes, newBlocks, { graveyard });
+            const pinnedByPosition = new Map();
+            for (const p of matchResult.pinned)
+                pinnedByPosition.set(p.position, p.id);
+            applyIdsToTiptap(state.document, pinnedByPosition);
+            nextGraveyard = matchResult.nextGraveyard;
+        }
+        // Pass graveyard through metadata so the serializer can emit it in frontmatter.
+        const metaWithGraveyard = nextGraveyard.length > 0
+            ? { ...state.metadata, graveyard: nextGraveyard.map((g) => ({ id: g.id, fp: g.fingerprint })) }
+            : state.metadata;
+        // Checked serializer — verifies the TipTap → markdown → TipTap round-trip
+        // preserves block shape. Logs to console on drift; never blocks the save.
+        const result = tiptapToMarkdownChecked(state.document, state.title, metaWithGraveyard);
+        markdown = result.markdown;
     }
     if (existsSync(state.filePath)) {
         // Skip write if content is identical (prevents phantom git changes on doc switch)
@@ -1054,6 +1214,17 @@ function writeToDisk() {
         snapshotIfNeeded(state.docId, state.filePath);
     }
     catch { /* ignore */ }
+    // Backlinks update: refresh target docs' backlinks frontmatter if source's
+    // forward links changed. Best-effort — never blocks the save it follows.
+    if (!isExternalDoc(state.filePath) && state.docId) {
+        try {
+            const newForwardLinks = extractForwardLinks(state.document, state.docId);
+            updateBacklinksForSource(state.docId, newForwardLinks, oldForwardLinks);
+        }
+        catch (err) {
+            console.error('[State] backlinks update failed:', err);
+        }
+    }
 }
 export function save() {
     if (!state.filePath) {
@@ -1407,12 +1578,8 @@ export function setAutoAcceptOnFile(filename, enabled) {
     try {
         const raw = readFileSync(targetPath, 'utf-8');
         const parsed = markdownToTiptap(raw);
-        if (enabled) {
-            parsed.metadata.autoAccept = true;
-        }
-        else {
-            delete parsed.metadata.autoAccept;
-        }
+        // Explicit false (not delete) so the user's "off" overrides any workspace inheritance.
+        parsed.metadata.autoAccept = enabled;
         let markdown;
         if (isExternalDoc(targetPath)) {
             const body = tiptapToBody(parsed.document);
@@ -1501,9 +1668,9 @@ export function populateDocumentFile(filename, doc) {
     const targetPath = resolveDocPath(filename);
     const raw = readFileSync(targetPath, 'utf-8');
     const parsed = markdownToTiptap(raw);
-    // Skip pending tagging when the target doc has autoAccept on —
+    // Skip pending tagging when the target doc effectively has autoAccept on —
     // content commits directly as accepted.
-    if (parsed.metadata?.autoAccept !== true) {
+    if (!isAutoAcceptActive(filename, parsed.metadata)) {
         markAllNodesAsPending(doc, 'insert');
     }
     flushDocToFile(filename, doc, parsed.title, parsed.metadata);
@@ -1541,7 +1708,7 @@ export function applyChangesToFile(filename, changes) {
         docId = metadata.docId || '';
         isTemp = false;
     }
-    const autoAccept = metadata?.autoAccept === true;
+    const autoAccept = isAutoAcceptActive(filename, metadata);
     const processed = applyChangesToDoc(doc, changes, autoAccept);
     if (processed.length > 0) {
         flushDocToFile(filename, doc, title, metadata);
@@ -1597,7 +1764,7 @@ export function applyTextEditsToFile(filename, nodeId, edits) {
     const result = applyTextEditsToNode(originalNode, edits);
     if (!result)
         return { success: false, error: 'No edits matched' };
-    const autoAccept = metadata?.autoAccept === true;
+    const autoAccept = isAutoAcceptActive(filename, metadata);
     // pendingTextEdits is the fine-grained inline-edit decoration — skip in autoAccept
     // since the change commits directly.
     if (!autoAccept) {

package/dist/server/workspace-routes.js

@@ -4,6 +4,17 @@
  */
 import { Router } from 'express';
 import { listWorkspaces, getWorkspace, createWorkspace, deleteWorkspace, reorderWorkspaces, addDoc, removeDoc, moveDoc, reorderDoc, addContainerToWorkspace, removeContainer, renameContainer, renameWorkspace, reorderContainer, crossMoveContainer, promoteContainerToWorkspace, } from './workspaces.js';
+import { findNode } from './workspace-tree.js';
+import { deleteDocument } from './documents.js';
+function collectDocFilesInSubtree(nodes, out = []) {
+    for (const n of nodes) {
+        if (n.type === 'doc')
+            out.push(n.file);
+        else if (n.type === 'container')
+            collectDocFilesInSubtree(n.items, out);
+    }
+    return out;
+}
 export function createWorkspaceRouter(b) {
     const router = Router();
     router.get('/api/workspaces', (_req, res) => {
@@ -130,11 +141,28 @@ export function createWorkspaceRouter(b) {
             res.status(400).json({ error: err.message });
         }
     });
-    router.delete('/api/workspaces/:filename/containers/:containerId', (req, res) => {
-        try {
+    router.delete('/api/workspaces/:filename/containers/:containerId', async (req, res) => {
+        try {
+            const cascade = req.query.cascade === 'true' || req.query.cascade === '1';
+            let deletedDocs = 0;
+            if (cascade) {
+                // Find the container, collect all docs in its subtree, delete them from disk.
+                const current = getWorkspace(req.params.filename);
+                const found = findNode(current.root, (n) => n.type === 'container' && n.id === req.params.containerId);
+                if (found && found.node.type === 'container') {
+                    const files = collectDocFilesInSubtree(found.node.items);
+                    for (const file of files) {
+                        try {
+                            await deleteDocument(file);
+                            deletedDocs++;
+                        }
+                        catch { /* swallow per-doc failures; keep going */ }
+                    }
+                }
+            }
             const ws = removeContainer(req.params.filename, req.params.containerId);
             b.broadcastWorkspacesChanged();
-            res.json(ws);
+            res.json({ ...ws, deletedDocs });
         }
         catch (err) {
             res.status(400).json({ error: err.message });

package/dist/server/workspaces.js

@@ -437,6 +437,91 @@ export function getWorkspaceAssignedFiles() {
     }
     return assigned;
 }
+/**
+ * Walk every workspace and return true if `file` is inside one where auto-accept
+ * is on at the workspace level or on any ancestor container. Returns false when
+ * the doc isn't in any workspace or no ancestor has the flag set.
+ *
+ * A doc's own `autoAccept` frontmatter is NOT checked here — that's the caller's
+ * job (combined with this lookup, OR-style).
+ */
+export function isAutoAcceptInheritedForDoc(file) {
+    const workspaces = listWorkspaces();
+    for (const info of workspaces) {
+        try {
+            const ws = readWorkspace(info.filename);
+            // Walk root to find the doc; collect ancestor containers along the way.
+            function walk(nodes, ancestors) {
+                for (const n of nodes) {
+                    if (n.type === 'doc' && n.file === file) {
+                        if (ws.autoAccept === true)
+                            return true;
+                        for (const c of ancestors)
+                            if (c.autoAccept === true)
+                                return true;
+                        return false; // doc lives here but no ancestor flag set
+                    }
+                    if (n.type === 'container') {
+                        const result = walk(n.items, [...ancestors, n]);
+                        if (result !== null)
+                            return result;
+                    }
+                }
+                return null;
+            }
+            const found = walk(ws.root, []);
+            if (found === true)
+                return true;
+            // if found === false, doc IS in this workspace but no ancestor flag is on;
+            // continue scanning other workspaces (a doc could be referenced in multiple)
+        }
+        catch { /* skip corrupt manifests */ }
+    }
+    return false;
+}
+/** Set or clear workspace-level autoAccept. */
+export function setWorkspaceAutoAccept(wsFile, enabled) {
+    const ws = readWorkspace(wsFile);
+    if (enabled)
+        ws.autoAccept = true;
+    else
+        delete ws.autoAccept;
+    writeWorkspace(wsFile, ws);
+}
+/** Set or clear container-level autoAccept. */
+export function setContainerAutoAccept(wsFile, containerId, enabled) {
+    const ws = readWorkspace(wsFile);
+    const found = findContainer(ws.root, containerId);
+    if (!found)
+        throw new Error(`Container ${containerId} not found in ${wsFile}`);
+    if (enabled)
+        found.node.autoAccept = true;
+    else
+        delete found.node.autoAccept;
+    writeWorkspace(wsFile, ws);
+}
+/** Collect every file inside a workspace or container subtree. Used for broadcast. */
+export function collectFilesInWorkspace(wsFile) {
+    try {
+        const ws = readWorkspace(wsFile);
+        return collectAllFiles(ws.root);
+    }
+    catch {
+        return [];
+    }
+}
+export function collectFilesInContainer(wsFile, containerId) {
+    try {
+        const ws = readWorkspace(wsFile);
+        const found = findContainer(ws.root, containerId);
+        if (!found)
+            return [];
+        return collectAllFiles(found.node.items);
+    }
+    catch {
+        return [];
+    }
+}
 export function getWorkspaceStructure(filename) {
     return getWorkspace(filename);
 }

package/package.json

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

@@ -16,7 +16,7 @@ description: |
   Requires: OpenWriter MCP server configured. Browser UI at localhost:5050.
 metadata:
   author: travsteward
-  version: "0.6.0"
+  version: "0.7.0"
   repository: https://github.com/travsteward/openwriter
 license: MIT
 ---
@@ -205,6 +205,7 @@ For making changes to existing documents — rewrites, insertions, deletions:
 - Always `read_pad` before editing to get fresh node IDs
 - Respect `pendingChanges > 0` — wait for the user to accept/reject before sending more
 - Content accepts markdown strings (preferred) or TipTap JSON
+- **`rewrite` preserves the target node's type.** Sending plain prose to rewrite a heading keeps it a heading; the same for list items and blockquotes. To intentionally change a node's type, use `delete` + `insert`. For surgical text-only edits inside a node (no risk of restructuring), `edit_text` is the smaller hammer.
 - Decoration colors: **blue** = rewrite, **green** = insert, **red** = delete
 - **Never re-populate a document to fix it.** `populate_document` re-sends the entire document body — extremely token-expensive. To remove nodes, use `write_to_pad` with `{ operation: "delete", nodeId: "..." }`. To fix content, use `rewrite`. Only use `populate_document` once during initial creation, or as a last resort if the document is severely broken.
 
@@ -278,13 +279,9 @@ When creating **two or more documents together** — a tweet thread saved as sep
 - `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
+## Companion Skills (optional)
 
-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.
+For voice-matched drafting without a custom Author's Voice profile, install the **voice-presets** skill — 5 frames (authority, provocateur, logical, storyteller, business). For an AI-detection pass on output, install **anti-ai**. Both are optional and ship separately from this skill.
 
 ## Workflow