@openparachute/vault 0.1.0 → 0.2.1

package/core/src/expand.ts

@@ -0,0 +1,140 @@
+/**
+ * Inline expansion of [[wikilinks]] in note content.
+ *
+ * Used by `query-notes` when `expand_links=true`. Replaces wikilink matches
+ * with delimited blocks containing the linked note's content (full mode) or
+ * metadata summary (summary mode). Deduplicates across the query and guards
+ * against cycles via a shared `expanded` set.
+ */
+
+import { Database } from "bun:sqlite";
+import type { Note } from "./types.js";
+import * as noteOps from "./notes.js";
+import { resolveWikilink } from "./wikilinks.js";
+
+export type ExpandMode = "full" | "summary";
+
+export const DEFAULT_EXPAND_DEPTH = 1;
+export const MAX_EXPAND_DEPTH = 3;
+
+export interface ExpandContext {
+  db: Database;
+  mode: ExpandMode;
+  /** Note IDs already expanded in this query. Shared across all expansions. */
+  expanded: Set<string>;
+}
+
+/**
+ * Matches wikilinks the same way the parser does — but retains positions.
+ * Embeds (`![[...]]`) are treated as regular links here; the `!` is discarded
+ * in the expansion output. If embed-specific rendering is needed later,
+ * inspect the first capture group.
+ */
+const WIKILINK_RE = /(!?)\[\[([^\[\]\n]+?)\]\]/g;
+
+/**
+ * Expand wikilinks in `content` up to `remainingDepth` levels deep. Returns
+ * content with `<expanded>` blocks replacing each wikilink occurrence.
+ *
+ * `remainingDepth` counts down: when it reaches 0, no further expansion
+ * happens. A call with remainingDepth=1 expands top-level wikilinks only;
+ * wikilinks inside those expansions are left as-is.
+ *
+ * Wikilinks inside fenced or inline code blocks are left untouched — mirrors
+ * the behavior of `parseWikilinks` in `wikilinks.ts` so the link graph and
+ * the expansion view stay consistent.
+ */
+export function expandContent(
+  content: string,
+  ctx: ExpandContext,
+  remainingDepth: number,
+): string {
+  if (remainingDepth <= 0) return content;
+
+  const codeSkip = codeRanges(content);
+
+  return content.replace(WIKILINK_RE, (match, _bang: string, inner: string, offset: number) => {
+    if (inCodeRange(offset, codeSkip)) return match;
+
+    const target = parseTarget(inner);
+    if (!target) return match;
+
+    const noteId = resolveWikilink(ctx.db, target);
+    if (!noteId) return match; // unresolved or ambiguous — leave as-is
+
+    if (ctx.expanded.has(noteId)) {
+      return `${match} (expanded above)`;
+    }
+    ctx.expanded.add(noteId);
+
+    const note = noteOps.getNote(ctx.db, noteId);
+    if (!note) return match; // shouldn't happen, but be safe
+
+    if (ctx.mode === "summary") {
+      // Summary mode doesn't recurse: depth > 1 has no additional effect.
+      return renderSummary(note);
+    }
+
+    // Full mode — expand nested wikilinks one less level deep.
+    const nested = expandContent(note.content, ctx, remainingDepth - 1);
+    return renderFull(note, nested);
+  });
+}
+
+function codeRanges(content: string): [number, number][] {
+  const ranges: [number, number][] = [];
+  const fenced = /```[\s\S]*?```/g;
+  let m: RegExpExecArray | null;
+  while ((m = fenced.exec(content)) !== null) {
+    ranges.push([m.index, m.index + m[0].length]);
+  }
+  const inline = /`[^`\n]+`/g;
+  while ((m = inline.exec(content)) !== null) {
+    ranges.push([m.index, m.index + m[0].length]);
+  }
+  return ranges;
+}
+
+function inCodeRange(pos: number, ranges: [number, number][]): boolean {
+  for (const [start, end] of ranges) {
+    if (pos >= start && pos < end) return true;
+  }
+  return false;
+}
+
+function parseTarget(inner: string): string | null {
+  // Strip display alias: "target|display" → "target"
+  const pipeIdx = inner.indexOf("|");
+  let targetPart = pipeIdx === -1 ? inner : inner.slice(0, pipeIdx);
+  // Strip anchor/block-ref: "target#heading" → "target"
+  const hashIdx = targetPart.indexOf("#");
+  if (hashIdx !== -1) targetPart = targetPart.slice(0, hashIdx);
+  const target = targetPart.trim();
+  return target || null;
+}
+
+function renderFull(note: Note, content: string): string {
+  const pathAttr = escapeAttr(note.path ?? note.id);
+  return `<expanded path="${pathAttr}" mode="full">\n${content}\n</expanded>`;
+}
+
+function renderSummary(note: Note): string {
+  const pathAttr = escapeAttr(note.path ?? note.id);
+  const summary = summaryText(note);
+  return `<expanded path="${pathAttr}" mode="summary">\n${summary}\n</expanded>`;
+}
+
+function summaryText(note: Note): string {
+  const meta = note.metadata as Record<string, unknown> | undefined;
+  const s = meta?.summary;
+  if (typeof s === "string" && s.trim()) return s.trim();
+  return "";
+}
+
+function escapeAttr(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}

package/core/src/hooks.test.ts

@@ -26,7 +26,7 @@ async function settle(): Promise<void> {
   await hooks.drain();
 }
 
-describe("HookRegistry", () => {
+describe("HookRegistry", async () => {
   it("fires registered hook on createNote", async () => {
     const fired: string[] = [];
     hooks.onNote({
@@ -36,7 +36,7 @@ describe("HookRegistry", () => {
       },
     });
 
-    const note = store.createNote("hello");
+    const note = await store.createNote("hello");
     expect(fired).toEqual([]); // async — not yet
     await settle();
     expect(fired).toEqual([note.id]);
@@ -51,11 +51,11 @@ describe("HookRegistry", () => {
       },
     });
 
-    const note = store.createNote("hello");
+    const note = await store.createNote("hello");
     await settle();
     expect(fired).toEqual([]); // we only subscribed to updated
 
-    store.updateNote(note.id, { content: "world" });
+    await store.updateNote(note.id, { content: "world" });
     await settle();
     expect(fired).toEqual([{ event: "updated", id: note.id }]);
   });
@@ -68,7 +68,7 @@ describe("HookRegistry", () => {
       },
     });
 
-    const notes = store.createNotes([
+    const notes = await store.createNotes([
       { content: "a", id: "a1" },
       { content: "b", id: "b1" },
       { content: "c", id: "c1" },
@@ -87,8 +87,8 @@ describe("HookRegistry", () => {
       },
     });
 
-    const skipped = store.createNote("plain", { tags: ["journal"] });
-    const matched = store.createNote("reader-note", { tags: ["reader"] });
+    const skipped = await store.createNote("plain", { tags: ["journal"] });
+    const matched = await store.createNote("reader-note", { tags: ["reader"] });
     await settle();
 
     expect(fired).toEqual([matched.id]);
@@ -103,14 +103,14 @@ describe("HookRegistry", () => {
       },
     });
 
-    const note = store.createNote("one");
+    const note = await store.createNote("one");
     await settle();
     expect(fired).toEqual([note.id]);
 
     fired.length = 0;
-    store.getNote(note.id);
-    store.getNotes([note.id]);
-    store.queryNotes({});
+    await store.getNote(note.id);
+    await store.getNotes([note.id]);
+    await store.queryNotes({});
     await settle();
     expect(fired).toEqual([]);
   });
@@ -128,14 +128,14 @@ describe("HookRegistry", () => {
       },
     });
 
-    const note = store.createNote("work me");
+    const note = await store.createNote("work me");
     await settle();
     // The handler ran once for "created"; its updateNote triggered an
     // "updated" dispatch, but the predicate excluded it because the
     // marker is now set. So exactly one call.
     expect(handlerCalls).toBe(1);
 
-    const refreshed = store.getNote(note.id)!;
+    const refreshed = (await store.getNote(note.id))!;
     expect(refreshed.metadata?.processed_at).toBeTruthy();
   });
 
@@ -155,10 +155,10 @@ describe("HookRegistry", () => {
       },
     });
 
-    const note = localStore.createNote("survive");
+    const note = await localStore.createNote("survive");
     expect(note.id).toBeTruthy();
     // Original mutation still persisted
-    expect(localStore.getNote(note.id)?.content).toBe("survive");
+    expect((await localStore.getNote(note.id))?.content).toBe("survive");
 
     await Promise.resolve();
     await Promise.resolve();
@@ -184,9 +184,9 @@ describe("HookRegistry", () => {
       },
     });
 
-    localStore.createNote("a");
-    localStore.createNote("b");
-    localStore.createNote("c");
+    await localStore.createNote("a");
+    await localStore.createNote("b");
+    await localStore.createNote("c");
 
     // Let dispatch microtasks enqueue tasks and the semaphore start one.
     await Promise.resolve();
@@ -216,12 +216,12 @@ describe("HookRegistry", () => {
       },
     });
 
-    store.createNote("first");
+    await store.createNote("first");
     await settle();
     expect(fired.length).toBe(1);
 
     off();
-    store.createNote("second");
+    await store.createNote("second");
     await settle();
     expect(fired.length).toBe(1);
   });
@@ -231,7 +231,7 @@ describe("HookRegistry", () => {
     hooks.onNote({ name: "one", handler: () => void order.push("one") });
     hooks.onNote({ name: "two", handler: () => void order.push("two") });
 
-    store.createNote("both");
+    await store.createNote("both");
     await settle();
     expect(order.sort()).toEqual(["one", "two"]);
   });
@@ -244,7 +244,7 @@ describe("HookRegistry", () => {
         done = true;
       },
     });
-    store.createNote("slow");
+    await store.createNote("slow");
     // Let dispatch schedule
     await Promise.resolve();
     await Promise.resolve();
@@ -278,7 +278,7 @@ describe("HookRegistry", () => {
       },
     });
 
-    loggingStore.createNote("hi");
+    await loggingStore.createNote("hi");
     await Promise.resolve();
     await Promise.resolve();
     await loggingHooks.drain();
@@ -292,7 +292,7 @@ describe("HookRegistry", () => {
   });
 });
 
-describe("HookRegistry — HOOK_CONCURRENCY env var parsing", () => {
+describe("HookRegistry — HOOK_CONCURRENCY env var parsing", async () => {
   const original = process.env.HOOK_CONCURRENCY;
   const restore = () => {
     if (original === undefined) delete process.env.HOOK_CONCURRENCY;
@@ -344,9 +344,9 @@ describe("HookRegistry — HOOK_CONCURRENCY env var parsing", () => {
       },
     });
 
-    s.createNote("a");
-    s.createNote("b");
-    s.createNote("c");
+    await s.createNote("a");
+    await s.createNote("b");
+    await s.createNote("c");
     await Promise.resolve();
     await Promise.resolve();
     // Release them one at a time and let each drain through the semaphore.

package/core/src/hooks.ts

@@ -203,7 +203,7 @@ export class HookRegistry {
       // Re-read the note so the handler sees the latest state (another
       // handler may have written back in between). If the note was
       // deleted, silently drop.
-      const fresh = store.getNote(note.id) ?? note;
+      const fresh = (await store.getNote(note.id)) ?? note;
       await hook.handler(fresh, store, event);
     } catch (err) {
       this.logger.error(

package/core/src/mcp.ts

@@ -4,12 +4,19 @@ import * as noteOps from "./notes.js";
 import { filterMetadata } from "./notes.js";
 import * as linkOps from "./links.js";
 import * as tagSchemaOps from "./tag-schemas.js";
+import {
+  expandContent,
+  DEFAULT_EXPAND_DEPTH,
+  MAX_EXPAND_DEPTH,
+  type ExpandContext,
+  type ExpandMode,
+} from "./expand.js";
 
 export interface McpToolDef {
   name: string;
   description: string;
   inputSchema: Record<string, unknown>;
-  execute: (params: Record<string, unknown>) => unknown;
+  execute: (params: Record<string, unknown>) => unknown | Promise<unknown>;
 }
 
 // ---------------------------------------------------------------------------
@@ -78,7 +85,9 @@ export function generateMcpTools(store: Store): McpToolDef[] {
 - **Graph neighborhood**: pass \`near\` to scope results to notes within N hops of an anchor note
 - **No filters**: returns all notes (paginated)
 
-Defaults: include_content=true for single note, false for lists. include_links=false. tag_match="any".`,
+Defaults: include_content=true for single note, false for lists. include_links=false. tag_match="any".
+
+Link expansion: pass \`expand_links: true\` to inline [[wikilinks]] from returned content. Tune with \`expand_depth\` (1–3, default 1) and \`expand_mode\` ("full" inlines full content, "summary" inlines only metadata.summary). Expansions are deduplicated across the query and cycle-guarded.`,
       inputSchema: {
         type: "object",
         properties: {
@@ -121,21 +130,43 @@ Defaults: include_content=true for single note, false for lists. include_links=f
           },
           include_links: { type: "boolean", description: "Include inbound + outbound links per note (default: false)" },
           include_attachments: { type: "boolean", description: "Include attachment records (default: false)" },
+          expand_links: { type: "boolean", description: "Inline [[wikilinks]] in returned content (default: false). Has no effect if content is not included (e.g., default list mode with include_content=false); wikilinks inside fenced or inline code are not expanded." },
+          expand_depth: { type: "number", description: "Recursion depth for link expansion (default 1, max 3). Only meaningful in 'full' mode — 'summary' mode does not recurse." },
+          expand_mode: { type: "string", enum: ["full", "summary"], description: "Expansion rendering: 'full' inlines the linked note's content, 'summary' inlines only metadata.summary. Default: 'full'." },
         },
       },
-      execute: (params) => {
+      execute: async (params) => {
+        // --- Link expansion config (shared across single + list paths) ---
+        const expandLinks = params.expand_links === true;
+        const expandMode = (params.expand_mode as ExpandMode) ?? "full";
+        const expandDepth = Math.max(
+          0,
+          Math.min(
+            (params.expand_depth as number | undefined) ?? DEFAULT_EXPAND_DEPTH,
+            MAX_EXPAND_DEPTH,
+          ),
+        );
+        const expandCtx: ExpandContext | null = expandLinks
+          ? { db, mode: expandMode, expanded: new Set() }
+          : null;
+
         // --- Single note by ID/path ---
         if (params.id) {
           const note = resolveNote(db, params.id as string);
           if (!note) return { error: "Note not found", id: params.id };
           const includeContent = params.include_content !== false; // default true for single
           let result: any = includeContent ? { ...note } : noteOps.toNoteIndex(note);
+          if (expandCtx && includeContent && typeof result.content === "string") {
+            // Mark the top-level note as already expanded so it can't recursively inline itself.
+            expandCtx.expanded.add(note.id);
+            result.content = expandContent(result.content, expandCtx, expandDepth);
+          }
           result = filterMetadata(result, params.include_metadata as boolean | string[] | undefined);
           if (params.include_links) {
             result.links = linkOps.getLinksHydrated(db, note.id);
           }
           if (params.include_attachments) {
-            result.attachments = store.getAttachments(note.id);
+            result.attachments = await store.getAttachments(note.id);
           }
           return result;
         }
@@ -189,7 +220,18 @@ Defaults: include_content=true for single note, false for lists. include_links=f
         // --- Format output ---
         const includeContent = params.include_content === true; // default false for list
         const includeMetadata = params.include_metadata as boolean | string[] | undefined;
-        let output = includeContent ? results : results.map(noteOps.toNoteIndex);
+        let output: any[] = includeContent ? results.map((n) => ({ ...n })) : results.map(noteOps.toNoteIndex);
+
+        // --- Expand wikilinks inline (only meaningful when content is present) ---
+        if (expandCtx && includeContent) {
+          // Mark all top-level notes as already expanded so they can't inline each other.
+          for (const n of output) expandCtx.expanded.add(n.id);
+          for (const n of output) {
+            if (typeof n.content === "string") {
+              n.content = expandContent(n.content, expandCtx, expandDepth);
+            }
+          }
+        }
 
         // --- Apply metadata filtering ---
         if (includeMetadata !== undefined && includeMetadata !== true) {
@@ -198,12 +240,14 @@ Defaults: include_content=true for single note, false for lists. include_links=f
 
         // --- Hydrate links/attachments per note if requested ---
         if (params.include_links || params.include_attachments) {
-          return output.map((n: any) => {
-            const enriched = { ...n };
+          const enrichedOut: any[] = [];
+          for (const n of output as any[]) {
+            const enriched: any = { ...n };
             if (params.include_links) enriched.links = linkOps.getLinksHydrated(db, n.id);
-            if (params.include_attachments) enriched.attachments = store.getAttachments(n.id);
-            return enriched;
-          });
+            if (params.include_attachments) enriched.attachments = await store.getAttachments(n.id);
+            enrichedOut.push(enriched);
+          }
+          return enrichedOut;
         }
 
         return output;
@@ -256,13 +300,13 @@ Defaults: include_content=true for single note, false for lists. include_links=f
           },
         },
       },
-      execute: (params) => {
+      execute: async (params) => {
         const batch = params.notes as any[] | undefined;
         const items = batch ?? [params];
 
         const created: Note[] = [];
         for (const item of items) {
-          const note = store.createNote(item.content as string ?? "", {
+          const note = await store.createNote(item.content as string ?? "", {
             path: item.path as string | undefined,
             tags: item.tags as string[] | undefined,
             metadata: item.metadata as Record<string, unknown> | undefined,
@@ -274,7 +318,7 @@ Defaults: include_content=true for single note, false for lists. include_links=f
             for (const link of item.links as { target: string; relationship: string }[]) {
               const target = resolveNote(db, link.target);
               if (target) {
-                store.createLink(note.id, target.id, link.relationship);
+                await store.createLink(note.id, target.id, link.relationship);
               }
             }
           }
@@ -285,7 +329,7 @@ Defaults: include_content=true for single note, false for lists. include_links=f
         // Apply tag schema effects
         for (const note of created) {
           if (note.tags && note.tags.length > 0) {
-            applySchemaDefaults(store, db, [note.id], note.tags);
+            await applySchemaDefaults(store, db, [note.id], note.tags);
           }
         }
 
@@ -303,7 +347,8 @@ Defaults: include_content=true for single note, false for lists. include_links=f
 - \`tags: { add: ["x"], remove: ["y"] }\` — add/remove tags
 - \`links: { add: [{ target, relationship }], remove: [{ target, relationship }] }\` — add/remove links
 - When removing a wikilink-type link, \`[[brackets]]\` are also removed from content.
-- For batch: pass a \`notes\` array, each with an \`id\` field.`,
+- For batch: pass a \`notes\` array, each with an \`id\` field.
+- Optimistic concurrency: pass \`if_updated_at\` with the \`updated_at\` value you last read. The update is rejected with a conflict error if the note has changed since. Re-read the note, reconcile, and retry.`,
       inputSchema: {
         type: "object",
         properties: {
@@ -312,6 +357,7 @@ Defaults: include_content=true for single note, false for lists. include_links=f
           path: { type: "string", description: "New path" },
           metadata: { type: "object", description: "Metadata to merge (keys are merged, not replaced wholesale)" },
           created_at: { type: "string", description: "New created_at timestamp" },
+          if_updated_at: { type: "string", description: "Optimistic concurrency check: the updated_at value you last read. Rejects with a conflict error if the note has been modified since." },
           tags: {
             type: "object",
             properties: {
@@ -359,6 +405,7 @@ Defaults: include_content=true for single note, false for lists. include_links=f
                 path: { type: "string" },
                 metadata: { type: "object" },
                 created_at: { type: "string" },
+                if_updated_at: { type: "string", description: "Optimistic concurrency check for this item; rejects with a conflict error if the note has been modified since." },
                 tags: { type: "object" },
                 links: { type: "object" },
               },
@@ -368,35 +415,37 @@ Defaults: include_content=true for single note, false for lists. include_links=f
           },
         },
       },
-      execute: (params) => {
+      execute: async (params) => {
         const batch = params.notes as any[] | undefined;
         const items = batch ?? [params];
 
         const updated: Note[] = [];
         for (const item of items) {
           const note = requireNote(db, item.id as string);
-          let contentOverride = item.content as string | undefined;
 
-          // --- Remove links (before content update, so bracket removal applies) ---
+          // --- Plan bracket cleanup for wikilink removals (no DB writes yet) ---
+          // We compute the cleaned content so we can do the core UPDATE first
+          // (with if_updated_at atomically) before any link deletions. If the
+          // UPDATE fails on a conflict, nothing has been mutated.
+          let contentOverride = item.content as string | undefined;
           const linksRemove = (item.links as any)?.remove as { target: string; relationship: string }[] | undefined;
+          const resolvedLinksToRemove: { targetId: string; relationship: string }[] = [];
           if (linksRemove) {
             for (const link of linksRemove) {
               const target = resolveNote(db, link.target);
-              if (target) {
-                store.deleteLink(note.id, target.id, link.relationship);
-                // Remove [[brackets]] from content if this was a wikilink
-                if (link.relationship === "wikilink" && target.path) {
-                  const currentContent = contentOverride ?? note.content;
-                  const cleaned = removeWikilinkBrackets(currentContent, target.path);
-                  if (cleaned !== currentContent) {
-                    contentOverride = cleaned;
-                  }
+              if (!target) continue;
+              resolvedLinksToRemove.push({ targetId: target.id, relationship: link.relationship });
+              if (link.relationship === "wikilink" && target.path) {
+                const currentContent = contentOverride ?? note.content;
+                const cleaned = removeWikilinkBrackets(currentContent, target.path);
+                if (cleaned !== currentContent) {
+                  contentOverride = cleaned;
                 }
               }
             }
           }
 
-          // --- Core update (content, path, metadata, created_at) ---
+          // --- Core update (content, path, metadata, created_at + concurrency check) ---
           const updates: any = {};
           if (contentOverride !== undefined) updates.content = contentOverride;
           if (item.path !== undefined) updates.path = item.path;
@@ -406,22 +455,32 @@ Defaults: include_content=true for single note, false for lists. include_links=f
             updates.metadata = { ...existing, ...(item.metadata as Record<string, unknown>) };
           }
           if (item.created_at !== undefined) updates.created_at = item.created_at;
+          if (item.if_updated_at !== undefined) updates.if_updated_at = item.if_updated_at as string;
 
           let result: Note;
           if (Object.keys(updates).length > 0) {
-            result = store.updateNote(note.id, updates);
+            // store.updateNote routes through noteOps.updateNote, which runs
+            // the UPDATE (with optional `AND updated_at IS ?`) atomically and
+            // throws ConflictError on mismatch. No mutations have happened
+            // yet, so a throw here leaves the note untouched.
+            result = await store.updateNote(note.id, updates);
           } else {
             result = note;
           }
 
+          // --- Remove links (after core UPDATE so a conflict leaves them intact) ---
+          for (const { targetId, relationship } of resolvedLinksToRemove) {
+            await store.deleteLink(note.id, targetId, relationship);
+          }
+
           // --- Tags ---
           const tagsOp = item.tags as { add?: string[]; remove?: string[] } | undefined;
           if (tagsOp?.add?.length) {
-            store.tagNote(note.id, tagsOp.add);
-            applySchemaDefaults(store, db, [note.id], tagsOp.add);
+            await store.tagNote(note.id, tagsOp.add);
+            await applySchemaDefaults(store, db, [note.id], tagsOp.add);
           }
           if (tagsOp?.remove?.length) {
-            store.untagNote(note.id, tagsOp.remove);
+            await store.untagNote(note.id, tagsOp.remove);
           }
 
           // --- Add links ---
@@ -430,7 +489,7 @@ Defaults: include_content=true for single note, false for lists. include_links=f
             for (const link of linksAdd) {
               const target = resolveNote(db, link.target);
               if (target) {
-                store.createLink(note.id, target.id, link.relationship, link.metadata);
+                await store.createLink(note.id, target.id, link.relationship, link.metadata);
               }
             }
           }
@@ -456,9 +515,9 @@ Defaults: include_content=true for single note, false for lists. include_links=f
         },
         required: ["id"],
       },
-      execute: (params) => {
+      execute: async (params) => {
         const note = requireNote(db, params.id as string);
-        store.deleteNote(note.id);
+        await store.deleteNote(note.id);
         return { deleted: true, id: note.id };
       },
     },
@@ -557,11 +616,11 @@ Defaults: include_content=true for single note, false for lists. include_links=f
         },
         required: ["tag"],
       },
-      execute: (params) => {
+      execute: async (params) => {
         const tag = params.tag as string;
         // Delete schema first (FK cascade would handle it, but be explicit)
         tagSchemaOps.deleteTagSchema(db, tag);
-        return store.deleteTag(tag);
+        return await store.deleteTag(tag);
       },
     },
 
@@ -617,7 +676,7 @@ Defaults: include_content=true for single note, false for lists. include_links=f
 // Tag schema effects — auto-populate defaults when tags are applied
 // ---------------------------------------------------------------------------
 
-function applySchemaDefaults(store: Store, db: Database, noteIds: string[], tags: string[]): void {
+async function applySchemaDefaults(store: Store, db: Database, noteIds: string[], tags: string[]): Promise<void> {
   const schemas = tagSchemaOps.getTagSchemaMap(db);
   if (Object.keys(schemas).length === 0) return;
 
@@ -644,7 +703,7 @@ function applySchemaDefaults(store: Store, db: Database, noteIds: string[], tags
       }
     }
     if (Object.keys(missing).length === 0) continue;
-    store.updateNote(noteId, {
+    await store.updateNote(noteId, {
       metadata: { ...existing, ...missing },
       skipUpdatedAt: true,
     });
@@ -670,3 +729,7 @@ function normalizeTags(tag: unknown): string[] | undefined {
   return [tag as string];
 }
 
+// Re-exported for backward compat; defined in notes.ts alongside the
+// conditional-UPDATE implementation that raises it.
+export { ConflictError } from "./notes.js";
+