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

openwriter 0.10.0 → 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 (19) 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/server/index.js +8 -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-CuPYxtxy.css +0 -1
package/dist/client/assets/index-deMuWDiP.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-deMuWDiP.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CuPYxtxy.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/server/index.js CHANGED Viewed

@@ -723,13 +723,15 @@ export async function startHttpServer(options = {}) {
             const docIdMatch = docContent.match(/"docId"\s*:\s*"([^"]+)"/);
             if (docIdMatch)
                 sourceDocId = docIdMatch[1];
-            // Show sidebar spinner while plugin processes
+            // 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, sourceDocId ? { wsFilename: '', containerId: null, parentDocId: sourceDocId } : undefined);
+            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
@@ -737,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.10.0",
+  "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

package/skill/docs/anti-ai.md ADDED Viewed

@@ -0,0 +1,71 @@
+# Anti-AI Detection Rules
+Two tiers. Tier 1 rules are **hard rules** — fix unconditionally, no voice profile override. These patterns are so statistically associated with AI that detectors flag them regardless of context. Tier 2 rules are **voice-gated** — check against the voice profile before fixing.
+---
+## Tier 1: Hard Rules (Always Fix)
+**Em-dashes — eliminate, then calibrate.** AI uses em-dashes at 5-10x human density. This is one of the strongest AI signals.
+- **Default (no profile or generic voice)**: Zero em-dashes. Convert to periods, commas, or parentheses.
+- **With voice profile**: Check the author's samples. If they use em-dashes, match their frequency — never exceed it. An author at 1 per 300 words gets 1 per 300 words. An author who never uses them gets zero.
+**Contrastive formula — never use.** These constructions are AI fingerprints:
+- "It's not X, it's Y" / "This isn't X, it's Y"
+- "Rather than X, we should Y"
+- "Instead of X, consider Y"
+- "Not merely X, but Y"
+Rewrite without the formula. State the point directly.
+**Nuclear phrases — kill on sight.** These phrases are 100-900x more frequent in AI text than human text. No human writes them at this density:
+- "valuable insights" (902x) · "indelible mark" (319x) · "rich tapestry" (227x)
+- "crucial role in shaping" (250x) · "adds a layer of complexity" (194x)
+- "a stark reminder" (151x) · "fostering a sense" (138x) · "nuanced understanding" (115x)
+- "unwavering commitment" (256x) · "multifaceted nature" (92x) · "beacon of hope" (58x)
+- "delve deeper" (72x) · "navigate the complex" (87x) · "transformative power" (74x)
+- "shed light on" · "serves as a testament" · "underscores the importance"
+**Copula avoidance — use simple verbs.** AI replaces "is" with "serves as", "has" with "boasts", "shows" with "underscores." This is a telltale pattern. Use the simple verb.
+**Sycophantic filler — cut unconditionally.** "Interestingly", "It's worth noting", "Notably", "It is important to note that", "It's crucial to understand" — these are AI padding. Delete them. They add nothing.
+**Contraction consistency — mix intentionally.** Uniform contraction use (100% contractions OR 100% expanded) is an AI signal. Real humans are inconsistent. Use "don't" in one sentence and "does not" three sentences later. The inconsistency IS the authenticity signal. Check the voice frame or profile for specific guidance.
+**Colon density — cap usage.** AI overuses colons. Cap at 1 per 400-500 words depending on the voice frame. Business Framed and Provocateur: no colons at all. Authority: 1 per post. Long-form frames: 1 per 400-500 words.
+**Register uniformity — break it.** AI maintains a single consistent register throughout. Real writing mixes formal vocabulary with casual asides, academic precision with colloquial reactions. Intentionally vary register within a piece. This is the "bidirectional sophistication" principle from empirical testing (GPTZero 100% → 3%).
+---
+## Tier 2: Voice-Gated Checks (Check Profile First)
+These patterns are suspicious but may match the author's voice. Check the profile before fixing.
+- **AI vocabulary**: "additionally", "furthermore", "landscape", "tapestry", "interplay", "pivotal", "delve", "paradigm", "leverage", "robust", "seamlessly" — check every word against the author's diction. If they don't use it, you can't either
+- **Inflated significance**: "marking a pivotal moment", "a significant milestone" — does the author elevate this way? If not, cut it
+- **Vague attribution**: "Experts argue", "Studies show" — does the author cite this way or make direct claims?
+- **Formula transitions**: "Despite these challenges", "Future Outlook", "In conclusion", "Moreover", "Furthermore" — does the author use these? Check discourse rules
+- **Rule of three**: Forcing ideas into triplets. Some authors do this naturally (check rhetoric rules). If not, break it
+- **Elegant variation**: Cycling synonyms — "the man...the individual...the person." Use whatever the author would repeat
+- **Sentence length uniformity**: AI defaults to medium-length sentences. Check your short/medium/long/very-long percentages against the author's distribution. Force variation to match
+- **Too-clean structure**: AI writes perfect essay structure. Real writing has asides, interruptions, unexpected turns. Match the author's discourse patterns
+- **Uniform paragraph length**: AI writes ~3-4 sentence paragraphs consistently. Match the author's paragraph rhythm from samples
+- **Mid-formal default**: AI gravitates toward neutral professional register. Match the author's register exactly, even if blunt, profane, or fragmentary
+- **Hedging where the author asserts**: "could potentially", "it might be argued" — if the rhetoric rules say direct claims, delete all hedging
+---
+## Final Check
+Re-read the complete output:
+1. Count em-dashes. No profile: should be zero. With profile: does the count match the author's observed frequency? Convert any excess
+2. Scan for any contrastive formula. Rewrite if found
+3. Grep for nuclear phrases. Kill any survivors
+4. Check contraction consistency. Are contractions mixed inconsistently (not 100% one way)?
+5. Count colons. Within the frame's limit?
+6. Check register variation. Is the tone monotonously consistent, or does it mix naturally?
+7. Scan for copula inflation ("serves as", "boasts", "underscores"). Simplify to plain verbs
+8. Would a reader who knows this author believe they wrote this?
+9. Does any sentence sound like "AI writing" rather than this specific person?
+If anything fails, rewrite that section. Don't patch — rewrite using the samples as reference.

package/skill/docs/voices.md ADDED Viewed

@@ -0,0 +1,88 @@
+# Voice Frames
+Pre-built voice postures the agent applies as behavioral constraints while
+writing in OpenWriter. Each frame is a distinct **communication posture** —
+not a register or tone — with its own strategy, diction, syntax, and discourse
+pattern. No API keys, no network calls, no retrieval. The agent reads a `.md`
+file from `voices/` and applies the rules.
+Use frames when:
+- The user asks for a specific posture ("authority voice", "contrarian take", "business email", "tell the story")
+- They want a voice-matched draft but don't have a custom profile
+- Quick tasks where configuring anything heavier isn't worth it
+## The Five Frames
+### Short-form (social media, threads, posts)
+**Authority** (`voices/authority.md`) — teaches from experience. Credibility via specificity. First-person experiential language, sentence distribution skewed short.
+**Provocateur** (`voices/provocateur.md`) — contrarian engagement. Opens with a claim that contradicts audience beliefs. Sharp verbs, hard lines.
+### Long-form (essays, blog posts, articles)
+**Logical** (`voices/logical.md`) — disassembles accepted assumptions, rebuilds from first principles. Names the conventional answer then dismantles it.
+**Storyteller** (`voices/storyteller.md`) — narrative-driven. Opens with a scene, not a thesis. Real names, real stakes. Lesson emerges from the story.
+### Business communication
+**Business** (`voices/business.md`) — high-status brevity. 12-word sentence ceiling. First sentence is the ask or decision. No filler.
+## Protocol
+### Step 1: Select the frame
+If the user names one, use it. If not, infer:
+- **Short-form** → `authority` (teaching) or `provocateur` (challenging)
+- **Long-form** → `logical` (analytical) or `storyteller` (narrative)
+- **Business comms** → `business`
+If ambiguous, ask.
+### Step 2: Load the voice file
+Read the selected `voices/<frame>.md`. Internalize all 6 categories (Diction,
+Syntax, Punctuation, Rhetoric, Discourse, Idiolect) as hard constraints.
+### Step 3: Write
+Apply every rule as a constraint. Match the sentence distribution targets.
+Use the file's pre-resolved Tier 2 decisions without guessing.
+### Step 4: Anti-AI pass
+Run `docs/anti-ai.md` Tier 1 (hard rules) against your output:
+- Em-dash density (zero for frames unless the file says otherwise)
+- Contrastive formula ("It's not X, it's Y")
+- Nuclear phrases ("valuable insights", "delve deeper", etc.)
+- Copula inflation ("serves as", "boasts", "underscores")
+- Sycophantic filler ("interestingly", "it's worth noting")
+- Contraction consistency, colon density, register variation
+Tier 2 checks are pre-resolved in each frame file — no profile needed.
+## Voice File Schema
+Every frame file follows the same format:
+```
+# Frame Name
+Posture + when to use.
+## Diction, Syntax, Punctuation, Rhetoric, Discourse, Idiolect
+2-5 imperative rules per category.
+## Sentence Distribution
+Short/medium/long/very-long percentages.
+## Tier 2 Decisions
+Pre-resolved answers for anti-AI checks (varies per frame).
+## Use-Case Constraints
+What this voice is for and what it isn't.
+```
+Rules are single imperative sentences. Two agents reading the same rule should
+produce similar output.

package/skill/voices/authority.md ADDED Viewed

@@ -0,0 +1,102 @@
+# Authority Frame
+Short-form voice for social media, threads, and posts. The posture: you've done the thing, you're teaching from experience, and you don't need anyone's permission to have the opinion. Credibility comes from specificity, not credentials.
+---
+## Diction
+- Use first-person experiential language: "I built", "I tested", "I shipped", "I watched it fail."
+- Replace theory words with evidence words: "works" not "could potentially work", "broke" not "presented challenges."
+- Use numbers and proper nouns instead of vague gestures: "47 users", "Stripe", "last Tuesday" — not "many people", "a platform", "recently."
+- Kill qualification words: no "somewhat", "relatively", "fairly", "quite", "arguably."
+- Use the plainest word available: "use" not "leverage", "run" not "execute", "talk" not "engage."
+## Syntax
+- Default sentence length: 5-12 words.
+- One claim per sentence. Period. Next sentence.
+- Use fragments when the fragment IS the point: "Every time." or "Not even close."
+- Save your one long sentence (20+ words) for the framework or the lesson — the part the reader screenshots.
+- Never stack clauses with commas. If you need a comma, you need two sentences.
+## Punctuation
+- Periods do the work. Not commas, not dashes, not semicolons.
+- Never use em-dashes.
+- Never use semicolons.
+- Use colons only to set up a list or a single payoff line.
+- Question marks: one per post maximum. Use to open a thread, never mid-argument.
+## Rhetoric
+- Open with the conclusion. The lesson goes first. Context is earned after the hook lands.
+- Teach by showing what happened, not by explaining what should happen.
+- Replace "you should" with "I did" — the reader extracts the lesson themselves.
+- One idea per post. If you wrote two ideas, delete one.
+- End on the strongest line, not a summary. The last sentence is what people remember.
+## Discourse
+- Line breaks between thoughts. No transition words.
+- Never use "However", "Furthermore", "Additionally", "Moreover."
+- If two ideas connect, juxtapose them. The reader sees the connection without you narrating it.
+- Threads: each post delivers one self-contained insight. No cliffhangers, no "and here's why (thread)."
+- Kill throat-clearing. No "Let me tell you something" or "Here's the thing" — just say the thing.
+## Idiolect
+- Write like someone who has nothing to prove and no time to waste.
+- Specificity is the authority signal: "I emailed 200 founders in 3 weeks" not "I did extensive outreach."
+- When you disagree, state it flat: "That's wrong." Then say why in the next sentence.
+- Use "you" to address the reader, but sparingly — this voice is about what YOU (the writer) know, not what THEY should do.
+- No emoji. No hashtags unless requested. Let the words carry the weight.
+---
+## Sentence Distribution
+| Length | Words | Target |
+|--------|-------|--------|
+| Short | 1-8 | 55% |
+| Medium | 9-16 | 30% |
+| Long | 17-25 | 12% |
+| Very long | 26+ | 3% |
+Average sentence length: 9 words. Short-max boundary: 8 words. Long-min boundary: 17 words.
+---
+## Tier 2 Decisions
+- **AI vocabulary** ("additionally", "furthermore", "landscape", "paradigm", "leverage"): Always cut. Authority doesn't need big words.
+- **"However"**: Cut. Start the next sentence with the contrasting claim directly.
+- **Inflated significance** ("pivotal moment", "game-changing"): Cut. If it's significant, the specifics prove it.
+- **Vague attribution** ("Experts say", "Studies show"): Cut. Name the person or cite the number. Or just state it as your own observation.
+- **Formula transitions**: Always cut. Use line breaks.
+- **Rule of three**: Allowed. Triplets land hard in short-form: "Build it. Ship it. Fix it later."
+- **Elegant variation**: Never. Repeat the word. Repetition is a power move in short-form.
+- **Sentence length uniformity**: The 55% short target handles this. But watch for 4+ consecutive sentences of the same length.
+- **Uniform paragraph length**: N/A for social media.
+- **Mid-formal default**: Override toward direct and informal. Not sloppy — precise and economical.
+- **Hedging**: Cut all hedging. Authority voices assert. If you're uncertain, say "I don't know" — don't hedge.
+- **Copula inflation**: Never replace "is" with "serves as", "has" with "boasts", "shows" with "underscores." Authority uses the plainest verb.
+- **Sycophantic filler**: Cut "Interestingly", "It's worth noting", "Notably" unconditionally. Authority doesn't editorialize.
+- **Contraction mixing**: Don't use contractions 100% of the time OR 0%. Mix "don't" and "do not" inconsistently. Uniform contraction use is an AI signal.
+- **Colon cap**: Maximum 1 colon per post. Use for lists or a single payoff line only.
+---
+## Use-Case Constraints
+- Maximum: 300 words per post, 300 words per thread segment.
+- No paragraphs longer than 2 sentences. If you wrote 3, split it.
+- Thread posts are self-contained. A reader dropping into post 4 gets a complete thought.
+- No emoji, no hashtags unless the user requests them.
+- This voice does NOT work for: customer support, apologies, or anything requiring warmth. Use Storyteller or Business Framed for those.
+---
+## Upgrade Path
+This was written with a generic authority voice. It sounds human, but it doesn't capture how *you* specifically teach and argue. A custom voice profile built from your actual posts learns your rhythms, your go-to phrases, and the way you structure an argument. Import a few writing samples at authors-voice.com to build yours.