openwriter 0.15.0 → 0.17.0

package/dist/server/enrichment.js

@@ -0,0 +1,125 @@
+/**
+ * Frontmatter enrichment staleness detection.
+ *
+ * The matcher already splits every block into sentences and hashes each one on
+ * every save (see node-fingerprint.ts). We reuse that machinery here — no new
+ * algorithm, no new splitter. Save-time staleness is a small tag-on after the
+ * matcher: harvest the current sentence-hash set + char count, compare against
+ * the at-enrichment baseline stored in frontmatter, set `enrichmentStale: true`
+ * when either threshold trips.
+ *
+ * Volume ratio captures growth and shrinkage symmetrically. Jaccard distance
+ * over the sentence-hash set captures rewrites at constant length. Either
+ * tripping flags the doc.
+ *
+ * OpenWriter owns "is this doc stale". The agent clears the flag via
+ * mark_enriched (Phase 4). Both sides read the same field, never compute it
+ * independently.
+ *
+ * See brief: 2026-05-18-frontmatter-enrichment-system.
+ */
+import { splitSentences, simpleHash } from './node-fingerprint.js';
+/** Volume-ratio threshold above which a doc is flagged stale by size delta. */
+export const DEFAULT_ENRICHMENT_VOLUME_THRESHOLD = 1.5;
+/**
+ * Jaccard-distance threshold above which a doc is flagged stale by drift.
+ *
+ * 0.10 catches in-place architectural rewrites that volume-ratio misses —
+ * e.g. inserting a Status Update section into a 200-sentence doc adds
+ * ~25 new sentences, ~0 removed: distance = 25/225 ≈ 0.11, trips at 0.10.
+ * Won't false-positive on routine editing — a 3-sentence paragraph addition
+ * to a 200-sentence doc is 3/203 ≈ 0.015, well below.
+ *
+ * Tightened from 0.3 → 0.10 after 2026-05-19 brief reported the Argument
+ * Arc class of rewrites slipping through.
+ */
+export const DEFAULT_ENRICHMENT_DRIFT_THRESHOLD = 0.10;
+/**
+ * Flatten every block's per-sentence hashes into one sorted unique set.
+ * Sorted so the on-disk representation is stable across saves (no spurious
+ * frontmatter diffs from set-order drift). Unique so duplicate sentences
+ * in the same doc don't double-count in the Jaccard math.
+ */
+export function harvestSentenceHashes(blocks) {
+    const set = new Set();
+    for (const block of blocks) {
+        const sentences = splitSentences(block.text || '');
+        for (const s of sentences) {
+            set.add(simpleHash(s.text + s.terminator));
+        }
+    }
+    return Array.from(set).sort();
+}
+/** Total char count across all blocks' text — the volume signal. */
+export function harvestCharCount(blocks) {
+    let n = 0;
+    for (const b of blocks)
+        n += (b.text || '').length;
+    return n;
+}
+/**
+ * Symmetric size delta. Returns 1 when sizes match, grows toward infinity as
+ * they diverge in either direction. Handles zero-size docs safely.
+ */
+export function volumeRatio(current, baseline) {
+    if (current === 0 && baseline === 0)
+        return 1;
+    if (current === 0 || baseline === 0)
+        return Infinity;
+    return Math.max(current, baseline) / Math.min(current, baseline);
+}
+/**
+ * Jaccard distance over two sentence-hash sets. 0 = identical, 1 = disjoint.
+ * (union - intersection) / union. Empty-vs-empty returns 0.
+ */
+export function jaccardDistance(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 0;
+    const setA = new Set(a);
+    const setB = new Set(b);
+    let intersection = 0;
+    for (const x of setA)
+        if (setB.has(x))
+            intersection++;
+    const union = setA.size + setB.size - intersection;
+    return union === 0 ? 0 : (union - intersection) / union;
+}
+/**
+ * Compute staleness for a single doc given current matcher-derived signals
+ * and the at-enrichment baseline stored in its frontmatter.
+ *
+ * Returns true when:
+ *   - the doc has never been enriched (no lastEnrichedAt) — brief: "absent flag = stale"
+ *   - volumeRatio trips its threshold
+ *   - Jaccard drift trips its threshold
+ *
+ * Thresholds: doc-level overrides first, then global defaults. Workspace-level
+ * overrides (per the brief) will be layered in when the surfacing handlers
+ * (Phase 6) get a workspace pointer — for now the doc carries no workspace
+ * reference in writeToDisk's scope.
+ */
+export function isEnrichmentStale(currentSentenceHashes, currentCharCount, metadata, workspaceOverrides) {
+    // Never enriched → stale by default. New docs land here.
+    if (!metadata.lastEnrichedAt)
+        return true;
+    const baselineHashes = Array.isArray(metadata.lastEnrichedSentences)
+        ? metadata.lastEnrichedSentences
+        : [];
+    const baselineChars = typeof metadata.lastEnrichedCharCount === 'number'
+        ? metadata.lastEnrichedCharCount
+        : 0;
+    const volTh = pickThreshold(metadata.enrichmentVolumeThreshold, workspaceOverrides?.volume, DEFAULT_ENRICHMENT_VOLUME_THRESHOLD);
+    const driftTh = pickThreshold(metadata.enrichmentDriftThreshold, workspaceOverrides?.drift, DEFAULT_ENRICHMENT_DRIFT_THRESHOLD);
+    if (volumeRatio(currentCharCount, baselineChars) >= volTh)
+        return true;
+    if (jaccardDistance(currentSentenceHashes, baselineHashes) >= driftTh)
+        return true;
+    return false;
+}
+function pickThreshold(docLevel, wsLevel, fallback) {
+    if (typeof docLevel === 'number' && docLevel > 0)
+        return docLevel;
+    if (typeof wsLevel === 'number' && wsLevel > 0)
+        return wsLevel;
+    return fallback;
+}

package/dist/server/export-routes.js

@@ -8,6 +8,7 @@ import markdownItIns from 'markdown-it-ins';
 import markdownItMark from 'markdown-it-mark';
 import markdownItSub from 'markdown-it-sub';
 import markdownItSup from 'markdown-it-sup';
+import markdownItFootnote from 'markdown-it-footnote';
 import { tiptapToMarkdown } from './markdown.js';
 import { getDocument, getTitle, getPlainText, getMetadata } from './state.js';
 import { buildExportHtml } from './export-html-template.js';
@@ -18,6 +19,7 @@ md.use(markdownItIns);
 md.use(markdownItMark);
 md.use(markdownItSub);
 md.use(markdownItSup);
+md.use(markdownItFootnote);
 /** Strip YAML frontmatter (---\n...\n---\n\n) from markdown output. */
 function stripFrontmatter(markdown) {
     const match = markdown.match(/^---\n[\s\S]*?\n---\n\n/);

package/dist/server/install-skill.js

@@ -136,6 +136,21 @@ export function installSkill() {
         }
         log(`  ✓ Skill docs copied to ${docsTarget}`);
     }
+    // Install custom Claude Code subagents to ~/.claude/agents/. These have
+    // allowlist-restricted tools so the main agent can dispatch them without
+    // loading the full MCP tool registry into the subagent's context
+    // (~50K tokens of overhead avoided per spawn).
+    const agentsSource = path.join(__dirname, '../../skill/agents');
+    if (fs.existsSync(agentsSource)) {
+        const agentsTarget = path.join(os.homedir(), '.claude', 'agents');
+        fs.mkdirSync(agentsTarget, { recursive: true });
+        for (const file of fs.readdirSync(agentsSource)) {
+            if (!file.endsWith('.md'))
+                continue;
+            fs.copyFileSync(path.join(agentsSource, file), path.join(agentsTarget, file));
+            log(`  ✓ Subagent installed: ${file}`);
+        }
+    }
     // Step 2: Global install or update
     let useNpx = false;
     const currentVersion = getGlobalVersion();

package/dist/server/markdown-parse.js

@@ -17,10 +17,12 @@ import markdownItIns from 'markdown-it-ins';
 import markdownItMark from 'markdown-it-mark';
 import markdownItSub from 'markdown-it-sub';
 import markdownItSup from 'markdown-it-sup';
+import markdownItFootnote from 'markdown-it-footnote';
 import { generateNodeId, LEAF_BLOCK_TYPES } from './helpers.js';
 import { nodeText } from './markdown-serialize.js';
 import { tiptapToBlocks, applyIdsToTiptap } from './node-blocks.js';
 import { matchNodes } from './node-matcher.js';
+import { enrichEntries, enrichSlimArray, fingerprintAll, isLegacyRawEntry, anyLegacyRaw, } from './node-fingerprint.js';
 // ============================================================================
 // Markdown -> TipTap
 // ============================================================================
@@ -30,6 +32,7 @@ md.use(markdownItIns);
 md.use(markdownItMark);
 md.use(markdownItSub);
 md.use(markdownItSup);
+md.use(markdownItFootnote);
 /**
  * Normalize blank lines INSIDE markdown tables before parsing.
  *
@@ -122,14 +125,15 @@ export function markdownToTiptap(markdown) {
         type: 'doc',
         content: docContent.length > 0 ? docContent : [{ type: 'paragraph', attrs: { id: generateNodeId() }, content: [] }],
     };
-    // Extract identity graph from frontmatter — these become the matcher's
-    // previousNodes input on both the load-time pass below AND on every
-    // subsequent save-time pass while the doc stays loaded.
-    const previousNodes = normalizeNodeEntries(data.nodes);
-    const graveyard = normalizeNodeEntries(data.graveyard);
-    // Load-time matcher pass — when frontmatter carries `nodes`, reassign IDs
-    // based on fingerprint match. Legacy docs (no `nodes` field) keep whatever
-    // IDs the body parser extracted from caret anchors or minted fresh.
+    // Resolve identity graph from frontmatter. Two on-disk formats live in the
+    // wild: ultra-lean slim tuples (current) and legacy verbose objects (v0.14
+    // and v0.15). Legacy entries get positionally re-fingerprinted from the
+    // freshly-parsed body — the body IS the previous state at load time, and
+    // re-fingerprinting produces hashes the matcher can pin against cleanly.
+    // adr: adr/node-identity-matcher.md
+    const blocksForEnrich = tiptapToBlocks(doc);
+    const previousNodes = resolvePreviousNodes(data.nodes, blocksForEnrich);
+    const graveyard = resolveGraveyard(data.graveyard);
     if (previousNodes.length > 0) {
         applyMatcher(doc, previousNodes, graveyard);
     }
@@ -151,13 +155,68 @@ export function markdownToTiptap(markdown) {
         previousNodes,
     };
 }
-/** Defensive parse of frontmatter node entries — drops any malformed rows. */
-function normalizeNodeEntries(raw) {
-    if (!Array.isArray(raw))
+/**
+ * Resolve `nodes:` frontmatter into rich NodeEntry[] suitable for the matcher.
+ *
+ * Two on-disk formats:
+ *   - Ultra-lean: each entry is an array tuple. enrichSlimArray derives all
+ *     positional/structural fields from the slim array itself — no body parse
+ *     needed. The slim array IS the previous state (position = array index,
+ *     parent = most-recent unfilled container, neighbors = slim[i±1]).
+ *   - Legacy (v0.14/v0.15): each entry is an object with `id` and `fp` keys.
+ *     We re-fingerprint positionally from the body — the body IS the previous
+ *     state at load time, and a fresh fingerprint over the same body produces
+ *     hashes the matcher can pin against. After the next save, disk is in the
+ *     ultra-lean format and the body-parse cost drops away.
+ *
+ * `blocks` is only consulted for the legacy path; slim path ignores it. Pass
+ * an empty array when you only have slim input to avoid the body parse cost.
+ */
+export function resolvePreviousNodes(raw, blocks) {
+    if (!Array.isArray(raw) || raw.length === 0)
+        return [];
+    if (anyLegacyRaw(raw)) {
+        // Positional re-fingerprint: take each legacy entry's id, assign it to a
+        // freshly-computed fingerprint at the same position in the body.
+        const freshFps = fingerprintAll(blocks);
+        const out = [];
+        for (let i = 0; i < raw.length; i++) {
+            const r = raw[i];
+            const id = isLegacyRawEntry(r) ? r.id : (Array.isArray(r) ? r[0] : null);
+            if (!id || typeof id !== 'string' || !freshFps[i])
+                continue;
+            out.push({ id, fingerprint: freshFps[i] });
+        }
+        return out;
+    }
+    // Ultra-lean: walk the slim array directly. No body parse required.
+    return enrichSlimArray(raw).map((e) => ({
+        id: e.id,
+        fingerprint: e.fingerprint,
+    }));
+}
+/**
+ * Resolve `graveyard:` frontmatter into rich NodeEntry[].
+ *
+ * Ultra-lean tuples enrich without block context (deleted blocks have no
+ * body). Derived fields default to safe values; matcher rules for graveyard
+ * restore only consult type + sentences + structureSig + childTypes, all
+ * carried in slim. Legacy graveyard entries are dropped — their stored
+ * fingerprints don't translate to the new hash semantics (terminator is now
+ * folded into the hash), so they'd never match a fresh paste-back anyway.
+ */
+export function resolveGraveyard(raw) {
+    if (!Array.isArray(raw) || raw.length === 0)
         return [];
-    return raw
-        .filter((entry) => entry && typeof entry === 'object' && entry.id && entry.fp)
-        .map((entry) => ({ id: String(entry.id), fingerprint: entry.fp }));
+    if (anyLegacyRaw(raw)) {
+        // Mixed input: drop legacy entries, enrich slim ones.
+        const slimOnly = raw.filter((r) => Array.isArray(r));
+        return enrichEntries(slimOnly, []).map((e) => ({ id: e.id, fingerprint: e.fingerprint }));
+    }
+    return enrichEntries(raw, []).map((e) => ({
+        id: e.id,
+        fingerprint: e.fingerprint,
+    }));
 }
 /**
  * Run the matcher: compare frontmatter `nodes` (previous fingerprints) to
@@ -329,12 +388,81 @@ function tokensToTiptap(tokens) {
             nodes.push(tableNode);
             i = end + 1;
         }
+        else if (token.type === 'footnote_block_open') {
+            // Footnote definitions section. markdown-it-footnote always emits
+            // this block at end-of-doc with all `[^N]: ...` definitions inside,
+            // regardless of where in the source the `[^N]:` lines appeared.
+            // Parse accepts flexibly; serializer always emits at end-of-doc.
+            // adr: adr/footnote-system.md
+            const end = findClosingToken(tokens, i, 'footnote_block');
+            const definitions = parseFootnoteDefinitions(tokens.slice(i + 1, end));
+            if (definitions.length > 0) {
+                nodes.push({
+                    type: 'footnoteSection',
+                    attrs: { id: generateNodeId() },
+                    content: definitions,
+                });
+            }
+            i = end + 1;
+        }
         else {
             i += 1;
         }
     }
     return nodes;
 }
+/**
+ * Parse the contents of a footnote_block (between footnote_block_open and
+ * footnote_block_close). Each footnote is a footnote_open ... footnote_close
+ * range containing block-level tokens (paragraphs, lists, etc).
+ *
+ * Strips the trailing `footnote_anchor` back-link that markdown-it-footnote
+ * appends to each footnote's last paragraph — it's a renderer artifact, not
+ * source content.
+ */
+function parseFootnoteDefinitions(tokens) {
+    const definitions = [];
+    let i = 0;
+    while (i < tokens.length) {
+        if (tokens[i].type === 'footnote_open') {
+            const label = tokens[i].meta?.label || String(tokens[i].meta?.id ?? '');
+            const end = findClosingToken(tokens, i, 'footnote');
+            const innerTokens = stripFootnoteAnchors(tokens.slice(i + 1, end));
+            const content = tokensToTiptap(innerTokens);
+            definitions.push({
+                type: 'footnoteDefinition',
+                attrs: { id: generateNodeId(), label },
+                content: content.length > 0
+                    ? content
+                    : [{ type: 'paragraph', attrs: { id: generateNodeId() }, content: [] }],
+            });
+            i = end + 1;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return definitions;
+}
+/**
+ * Remove `footnote_anchor` tokens from inline children. markdown-it-footnote
+ * appends an anchor (rendered as ↩︎) to the last paragraph of each footnote
+ * to back-link to the reference. We strip it on parse because it's a
+ * rendering artifact, not source content the author wrote.
+ */
+function stripFootnoteAnchors(tokens) {
+    return tokens.map((token) => {
+        if (token.type !== 'inline' || !token.children)
+            return token;
+        const filtered = token.children.filter((c) => c.type !== 'footnote_anchor');
+        if (filtered.length === token.children.length)
+            return token;
+        // Clone token with filtered children
+        const cloned = Object.assign(Object.create(Object.getPrototypeOf(token)), token);
+        cloned.children = filtered;
+        return cloned;
+    });
+}
 function findClosingToken(tokens, startIndex, type) {
     let depth = 0;
     for (let i = startIndex; i < tokens.length; i++) {
@@ -567,6 +695,17 @@ function inlineTokensToTiptap(tokens) {
         else if (token.type === 'softbreak') {
             nodes.push({ type: 'text', text: ' ' });
         }
+        else if (token.type === 'footnote_ref') {
+            // `[^N]` inline reference. Carry the author-written label verbatim so
+            // mnemonic labels (`[^sapolsky2017]`) survive round-trip. Display
+            // numbering is recomputed by the renderer.
+            // adr: adr/footnote-system.md
+            const label = token.meta?.label || String(token.meta?.id ?? '');
+            nodes.push({
+                type: 'footnoteReference',
+                attrs: { label },
+            });
+        }
     }
     return nodes;
 }

package/dist/server/markdown-serialize.js

@@ -18,7 +18,7 @@
  */
 import { generateNodeId, LEAF_BLOCK_TYPES } from './helpers.js';
 import { tiptapToBlocks } from './node-blocks.js';
-import { fingerprintAll } from './node-fingerprint.js';
+import { fingerprintAll, slimEntry } from './node-fingerprint.js';
 // ============================================================================
 // TipTap -> Markdown
 // ============================================================================
@@ -74,25 +74,23 @@ function collectPendingState(doc) {
     return Object.keys(pending).length > 0 ? pending : undefined;
 }
 /**
- * Build the `nodes` frontmatter entry — one (id, fingerprint) per block
- * in pre-order traversal of the TipTap tree.
+ * Build the `nodes` frontmatter entry — one slim tuple per block in
+ * pre-order traversal of the TipTap tree.
  *
- * Each block's ID comes from its TipTap node's `attrs.id`. Fingerprints are
- * computed from the walker-style block list derived directly from the TipTap
- * tree (no separate markdown re-parse — same source of truth that builds
- * the visible doc).
+ * Disk shape is the ultra-lean tuple form from node-fingerprint.ts. Derived
+ * fields (position, parent indices, neighbor types, char/word counts) are
+ * recomputed at load time from the block tree itself — they don't go to disk.
  */
 function collectNodesFrontmatter(doc) {
     const blocks = tiptapToBlocks(doc);
     const fingerprints = fingerprintAll(blocks);
     const ids = collectBlockIds(doc);
-    // ids array is parallel to blocks array — same pre-order traversal.
-    const entries = [];
+    const out = [];
     for (let i = 0; i < blocks.length; i++) {
         const id = ids[i] || generateNodeId();
-        entries.push({ id, fp: fingerprints[i] });
+        out.push(slimEntry(id, fingerprints[i]));
     }
-    return entries;
+    return out;
 }
 /**
  * Cap graveyard size to avoid frontmatter bloat on docs with many edits.
@@ -107,9 +105,11 @@ function collectBlockIds(doc) {
         'heading', 'paragraph', 'bulletList', 'orderedList', 'taskList',
         'listItem', 'taskItem', 'blockquote', 'codeBlock', 'horizontalRule',
         'table', 'image', 'tableRow', 'tableCell', 'tableHeader',
+        'footnoteSection', 'footnoteDefinition',
     ]);
     const containerTypes = new Set([
         'bulletList', 'orderedList', 'taskList', 'listItem', 'taskItem', 'blockquote',
+        'footnoteSection', 'footnoteDefinition',
     ]);
     function walk(nodes) {
         if (!nodes)
@@ -156,12 +156,12 @@ export function tiptapToMarkdown(doc, title, metadata) {
     else {
         delete meta.nodes;
     }
-    // Graveyard: recently-orphaned (id, fingerprint) entries kept across saves so
-    // paste-back/undo can restore the original ID via exact fingerprint match.
-    // The caller (writeToDisk) puts the matcher's nextGraveyard into metadata.graveyard;
-    // we cap it here to keep the file small.
+    // Graveyard: recently-orphaned entries kept across saves so paste-back/undo
+    // can restore the original ID via exact fingerprint match. Caller passes
+    // `{id, fingerprint}` objects (matcher output); we cap, slim, and emit.
     if (Array.isArray(meta.graveyard) && meta.graveyard.length > 0) {
-        meta.graveyard = meta.graveyard.slice(0, GRAVEYARD_MAX);
+        const capped = meta.graveyard.slice(0, GRAVEYARD_MAX);
+        meta.graveyard = capped.map((g) => Array.isArray(g) ? g : slimEntry(g.id, g.fingerprint || g.fp));
     }
     else {
         delete meta.graveyard;
@@ -226,12 +226,84 @@ function revertPendingForSerialization(doc) {
     return { type: 'doc', content: walk(doc?.content || []) };
 }
 function nodesToMarkdown(nodes) {
-    let result = '';
+    // Constrained model: `footnoteSection` is always emitted last, regardless of
+    // its position in the tree. Authors / agents / editor drag operations may
+    // place it anywhere; the serializer normalizes. Parse accepts flexibly;
+    // serialize produces strictly. First save of any non-canonical file becomes
+    // the one-time migration.
+    //
+    // Trailing-empty-paragraph stripping: TipTap inserts an empty paragraph at
+    // end-of-doc as a cursor-landing artifact. It serializes to a stray
+    // `<!-- -->` marker — visual cruft with no semantic value, and the next
+    // load just re-creates the cursor-landing paragraph anyway. Drop trailing
+    // empty paragraphs unconditionally (whether or not a footnoteSection is
+    // present): they're editor state, not on-disk content.
+    //
+    // Empty paragraphs in the MIDDLE of the doc are preserved — those are
+    // authored blank lines between sections and carry intent. Only the trailing
+    // run of empties at end-of-body gets stripped.
+    //
+    // adr: adr/footnote-system.md
+    let deferredSection = null;
+    const body = [];
     for (const node of nodes) {
+        if (node.type === 'footnoteSection') {
+            deferredSection = node;
+            continue;
+        }
+        body.push(node);
+    }
+    while (body.length > 0) {
+        const last = body[body.length - 1];
+        if (last.type === 'paragraph' && (!last.content || last.content.length === 0)) {
+            body.pop();
+        }
+        else {
+            break;
+        }
+    }
+    let result = '';
+    for (const node of body) {
         result += nodeToMarkdown(node, '');
     }
+    if (deferredSection) {
+        result += footnoteSectionToMarkdown(deferredSection);
+    }
     return result;
 }
+/**
+ * Serialize the footnoteSection block. Each definition emits as
+ * `[^label]: first-paragraph-content` with continuation paragraphs indented
+ * 4 spaces (Pandoc continuation convention). Empty section emits nothing.
+ *
+ * Definitions with no content still emit a `[^label]:` line so the reference
+ * doesn't dangle on round-trip.
+ *
+ * adr: adr/footnote-system.md
+ */
+function footnoteSectionToMarkdown(section) {
+    const definitions = (section.content || []).filter((d) => d.type === 'footnoteDefinition');
+    if (definitions.length === 0)
+        return '';
+    const lines = [];
+    for (const def of definitions) {
+        const label = def.attrs?.label || '';
+        const paragraphs = (def.content || []).filter((c) => c.type === 'paragraph');
+        if (paragraphs.length === 0) {
+            lines.push(`[^${label}]: `);
+            continue;
+        }
+        const firstText = inlineToMarkdown(paragraphs[0].content || []);
+        lines.push(`[^${label}]: ${firstText}`);
+        // Continuation paragraphs: 4-space indent per Pandoc convention.
+        for (let i = 1; i < paragraphs.length; i++) {
+            const text = inlineToMarkdown(paragraphs[i].content || []);
+            lines.push('');
+            lines.push(`    ${text}`);
+        }
+    }
+    return lines.join('\n') + '\n';
+}
 function nodeToMarkdown(node, indent) {
     switch (node.type) {
         case 'heading': {
@@ -409,6 +481,17 @@ export function inlineToMarkdown(nodes) {
             result += '<br>';
             continue;
         }
+        if (node.type === 'footnoteReference') {
+            // Close any open marks so `[^N]` lands at the prose level, not inside
+            // a bold/italic span. Footnote references are visually distinct chips;
+            // wrapping them in bold or italic doesn't make sense.
+            // adr: adr/footnote-system.md
+            result += closeAllMarks(openMarks);
+            openMarks = [];
+            const label = node.attrs?.label || '';
+            result += `[^${label}]`;
+            continue;
+        }
         if (node.type !== 'text')
             continue;
         const targetMarks = (node.marks || [])