@openparachute/vault 0.1.0 → 0.2.1

package/src/vault.test.ts

@@ -29,39 +29,39 @@ afterEach(() => {
   rmSync(tmpDir, { recursive: true, force: true });
 });
 
-describe("BunStore", () => {
-  test("creates and retrieves a note", () => {
-    const note = store.createNote("Hello world");
+describe("BunStore", async () => {
+  test("creates and retrieves a note", async () => {
+    const note = await store.createNote("Hello world");
     expect(note.id).toBeTruthy();
     expect(note.content).toBe("Hello world");
 
-    const fetched = store.getNote(note.id);
+    const fetched = await store.getNote(note.id);
     expect(fetched).not.toBeNull();
     expect(fetched!.content).toBe("Hello world");
   });
 
-  test("creates note with tags", () => {
-    const note = store.createNote("Tagged note", { tags: ["daily", "pinned"] });
+  test("creates note with tags", async () => {
+    const note = await store.createNote("Tagged note", { tags: ["daily", "pinned"] });
     expect(note.tags).toContain("daily");
     expect(note.tags).toContain("pinned");
   });
 
-  test("creates note with path", () => {
-    const note = store.createNote("Doc note", { path: "blog/first-post" });
+  test("creates note with path", async () => {
+    const note = await store.createNote("Doc note", { path: "blog/first-post" });
     expect(note.path).toBe("blog/first-post");
   });
 
-  test("updates a note", () => {
-    const note = store.createNote("Original");
-    const updated = store.updateNote(note.id, { content: "Updated" });
+  test("updates a note", async () => {
+    const note = await store.createNote("Original");
+    const updated = await store.updateNote(note.id, { content: "Updated" });
     expect(updated.content).toBe("Updated");
     expect(updated.updatedAt).toBeTruthy();
   });
 
-  test("user updates bump updatedAt", () => {
-    const note = store.createNote("Original");
+  test("user updates bump updatedAt", async () => {
+    const note = await store.createNote("Original");
     expect(note.updatedAt).toBeUndefined();
-    const updated = store.updateNote(note.id, { content: "Edited by user" });
+    const updated = await store.updateNote(note.id, { content: "Edited by user" });
     expect(updated.updatedAt).toBeTruthy();
   });
 
@@ -69,15 +69,15 @@ describe("BunStore", () => {
     // Hook writes (e.g., the reader-audio hook's metadata markers) must not
     // count as user activity. See issue #44 — hook writes were bumping
     // updatedAt and wrecking Daily's reader sort.
-    const note = store.createNote("Content");
+    const note = await store.createNote("Content");
     expect(note.updatedAt).toBeUndefined();
 
     // Fresh note: a machine write must not set updatedAt.
-    store.updateNote(note.id, {
+    await store.updateNote(note.id, {
       metadata: { audio_pending_at: "2026-04-09T10:00:00.000Z" },
       skipUpdatedAt: true,
     });
-    let fetched = store.getNote(note.id)!;
+    let fetched = (await store.getNote(note.id))!;
     expect(fetched.updatedAt).toBeUndefined();
     expect((fetched.metadata as { audio_pending_at?: string } | undefined)?.audio_pending_at).toBe(
       "2026-04-09T10:00:00.000Z",
@@ -85,152 +85,152 @@ describe("BunStore", () => {
 
     // Now a real user edit bumps it.
     await new Promise((r) => setTimeout(r, 5));
-    store.updateNote(note.id, { content: "User edit" });
-    fetched = store.getNote(note.id)!;
+    await store.updateNote(note.id, { content: "User edit" });
+    fetched = (await store.getNote(note.id))!;
     const userTs = fetched.updatedAt;
     expect(userTs).toBeTruthy();
 
     // A subsequent machine write must not overwrite the user's timestamp.
     await new Promise((r) => setTimeout(r, 5));
-    store.updateNote(note.id, {
+    await store.updateNote(note.id, {
       metadata: {
         ...(fetched.metadata as Record<string, unknown>),
         audio_rendered_at: "2026-04-09T10:05:00.000Z",
       },
       skipUpdatedAt: true,
     });
-    fetched = store.getNote(note.id)!;
+    fetched = (await store.getNote(note.id))!;
     expect(fetched.updatedAt).toBe(userTs!);
     expect((fetched.metadata as { audio_rendered_at?: string } | undefined)?.audio_rendered_at).toBe(
       "2026-04-09T10:05:00.000Z",
     );
   });
 
-  test("deletes a note", () => {
-    const note = store.createNote("To delete");
-    store.deleteNote(note.id);
-    expect(store.getNote(note.id)).toBeNull();
+  test("deletes a note", async () => {
+    const note = await store.createNote("To delete");
+    await store.deleteNote(note.id);
+    expect(await store.getNote(note.id)).toBeNull();
   });
 
-  test("queries notes by tag", () => {
-    store.createNote("A", { tags: ["daily"] });
-    store.createNote("B", { tags: ["doc"] });
-    store.createNote("C", { tags: ["daily", "pinned"] });
+  test("queries notes by tag", async () => {
+    await store.createNote("A", { tags: ["daily"] });
+    await store.createNote("B", { tags: ["doc"] });
+    await store.createNote("C", { tags: ["daily", "pinned"] });
 
-    const daily = store.queryNotes({ tags: ["daily"] });
+    const daily = await store.queryNotes({ tags: ["daily"] });
     expect(daily.length).toBe(2);
   });
 
-  test("queries with exclude tags", () => {
-    store.createNote("A", { tags: ["daily"] });
-    store.createNote("B", { tags: ["daily", "archived"] });
+  test("queries with exclude tags", async () => {
+    await store.createNote("A", { tags: ["daily"] });
+    await store.createNote("B", { tags: ["daily", "archived"] });
 
-    const active = store.queryNotes({ tags: ["daily"], excludeTags: ["archived"] });
+    const active = await store.queryNotes({ tags: ["daily"], excludeTags: ["archived"] });
     expect(active.length).toBe(1);
     expect(active[0].content).toBe("A");
   });
 
-  test("full-text search", () => {
-    store.createNote("The quick brown fox");
-    store.createNote("A lazy dog");
+  test("full-text search", async () => {
+    await store.createNote("The quick brown fox");
+    await store.createNote("A lazy dog");
 
-    const results = store.searchNotes("fox");
+    const results = await store.searchNotes("fox");
     expect(results.length).toBe(1);
     expect(results[0].content).toContain("fox");
   });
 
-  test("tags and untags notes", () => {
-    const note = store.createNote("Taggable");
-    store.tagNote(note.id, ["important"]);
-    let fetched = store.getNote(note.id)!;
+  test("tags and untags notes", async () => {
+    const note = await store.createNote("Taggable");
+    await store.tagNote(note.id, ["important"]);
+    let fetched = (await store.getNote(note.id))!;
     expect(fetched.tags).toContain("important");
 
-    store.untagNote(note.id, ["important"]);
-    fetched = store.getNote(note.id)!;
+    await store.untagNote(note.id, ["important"]);
+    fetched = (await store.getNote(note.id))!;
     expect(fetched.tags).not.toContain("important");
   });
 
-  test("lists tags with counts", () => {
-    store.createNote("A", { tags: ["daily"] });
-    store.createNote("B", { tags: ["daily"] });
-    store.createNote("C", { tags: ["doc"] });
+  test("lists tags with counts", async () => {
+    await store.createNote("A", { tags: ["daily"] });
+    await store.createNote("B", { tags: ["daily"] });
+    await store.createNote("C", { tags: ["doc"] });
 
-    const tags = store.listTags();
+    const tags = await store.listTags();
     const daily = tags.find((t) => t.name === "daily");
     expect(daily?.count).toBe(2);
     const doc = tags.find((t) => t.name === "doc");
     expect(doc?.count).toBe(1);
   });
 
-  test("creates and queries links", () => {
-    const a = store.createNote("Note A");
-    const b = store.createNote("Note B");
+  test("creates and queries links", async () => {
+    const a = await store.createNote("Note A");
+    const b = await store.createNote("Note B");
 
-    const link = store.createLink(a.id, b.id, "related-to");
+    const link = await store.createLink(a.id, b.id, "related-to");
     expect(link.sourceId).toBe(a.id);
     expect(link.targetId).toBe(b.id);
     expect(link.relationship).toBe("related-to");
 
-    const outbound = store.getLinks(a.id, { direction: "outbound" });
+    const outbound = await store.getLinks(a.id, { direction: "outbound" });
     expect(outbound.length).toBe(1);
 
-    const inbound = store.getLinks(b.id, { direction: "inbound" });
+    const inbound = await store.getLinks(b.id, { direction: "inbound" });
     expect(inbound.length).toBe(1);
 
-    store.deleteLink(a.id, b.id, "related-to");
-    expect(store.getLinks(a.id).length).toBe(0);
+    await store.deleteLink(a.id, b.id, "related-to");
+    expect((await store.getLinks(a.id)).length).toBe(0);
   });
 
-  test("attachments", () => {
-    const note = store.createNote("With attachment");
-    const att = store.addAttachment(note.id, "/path/to/file.png", "image/png");
+  test("attachments", async () => {
+    const note = await store.createNote("With attachment");
+    const att = await store.addAttachment(note.id, "/path/to/file.png", "image/png");
     expect(att.noteId).toBe(note.id);
 
-    const atts = store.getAttachments(note.id);
+    const atts = await store.getAttachments(note.id);
     expect(atts.length).toBe(1);
     expect(atts[0].mimeType).toBe("image/png");
   });
 
-  test("starts with no tags", () => {
-    const tags = store.listTags();
+  test("starts with no tags", async () => {
+    const tags = await store.listTags();
     expect(tags.length).toBe(0);
   });
 
-  test("gets note by path", () => {
-    store.createNote("README content", { path: "Projects/Parachute/README" });
-    const note = store.getNoteByPath("Projects/Parachute/README");
+  test("gets note by path", async () => {
+    await store.createNote("README content", { path: "Projects/Parachute/README" });
+    const note = await store.getNoteByPath("Projects/Parachute/README");
     expect(note).not.toBeNull();
     expect(note!.content).toBe("README content");
     expect(note!.path).toBe("Projects/Parachute/README");
   });
 
-  test("gets multiple notes by IDs", () => {
-    const a = store.createNote("A");
-    const b = store.createNote("B");
-    const c = store.createNote("C");
+  test("gets multiple notes by IDs", async () => {
+    const a = await store.createNote("A");
+    const b = await store.createNote("B");
+    const c = await store.createNote("C");
 
-    const fetched = store.getNotes([a.id, c.id]);
+    const fetched = await store.getNotes([a.id, c.id]);
     expect(fetched.length).toBe(2);
     expect(fetched.map((n) => n.content)).toContain("A");
     expect(fetched.map((n) => n.content)).toContain("C");
   });
 
-  test("queries by path prefix", () => {
-    store.createNote("Root README", { path: "README" });
-    store.createNote("Project README", { path: "Projects/Parachute/README" });
-    store.createNote("Project Notes", { path: "Projects/Parachute/Notes" });
-    store.createNote("Other", { path: "Other/Stuff" });
+  test("queries by path prefix", async () => {
+    await store.createNote("Root README", { path: "README" });
+    await store.createNote("Project README", { path: "Projects/Parachute/README" });
+    await store.createNote("Project Notes", { path: "Projects/Parachute/Notes" });
+    await store.createNote("Other", { path: "Other/Stuff" });
 
-    const results = store.queryNotes({ pathPrefix: "Projects/Parachute" });
+    const results = await store.queryNotes({ pathPrefix: "Projects/Parachute" });
     expect(results.length).toBe(2);
     expect(results.map((n) => n.path)).toContain("Projects/Parachute/README");
     expect(results.map((n) => n.path)).toContain("Projects/Parachute/Notes");
   });
 });
 
-describe("metadata", () => {
-  test("creates note with metadata", () => {
-    const note = store.createNote("Meeting notes", {
+describe("metadata", async () => {
+  test("creates note with metadata", async () => {
+    const note = await store.createNote("Meeting notes", {
       path: "Meetings/standup",
       metadata: { status: "draft", priority: "high", attendees: ["alice", "bob"] },
     });
@@ -240,35 +240,35 @@ describe("metadata", () => {
     expect(note.metadata!.attendees).toEqual(["alice", "bob"]);
   });
 
-  test("updates note metadata", () => {
-    const note = store.createNote("Doc", { metadata: { status: "draft" } });
-    const updated = store.updateNote(note.id, { metadata: { status: "published", version: 2 } });
+  test("updates note metadata", async () => {
+    const note = await store.createNote("Doc", { metadata: { status: "draft" } });
+    const updated = await store.updateNote(note.id, { metadata: { status: "published", version: 2 } });
     expect(updated.metadata!.status).toBe("published");
     expect(updated.metadata!.version).toBe(2);
   });
 
-  test("queries notes by metadata", () => {
-    store.createNote("Draft 1", { metadata: { status: "draft" } });
-    store.createNote("Draft 2", { metadata: { status: "draft" } });
-    store.createNote("Published", { metadata: { status: "published" } });
+  test("queries notes by metadata", async () => {
+    await store.createNote("Draft 1", { metadata: { status: "draft" } });
+    await store.createNote("Draft 2", { metadata: { status: "draft" } });
+    await store.createNote("Published", { metadata: { status: "published" } });
 
-    const drafts = store.queryNotes({ metadata: { status: "draft" } });
+    const drafts = await store.queryNotes({ metadata: { status: "draft" } });
     expect(drafts.length).toBe(2);
 
-    const published = store.queryNotes({ metadata: { status: "published" } });
+    const published = await store.queryNotes({ metadata: { status: "published" } });
     expect(published.length).toBe(1);
     expect(published[0].content).toBe("Published");
   });
 
-  test("notes without metadata return undefined metadata", () => {
-    const note = store.createNote("Plain note");
+  test("notes without metadata return undefined metadata", async () => {
+    const note = await store.createNote("Plain note");
     expect(note.metadata).toBeUndefined();
   });
 
-  test("creates link with metadata", () => {
-    const a = store.createNote("A");
-    const b = store.createNote("B");
-    const link = store.createLink(a.id, b.id, "related-to", {
+  test("creates link with metadata", async () => {
+    const a = await store.createNote("A");
+    const b = await store.createNote("B");
+    const link = await store.createLink(a.id, b.id, "related-to", {
       confidence: 0.9,
       context: "mentioned in meeting",
     });
@@ -277,10 +277,10 @@ describe("metadata", () => {
     expect(link.metadata!.context).toBe("mentioned in meeting");
   });
 
-  test("hydrated links include note metadata", () => {
-    const a = store.createNote("A", { metadata: { type: "project" } });
-    const b = store.createNote("B", { metadata: { type: "task" } });
-    store.createLink(a.id, b.id, "contains");
+  test("hydrated links include note metadata", async () => {
+    const a = await store.createNote("A", { metadata: { type: "project" } });
+    const b = await store.createNote("B", { metadata: { type: "task" } });
+    await store.createLink(a.id, b.id, "contains");
 
     const links = getLinksHydrated(db, a.id);
     expect(links[0].sourceNote?.metadata?.type).toBe("project");
@@ -288,9 +288,9 @@ describe("metadata", () => {
   });
 });
 
-describe("bulk operations", () => {
-  test("creates multiple notes at once", () => {
-    const notes = store.createNotes([
+describe("bulk operations", async () => {
+  test("creates multiple notes at once", async () => {
+    const notes = await store.createNotes([
       { content: "Note 1", tags: ["daily"] },
       { content: "Note 2", tags: ["doc"] },
       { content: "Note 3" },
@@ -300,8 +300,8 @@ describe("bulk operations", () => {
     expect(notes[1].tags).toContain("doc");
   });
 
-  test("createNotes accepts per-note metadata and created_at (mixed batch)", () => {
-    const notes = store.createNotes([
+  test("createNotes accepts per-note metadata and created_at (mixed batch)", async () => {
+    const notes = await store.createNotes([
       { content: "Plain", tags: ["daily"] },
       {
         content: "With metadata",
@@ -331,7 +331,7 @@ describe("bulk operations", () => {
     expect(notes[2].metadata?.source).toBe("tana-import");
   });
 
-  test("createNotes preserves per-note metadata isolation across many notes", () => {
+  test("createNotes preserves per-note metadata isolation across many notes", async () => {
     const inputs = Array.from({ length: 5 }, (_, i) => ({
       content: `Day ${i}`,
       path: `Journal/2024-06-${String(i + 1).padStart(2, "0")}`,
@@ -343,7 +343,7 @@ describe("bulk operations", () => {
       },
       created_at: `2024-06-${String(i + 1).padStart(2, "0")}T12:00:00.000Z`,
     }));
-    const notes = store.createNotes(inputs);
+    const notes = await store.createNotes(inputs);
     expect(notes.length).toBe(5);
     for (let i = 0; i < 5; i++) {
       expect(notes[i].path).toBe(`Journal/2024-06-${String(i + 1).padStart(2, "0")}`);
@@ -354,9 +354,9 @@ describe("bulk operations", () => {
     }
   });
 
-  test("createNotes is backwards compatible — omitted metadata/created_at use defaults", () => {
+  test("createNotes is backwards compatible — omitted metadata/created_at use defaults", async () => {
     const before = new Date().toISOString();
-    const notes = store.createNotes([
+    const notes = await store.createNotes([
       { content: "Just content" },
       { content: "Content + tags", tags: ["x"] },
     ]);
@@ -368,89 +368,89 @@ describe("bulk operations", () => {
     expect(notes[0].createdAt <= after).toBe(true);
   });
 
-  test("batch tags multiple notes", () => {
-    const a = store.createNote("A");
-    const b = store.createNote("B");
-    const c = store.createNote("C");
+  test("batch tags multiple notes", async () => {
+    const a = await store.createNote("A");
+    const b = await store.createNote("B");
+    const c = await store.createNote("C");
 
-    store.batchTag([a.id, b.id, c.id], ["important", "review"]);
+    await store.batchTag([a.id, b.id, c.id], ["important", "review"]);
 
-    expect(store.getNote(a.id)!.tags).toContain("important");
-    expect(store.getNote(b.id)!.tags).toContain("review");
-    expect(store.getNote(c.id)!.tags).toContain("important");
+    expect((await store.getNote(a.id))!.tags).toContain("important");
+    expect((await store.getNote(b.id))!.tags).toContain("review");
+    expect((await store.getNote(c.id))!.tags).toContain("important");
   });
 
-  test("batch untags multiple notes", () => {
-    const a = store.createNote("A", { tags: ["daily", "pinned"] });
-    const b = store.createNote("B", { tags: ["daily", "pinned"] });
+  test("batch untags multiple notes", async () => {
+    const a = await store.createNote("A", { tags: ["daily", "pinned"] });
+    const b = await store.createNote("B", { tags: ["daily", "pinned"] });
 
-    store.batchUntag([a.id, b.id], ["pinned"]);
+    await store.batchUntag([a.id, b.id], ["pinned"]);
 
-    expect(store.getNote(a.id)!.tags).toContain("daily");
-    expect(store.getNote(a.id)!.tags).not.toContain("pinned");
-    expect(store.getNote(b.id)!.tags).not.toContain("pinned");
+    expect((await store.getNote(a.id))!.tags).toContain("daily");
+    expect((await store.getNote(a.id))!.tags).not.toContain("pinned");
+    expect((await store.getNote(b.id))!.tags).not.toContain("pinned");
   });
 });
 
-describe("deeper link queries", () => {
-  test("traverses links multi-hop", () => {
-    const a = store.createNote("A");
-    const b = store.createNote("B");
-    const c = store.createNote("C");
-    const d = store.createNote("D");
+describe("deeper link queries", async () => {
+  test("traverses links multi-hop", async () => {
+    const a = await store.createNote("A");
+    const b = await store.createNote("B");
+    const c = await store.createNote("C");
+    const d = await store.createNote("D");
 
-    store.createLink(a.id, b.id, "related-to");
-    store.createLink(b.id, c.id, "related-to");
-    store.createLink(c.id, d.id, "related-to");
+    await store.createLink(a.id, b.id, "related-to");
+    await store.createLink(b.id, c.id, "related-to");
+    await store.createLink(c.id, d.id, "related-to");
 
     // 1 hop from A: should find B
-    const hop1 = store.traverseLinks(a.id, { max_depth: 1 });
+    const hop1 = await store.traverseLinks(a.id, { max_depth: 1 });
     expect(hop1.length).toBe(1);
     expect(hop1[0].noteId).toBe(b.id);
 
     // 2 hops from A: should find B and C
-    const hop2 = store.traverseLinks(a.id, { max_depth: 2 });
+    const hop2 = await store.traverseLinks(a.id, { max_depth: 2 });
     expect(hop2.length).toBe(2);
     const ids2 = hop2.map((n) => n.noteId);
     expect(ids2).toContain(b.id);
     expect(ids2).toContain(c.id);
 
     // 3 hops from A: should find B, C, and D
-    const hop3 = store.traverseLinks(a.id, { max_depth: 3 });
+    const hop3 = await store.traverseLinks(a.id, { max_depth: 3 });
     expect(hop3.length).toBe(3);
   });
 
-  test("traverses with relationship filter", () => {
-    const a = store.createNote("A");
-    const b = store.createNote("B");
-    const c = store.createNote("C");
+  test("traverses with relationship filter", async () => {
+    const a = await store.createNote("A");
+    const b = await store.createNote("B");
+    const c = await store.createNote("C");
 
-    store.createLink(a.id, b.id, "mentions");
-    store.createLink(a.id, c.id, "related-to");
+    await store.createLink(a.id, b.id, "mentions");
+    await store.createLink(a.id, c.id, "related-to");
 
-    const mentions = store.traverseLinks(a.id, { max_depth: 1, relationship: "mentions" });
+    const mentions = await store.traverseLinks(a.id, { max_depth: 1, relationship: "mentions" });
     expect(mentions.length).toBe(1);
     expect(mentions[0].noteId).toBe(b.id);
   });
 
-  test("finds path between notes", () => {
-    const a = store.createNote("A");
-    const b = store.createNote("B");
-    const c = store.createNote("C");
+  test("finds path between notes", async () => {
+    const a = await store.createNote("A");
+    const b = await store.createNote("B");
+    const c = await store.createNote("C");
 
-    store.createLink(a.id, b.id, "related-to");
-    store.createLink(b.id, c.id, "mentions");
+    await store.createLink(a.id, b.id, "related-to");
+    await store.createLink(b.id, c.id, "mentions");
 
-    const result = store.findPath(a.id, c.id);
+    const result = await store.findPath(a.id, c.id);
     expect(result).not.toBeNull();
     expect(result!.path).toEqual([a.id, b.id, c.id]);
     expect(result!.relationships).toEqual(["related-to", "mentions"]);
   });
 
-  test("get-links returns hydrated note summaries", () => {
-    const a = store.createNote("Note A", { path: "a", tags: ["important"] });
-    const b = store.createNote("Note B", { path: "b" });
-    store.createLink(a.id, b.id, "related-to");
+  test("get-links returns hydrated note summaries", async () => {
+    const a = await store.createNote("Note A", { path: "a", tags: ["important"] });
+    const b = await store.createNote("Note B", { path: "b" });
+    await store.createLink(a.id, b.id, "related-to");
 
     const result = getLinksHydrated(db, a.id);
     expect(result.length).toBe(1);
@@ -459,17 +459,17 @@ describe("deeper link queries", () => {
     expect(result[0].sourceNote?.tags).toContain("important");
   });
 
-  test("returns null when no path exists", () => {
-    const a = store.createNote("A");
-    const b = store.createNote("B");
+  test("returns null when no path exists", async () => {
+    const a = await store.createNote("A");
+    const b = await store.createNote("B");
     // No link between them
 
-    const result = store.findPath(a.id, b.id);
+    const result = await store.findPath(a.id, b.id);
     expect(result).toBeNull();
   });
 });
 
-describe("MCP tools", () => {
+describe("MCP tools", async () => {
   test("generates all 9 core tools", () => {
     const tools = generateMcpTools(store);
     expect(tools.length).toBe(9);
@@ -486,29 +486,29 @@ describe("MCP tools", () => {
     expect(names).toContain("vault-info");
   });
 
-  test("query-notes by id works", () => {
+  test("query-notes by id works", async () => {
     const tools = generateMcpTools(store);
-    const note = store.createNote("By ID", { path: "test/note" });
+    const note = await store.createNote("By ID", { path: "test/note" });
 
     const query = tools.find((t) => t.name === "query-notes")!;
-    const result = query.execute({ id: note.id }) as any;
+    const result = await query.execute({ id: note.id }) as any;
     expect(result.content).toBe("By ID");
     expect(result.path).toBe("test/note");
   });
 
-  test("query-notes by path works", () => {
+  test("query-notes by path works", async () => {
     const tools = generateMcpTools(store);
-    store.createNote("By Path", { path: "Projects/README" });
+    await store.createNote("By Path", { path: "Projects/README" });
 
     const query = tools.find((t) => t.name === "query-notes")!;
-    const result = query.execute({ id: "Projects/README" }) as any;
+    const result = await query.execute({ id: "Projects/README" }) as any;
     expect(result.content).toBe("By Path");
   });
 
-  test("create-note tool works via execute", () => {
+  test("create-note tool works via execute", async () => {
     const tools = generateMcpTools(store);
     const createNote = tools.find((t) => t.name === "create-note")!;
-    const result = createNote.execute({ content: "MCP note", tags: ["daily"] }) as any;
+    const result = await createNote.execute({ content: "MCP note", tags: ["daily"] }) as any;
     expect(result.content).toBe("MCP note");
     expect(result.tags).toContain("daily");
   });
@@ -522,7 +522,7 @@ describe("MCP tools", () => {
   });
 });
 
-describe("unified MCP wrapper", () => {
+describe("unified MCP wrapper", async () => {
   test("vault-info routes through vault param", async () => {
     const { generateUnifiedMcpTools } = await import("./mcp-tools.ts");
     const { writeVaultConfig, writeGlobalConfig } = await import("./config.ts");
@@ -538,14 +538,14 @@ describe("unified MCP wrapper", () => {
     writeGlobalConfig({ port: 1940, default_vault: vaultName });
 
     const vaultStore = getVaultStore(vaultName);
-    vaultStore.createNote("alpha", { tags: ["x", "y"] });
-    vaultStore.createNote("beta", { tags: ["x"] });
+    await vaultStore.createNote("alpha", { tags: ["x", "y"] });
+    await vaultStore.createNote("beta", { tags: ["x"] });
 
     const tools = generateUnifiedMcpTools();
     const vaultInfo = tools.find((t) => t.name === "vault-info");
     expect(vaultInfo).toBeTruthy();
 
-    const result = vaultInfo!.execute({ vault: vaultName, include_stats: true }) as any;
+    const result = await vaultInfo!.execute({ vault: vaultName, include_stats: true }) as any;
     expect(result.name).toBe(vaultName);
     expect(result.description).toBe("Test vault");
     expect(result.stats.totalNotes).toBe(2);
@@ -568,8 +568,8 @@ describe("unified MCP wrapper", () => {
     writeGlobalConfig({ port: 1940, default_vault: vaultName });
 
     const vaultStore = getVaultStore(vaultName);
-    vaultStore.createNote("A", { tags: ["person"] });
-    vaultStore.upsertTagSchema("person", {
+    await vaultStore.createNote("A", { tags: ["person"] });
+    await vaultStore.upsertTagSchema("person", {
       description: "A person",
       fields: { name: { type: "string", description: "Full name" } },
     });
@@ -578,7 +578,7 @@ describe("unified MCP wrapper", () => {
 
     // list-tags with tag param for single tag detail
     const listTags = tools.find((t) => t.name === "list-tags")!;
-    const detail = listTags.execute({ vault: vaultName, tag: "person" }) as any;
+    const detail = await listTags.execute({ vault: vaultName, tag: "person" }) as any;
     expect(detail.name).toBe("person");
     expect(detail.count).toBe(1);
     expect(detail.description).toBe("A person");
@@ -601,7 +601,7 @@ describe("unified MCP wrapper", () => {
     writeGlobalConfig({ port: 1940, default_vault: vaultName });
 
     const vaultStore = getVaultStore(vaultName);
-    vaultStore.upsertTagSchema("person", {
+    await vaultStore.upsertTagSchema("person", {
       description: "A person",
       fields: {
         first_appeared: { type: "string", description: "When" },
@@ -614,7 +614,7 @@ describe("unified MCP wrapper", () => {
     const queryNotes = tools.find((t) => t.name === "query-notes")!;
 
     // Create a note tagged person with no metadata — defaults auto-populated
-    const result = createNote.execute({
+    const result = await createNote.execute({
       vault: vaultName,
       content: "Alice",
       tags: ["person"],
@@ -622,18 +622,18 @@ describe("unified MCP wrapper", () => {
     expect(result.content).toBe("Alice");
 
     // Verify defaults were written
-    const fresh = queryNotes.execute({ vault: vaultName, id: result.id }) as any;
+    const fresh = await queryNotes.execute({ vault: vaultName, id: result.id }) as any;
     expect(fresh.metadata.first_appeared).toBe("");
     expect(fresh.metadata.relationship).toBe("");
 
     // Create with explicit metadata — preserved
-    const result2 = createNote.execute({
+    const result2 = await createNote.execute({
       vault: vaultName,
       content: "Bob",
       tags: ["person"],
       metadata: { first_appeared: "2024-01", relationship: "friend" },
     }) as any;
-    const fresh2 = queryNotes.execute({ vault: vaultName, id: result2.id }) as any;
+    const fresh2 = await queryNotes.execute({ vault: vaultName, id: result2.id }) as any;
     expect(fresh2.metadata.first_appeared).toBe("2024-01");
     expect(fresh2.metadata.relationship).toBe("friend");
 
@@ -654,14 +654,14 @@ describe("unified MCP wrapper", () => {
     writeGlobalConfig({ port: 1940, default_vault: vaultName });
 
     const vaultStore = getVaultStore(vaultName);
-    vaultStore.upsertTagSchema("person", {
+    await vaultStore.upsertTagSchema("person", {
       description: "A person",
       fields: {
         first_appeared: { type: "string", description: "When" },
         relationship: { type: "string", description: "How" },
       },
     });
-    vaultStore.upsertTagSchema("project", {
+    await vaultStore.upsertTagSchema("project", {
       description: "A project",
       fields: {
         status: { type: "string", enum: ["active", "completed", "abandoned"], description: "Status" },
@@ -675,35 +675,35 @@ describe("unified MCP wrapper", () => {
     const queryNotes = tools.find((t) => t.name === "query-notes")!;
 
     // Create a note, then add #person tag via update-note
-    const note = createNote.execute({ vault: vaultName, content: "Alice" }) as any;
-    updateNote.execute({ vault: vaultName, id: note.id, tags: { add: ["person"] } });
-    const after = queryNotes.execute({ vault: vaultName, id: note.id }) as any;
+    const note = await createNote.execute({ vault: vaultName, content: "Alice" }) as any;
+    await updateNote.execute({ vault: vaultName, id: note.id, tags: { add: ["person"] } });
+    const after = await queryNotes.execute({ vault: vaultName, id: note.id }) as any;
     expect(after.metadata.first_appeared).toBe("");
     expect(after.metadata.relationship).toBe("");
 
     // Tag note that already has partial metadata — only missing fields populated
-    const note2 = createNote.execute({
+    const note2 = await createNote.execute({
       vault: vaultName,
       content: "Bob",
       metadata: { first_appeared: "2023-11" },
     }) as any;
-    updateNote.execute({ vault: vaultName, id: note2.id, tags: { add: ["person"] } });
-    const after2 = queryNotes.execute({ vault: vaultName, id: note2.id }) as any;
+    await updateNote.execute({ vault: vaultName, id: note2.id, tags: { add: ["person"] } });
+    const after2 = await queryNotes.execute({ vault: vaultName, id: note2.id }) as any;
     expect(after2.metadata.first_appeared).toBe("2023-11"); // preserved
     expect(after2.metadata.relationship).toBe(""); // added
 
     // Tag with #project — enum defaults to first value, boolean to false, integer to 0
-    const note4 = createNote.execute({ vault: vaultName, content: "My Project" }) as any;
-    updateNote.execute({ vault: vaultName, id: note4.id, tags: { add: ["project"] } });
-    const after4 = queryNotes.execute({ vault: vaultName, id: note4.id }) as any;
+    const note4 = await createNote.execute({ vault: vaultName, content: "My Project" }) as any;
+    await updateNote.execute({ vault: vaultName, id: note4.id, tags: { add: ["project"] } });
+    const after4 = await queryNotes.execute({ vault: vaultName, id: note4.id }) as any;
     expect(after4.metadata.status).toBe("active");
     expect(after4.metadata.active).toBe(false);
     expect(after4.metadata.priority).toBe(0);
 
     // Multiple schema tags at once — all defaults merged
-    const note5 = createNote.execute({ vault: vaultName, content: "Multi" }) as any;
-    updateNote.execute({ vault: vaultName, id: note5.id, tags: { add: ["person", "project"] } });
-    const after5 = queryNotes.execute({ vault: vaultName, id: note5.id }) as any;
+    const note5 = await createNote.execute({ vault: vaultName, content: "Multi" }) as any;
+    await updateNote.execute({ vault: vaultName, id: note5.id, tags: { add: ["person", "project"] } });
+    const after5 = await queryNotes.execute({ vault: vaultName, id: note5.id }) as any;
     expect(after5.metadata.first_appeared).toBe("");
     expect(after5.metadata.relationship).toBe("");
     expect(after5.metadata.status).toBe("active");
@@ -726,7 +726,7 @@ describe("unified MCP wrapper", () => {
     writeGlobalConfig({ port: 1940, default_vault: vaultName });
 
     const vaultStore = getVaultStore(vaultName);
-    vaultStore.upsertTagSchema("person", {
+    await vaultStore.upsertTagSchema("person", {
       description: "A person",
       fields: { name: { type: "string" } },
     });
@@ -736,10 +736,10 @@ describe("unified MCP wrapper", () => {
     const updateNote = tools.find((t) => t.name === "update-note")!;
     const queryNotes = tools.find((t) => t.name === "query-notes")!;
 
-    const note = createNote.execute({ vault: vaultName, content: "Test" }) as any;
+    const note = await createNote.execute({ vault: vaultName, content: "Test" }) as any;
     const originalUpdatedAt = note.updatedAt;
-    updateNote.execute({ vault: vaultName, id: note.id, tags: { add: ["person"] } });
-    const after = queryNotes.execute({ vault: vaultName, id: note.id }) as any;
+    await updateNote.execute({ vault: vaultName, id: note.id, tags: { add: ["person"] } });
+    const after = await queryNotes.execute({ vault: vaultName, id: note.id }) as any;
     expect(after.updatedAt).toBe(originalUpdatedAt);
     expect(after.metadata.name).toBe("");
 
@@ -807,10 +807,10 @@ function mkReq(method: string, path: string, body?: unknown): Request {
   return new Request(`${BASE}${path}`, init);
 }
 
-describe("HTTP /notes", () => {
+describe("HTTP /notes", async () => {
   test("GET /notes defaults to lean index (no content field)", async () => {
-    store.createNote("one content", { path: "a", tags: ["t"] });
-    store.createNote("two content", { path: "b", tags: ["t"] });
+    await store.createNote("one content", { path: "a", tags: ["t"] });
+    await store.createNote("two content", { path: "b", tags: ["t"] });
     const res = await handleNotes(mkReq("GET", "/notes"), store, "");
     const body = await res.json() as any[];
     expect(body).toHaveLength(2);
@@ -820,22 +820,22 @@ describe("HTTP /notes", () => {
   });
 
   test("GET /notes?include_content=true returns full notes", async () => {
-    store.createNote("full body", { path: "a" });
+    await store.createNote("full body", { path: "a" });
     const res = await handleNotes(mkReq("GET", "/notes?include_content=true"), store, "");
     const body = await res.json() as any[];
     expect(body[0].content).toBe("full body");
   });
 
   test("GET /notes?search=fox full-text search", async () => {
-    store.createNote("The quick brown fox");
-    store.createNote("A lazy dog");
+    await store.createNote("The quick brown fox");
+    await store.createNote("A lazy dog");
     const res = await handleNotes(mkReq("GET", "/notes?search=fox"), store, "");
     const body = await res.json() as any[];
     expect(body).toHaveLength(1);
   });
 
   test("GET /notes?search=fox&include_metadata=false strips metadata from search results", async () => {
-    store.createNote("The quick brown fox", { metadata: { summary: "animal" } });
+    await store.createNote("The quick brown fox", { metadata: { summary: "animal" } });
     const res = await handleNotes(mkReq("GET", "/notes?search=fox&include_metadata=false"), store, "");
     const body = await res.json() as any[];
     expect(body).toHaveLength(1);
@@ -843,14 +843,14 @@ describe("HTTP /notes", () => {
   });
 
   test("GET /notes/:id defaults to full content", async () => {
-    const n = store.createNote("hello", { id: "x" });
+    const n = await store.createNote("hello", { id: "x" });
     const res = await handleNotes(mkReq("GET", "/notes/x"), store, "/x");
     const body = await res.json() as any;
     expect(body.content).toBe("hello");
   });
 
   test("GET /notes/:id?include_content=false returns lean shape", async () => {
-    store.createNote("hello", { id: "x" });
+    await store.createNote("hello", { id: "x" });
     const res = await handleNotes(mkReq("GET", "/notes/x?include_content=false"), store, "/x");
     const body = await res.json() as any;
     expect(body).not.toHaveProperty("content");
@@ -859,8 +859,8 @@ describe("HTTP /notes", () => {
   });
 
   test("GET /notes?include_metadata=false strips metadata from list", async () => {
-    store.createNote("a", { tags: ["m"], metadata: { summary: "hello", status: "ok" } });
-    store.createNote("b", { tags: ["m"], metadata: { summary: "world" } });
+    await store.createNote("a", { tags: ["m"], metadata: { summary: "hello", status: "ok" } });
+    await store.createNote("b", { tags: ["m"], metadata: { summary: "world" } });
     const res = await handleNotes(mkReq("GET", "/notes?tag=m&include_metadata=false"), store, "");
     const body = await res.json() as any[];
     expect(body).toHaveLength(2);
@@ -870,7 +870,7 @@ describe("HTTP /notes", () => {
   });
 
   test("GET /notes?include_metadata=summary,status returns only those fields", async () => {
-    store.createNote("a", { tags: ["mf"], metadata: { summary: "hello", status: "ok", extra: true } });
+    await store.createNote("a", { tags: ["mf"], metadata: { summary: "hello", status: "ok", extra: true } });
     const res = await handleNotes(mkReq("GET", "/notes?tag=mf&include_metadata=summary,status"), store, "");
     const body = await res.json() as any[];
     expect(body).toHaveLength(1);
@@ -878,7 +878,7 @@ describe("HTTP /notes", () => {
   });
 
   test("GET /notes/:id?include_metadata=false strips metadata from single note", async () => {
-    store.createNote("hello", { id: "xm", metadata: { summary: "s" } });
+    await store.createNote("hello", { id: "xm", metadata: { summary: "s" } });
     const res = await handleNotes(mkReq("GET", "/notes/xm?include_metadata=false"), store, "/xm");
     const body = await res.json() as any;
     expect(body.metadata).toBeUndefined();
@@ -886,12 +886,61 @@ describe("HTTP /notes", () => {
   });
 
   test("GET /notes/:id?include_metadata=summary returns only specified fields", async () => {
-    store.createNote("hello", { id: "xm2", metadata: { summary: "s", status: "draft" } });
+    await store.createNote("hello", { id: "xm2", metadata: { summary: "s", status: "draft" } });
     const res = await handleNotes(mkReq("GET", "/notes/xm2?include_metadata=summary"), store, "/xm2");
     const body = await res.json() as any;
     expect(body.metadata).toEqual({ summary: "s" });
   });
 
+  test("GET /notes/:id?expand_links=true inlines wikilink content", async () => {
+    await store.createNote("target body", { path: "Target" });
+    await store.createNote("see [[Target]]", { id: "src", path: "Src" });
+    const res = await handleNotes(
+      mkReq("GET", "/notes/src?expand_links=true"),
+      store,
+      "/src",
+    );
+    const body = await res.json() as any;
+    expect(body.content).toContain('<expanded path="Target" mode="full">');
+    expect(body.content).toContain("target body");
+  });
+
+  test("GET /notes/:id?expand_links=true&expand_mode=summary inlines metadata.summary only", async () => {
+    await store.createNote("long body", {
+      path: "T",
+      metadata: { summary: "short" },
+    });
+    await store.createNote("see [[T]]", { id: "sx", path: "Sx" });
+    const res = await handleNotes(
+      mkReq("GET", "/notes/sx?expand_links=true&expand_mode=summary"),
+      store,
+      "/sx",
+    );
+    const body = await res.json() as any;
+    expect(body.content).toContain('mode="summary"');
+    expect(body.content).toContain("short");
+    expect(body.content).not.toContain("long body");
+  });
+
+  test("GET /notes?tag=&include_content=true&expand_links=true expands per-note with cross-note dedup", async () => {
+    await store.createNote("shared body", { path: "Shared" });
+    await store.createNote("first [[Shared]]", { path: "A", tags: ["el"] });
+    await store.createNote("second [[Shared]]", { path: "B", tags: ["el"] });
+    const res = await handleNotes(
+      mkReq("GET", "/notes?tag=el&include_content=true&expand_links=true&sort=asc"),
+      store,
+      "",
+    );
+    const body = await res.json() as any[];
+    expect(body).toHaveLength(2);
+    const expandedBlocks = body
+      .map((n: any) => (n.content.match(/<expanded /g) ?? []).length)
+      .reduce((a: number, b: number) => a + b, 0);
+    expect(expandedBlocks).toBe(1);
+    const withMarker = body.find((n: any) => n.content.includes("(expanded above)"));
+    expect(withMarker).toBeTruthy();
+  });
+
   test("POST /notes accepts createdAt (camelCase) in body", async () => {
     const res = await handleNotes(
       mkReq("POST", "/notes", { content: "hi", createdAt: "2025-01-01T00:00:00.000Z" }),
@@ -903,7 +952,7 @@ describe("HTTP /notes", () => {
   });
 
   test("POST /notes/:id/attachments accepts mimeType (camelCase) in body", async () => {
-    const n = store.createNote("x", { id: "x" });
+    const n = await store.createNote("x", { id: "x" });
     const res = await handleNotes(
       mkReq("POST", "/notes/x/attachments", { path: "files/a.png", mimeType: "image/png" }),
       store,
@@ -915,13 +964,13 @@ describe("HTTP /notes", () => {
   });
 });
 
-describe("HTTP GET /notes?format=graph", () => {
+describe("HTTP GET /notes?format=graph", async () => {
   test("returns nodes and edges for linked notes", async () => {
-    const a = store.createNote("A", { id: "a", path: "People/Alice", tags: ["person"] });
-    const b = store.createNote("B", { id: "b", path: "People/Bob", tags: ["person"] });
-    const c = store.createNote("C", { id: "c", path: "Projects/X" });
-    store.createLink("a", "b", "knows");
-    store.createLink("a", "c", "works-on");
+    const a = await store.createNote("A", { id: "a", path: "People/Alice", tags: ["person"] });
+    const b = await store.createNote("B", { id: "b", path: "People/Bob", tags: ["person"] });
+    const c = await store.createNote("C", { id: "c", path: "Projects/X" });
+    await store.createLink("a", "b", "knows");
+    await store.createLink("a", "c", "works-on");
 
     const res = await handleNotes(
       mkReq("GET", "/notes?format=graph&include_links=true"),
@@ -941,9 +990,9 @@ describe("HTTP GET /notes?format=graph", () => {
   });
 
   test("returns empty edges when include_links is not set", async () => {
-    store.createNote("A", { id: "a" });
-    store.createNote("B", { id: "b" });
-    store.createLink("a", "b", "ref");
+    await store.createNote("A", { id: "a" });
+    await store.createNote("B", { id: "b" });
+    await store.createLink("a", "b", "ref");
 
     const res = await handleNotes(
       mkReq("GET", "/notes?format=graph"),
@@ -956,12 +1005,12 @@ describe("HTTP GET /notes?format=graph", () => {
   });
 
   test("composes with near param for subgraph", async () => {
-    const a = store.createNote("A", { id: "a", path: "People/Mickey" });
-    const b = store.createNote("B", { id: "b" });
-    const c = store.createNote("C", { id: "c" });
-    const d = store.createNote("D", { id: "d" }); // not connected
-    store.createLink("a", "b", "knows");
-    store.createLink("b", "c", "knows");
+    const a = await store.createNote("A", { id: "a", path: "People/Mickey" });
+    const b = await store.createNote("B", { id: "b" });
+    const c = await store.createNote("C", { id: "c" });
+    const d = await store.createNote("D", { id: "d" }); // not connected
+    await store.createLink("a", "b", "knows");
+    await store.createLink("b", "c", "knows");
 
     const res = await handleNotes(
       mkReq("GET", "/notes?format=graph&include_links=true&near[note_id]=People/Mickey&near[depth]=2"),
@@ -976,11 +1025,11 @@ describe("HTTP GET /notes?format=graph", () => {
   });
 
   test("near with depth=1 limits subgraph", async () => {
-    const a = store.createNote("A", { id: "a" });
-    const b = store.createNote("B", { id: "b" });
-    const c = store.createNote("C", { id: "c" });
-    store.createLink("a", "b", "ref");
-    store.createLink("b", "c", "ref");
+    const a = await store.createNote("A", { id: "a" });
+    const b = await store.createNote("B", { id: "b" });
+    const c = await store.createNote("C", { id: "c" });
+    await store.createLink("a", "b", "ref");
+    await store.createLink("b", "c", "ref");
 
     const res = await handleNotes(
       mkReq("GET", "/notes?format=graph&include_links=true&near[note_id]=a&near[depth]=1"),
@@ -995,9 +1044,9 @@ describe("HTTP GET /notes?format=graph", () => {
   });
 });
 
-describe("HTTP PATCH /notes/:idOrPath (update)", () => {
+describe("HTTP PATCH /notes/:idOrPath (update)", async () => {
   test("PATCH updates content and merges metadata", async () => {
-    const note = store.createNote("original", { id: "x", metadata: { a: 1 } });
+    const note = await store.createNote("original", { id: "x", metadata: { a: 1 } });
     const res = await handleNotes(
       mkReq("PATCH", "/notes/x", { content: "updated", metadata: { b: 2 } }),
       store,
@@ -1009,7 +1058,7 @@ describe("HTTP PATCH /notes/:idOrPath (update)", () => {
   });
 
   test("PATCH adds/removes tags", async () => {
-    store.createNote("x", { id: "x", tags: ["old"] });
+    await store.createNote("x", { id: "x", tags: ["old"] });
     const res = await handleNotes(
       mkReq("PATCH", "/notes/x", { tags: { add: ["new"], remove: ["old"] } }),
       store,
@@ -1021,15 +1070,15 @@ describe("HTTP PATCH /notes/:idOrPath (update)", () => {
   });
 
   test("PATCH adds/removes links", async () => {
-    store.createNote("a", { id: "a" });
-    store.createNote("b", { id: "b" });
+    await store.createNote("a", { id: "a" });
+    await store.createNote("b", { id: "b" });
     const res = await handleNotes(
       mkReq("PATCH", "/notes/a", { links: { add: [{ target: "b", relationship: "mentions" }] } }),
       store,
       "/a",
     );
     expect(res.status).toBe(200);
-    const links = store.getLinks("a", { direction: "outbound" });
+    const links = await store.getLinks("a", { direction: "outbound" });
     expect(links).toHaveLength(1);
 
     // Remove
@@ -1038,11 +1087,11 @@ describe("HTTP PATCH /notes/:idOrPath (update)", () => {
       store,
       "/a",
     );
-    expect(store.getLinks("a", { direction: "outbound" })).toHaveLength(0);
+    expect(await store.getLinks("a", { direction: "outbound" })).toHaveLength(0);
   });
 
   test("PATCH resolves note by path", async () => {
-    store.createNote("x", { path: "Projects/README" });
+    await store.createNote("x", { path: "Projects/README" });
     const res = await handleNotes(
       mkReq("PATCH", `/notes/${encodeURIComponent("Projects/README")}`, { content: "updated" }),
       store,
@@ -1052,8 +1101,53 @@ describe("HTTP PATCH /notes/:idOrPath (update)", () => {
     expect(body.content).toBe("updated");
   });
 
+  test("PATCH with matching if_updated_at succeeds", async () => {
+    const note = await store.createNote("first", { id: "x" });
+    // First bump — sets updated_at
+    const first = await handleNotes(
+      mkReq("PATCH", "/notes/x", { content: "second" }),
+      store,
+      "/x",
+    );
+    const firstBody = await first.json() as any;
+    expect(firstBody.updatedAt).toBeTruthy();
+
+    const res = await handleNotes(
+      mkReq("PATCH", "/notes/x", { content: "third", if_updated_at: firstBody.updatedAt }),
+      store,
+      "/x",
+    );
+    expect(res.status).toBe(200);
+    const body = await res.json() as any;
+    expect(body.content).toBe("third");
+  });
+
+  test("PATCH with stale if_updated_at returns 409 and does not modify note", async () => {
+    await store.createNote("first", { id: "x" });
+    await handleNotes(mkReq("PATCH", "/notes/x", { content: "second" }), store, "/x");
+    const current = await store.getNote("x");
+
+    const res = await handleNotes(
+      mkReq("PATCH", "/notes/x", {
+        content: "third",
+        if_updated_at: "2020-01-01T00:00:00.000Z",
+      }),
+      store,
+      "/x",
+    );
+    expect(res.status).toBe(409);
+    const body = await res.json() as any;
+    expect(body.error).toBe("conflict");
+    expect(body.note_id).toBe("x");
+    expect(body.current_updated_at).toBe(current!.updatedAt);
+    expect(body.expected_updated_at).toBe("2020-01-01T00:00:00.000Z");
+
+    // Unchanged
+    expect((await store.getNote("x"))!.content).toBe("second");
+  });
+
   test("DELETE resolves note by path", async () => {
-    store.createNote("x", { path: "Temp/note" });
+    await store.createNote("x", { path: "Temp/note" });
     const res = await handleNotes(
       mkReq("DELETE", `/notes/${encodeURIComponent("Temp/note")}`),
       store,
@@ -1061,14 +1155,14 @@ describe("HTTP PATCH /notes/:idOrPath (update)", () => {
     );
     const body = await res.json() as any;
     expect(body.deleted).toBe(true);
-    expect(store.getNoteByPath("Temp/note")).toBeNull();
+    expect(await store.getNoteByPath("Temp/note")).toBeNull();
   });
 });
 
-describe("HTTP /tags", () => {
+describe("HTTP /tags", async () => {
   test("GET /tags lists all tags", async () => {
-    store.createNote("A", { tags: ["daily"] });
-    store.createNote("B", { tags: ["daily", "pinned"] });
+    await store.createNote("A", { tags: ["daily"] });
+    await store.createNote("B", { tags: ["daily", "pinned"] });
     const res = await handleTags(mkReq("GET", "/tags"), store);
     const body = await res.json() as any[];
     const daily = body.find((t: any) => t.name === "daily");
@@ -1076,8 +1170,8 @@ describe("HTTP /tags", () => {
   });
 
   test("GET /tags?tag=name returns single tag detail with schema", async () => {
-    store.createNote("A", { tags: ["person"] });
-    store.upsertTagSchema("person", { description: "A person", fields: { name: { type: "string" } } });
+    await store.createNote("A", { tags: ["person"] });
+    await store.upsertTagSchema("person", { description: "A person", fields: { name: { type: "string" } } });
     const res = await handleTags(mkReq("GET", "/tags?tag=person"), store);
     const body = await res.json() as any;
     expect(body.name).toBe("person");
@@ -1098,43 +1192,43 @@ describe("HTTP /tags", () => {
   });
 
   test("DELETE /tags/:name removes tag and schema", async () => {
-    store.createNote("A", { tags: ["doomed"] });
-    store.upsertTagSchema("doomed", { description: "will be deleted" });
+    await store.createNote("A", { tags: ["doomed"] });
+    await store.upsertTagSchema("doomed", { description: "will be deleted" });
     const res = await handleTags(mkReq("DELETE", "/tags/doomed"), store, "/doomed");
     const body = await res.json() as any;
     expect(body.deleted).toBe(true);
-    expect(store.listTags().some((t) => t.name === "doomed")).toBe(false);
+    expect((await store.listTags()).some((t) => t.name === "doomed")).toBe(false);
   });
 });
 
-describe("HTTP /find-path", () => {
+describe("HTTP /find-path", async () => {
   test("finds path between two notes", async () => {
-    store.createNote("a", { id: "a" });
-    store.createNote("b", { id: "b" });
-    store.createNote("c", { id: "c" });
-    store.createLink("a", "b", "mentions");
-    store.createLink("b", "c", "related-to");
-    const res = handleFindPath(mkReq("GET", "/find-path?source=a&target=c"), store);
+    await store.createNote("a", { id: "a" });
+    await store.createNote("b", { id: "b" });
+    await store.createNote("c", { id: "c" });
+    await store.createLink("a", "b", "mentions");
+    await store.createLink("b", "c", "related-to");
+    const res = await handleFindPath(mkReq("GET", "/find-path?source=a&target=c"), store);
     const body = await res.json() as any;
     expect(body.path).toEqual(["a", "b", "c"]);
     expect(body.relationships).toEqual(["mentions", "related-to"]);
   });
 
   test("returns null when no path exists", async () => {
-    store.createNote("a", { id: "a" });
-    store.createNote("b", { id: "b" });
-    const res = handleFindPath(mkReq("GET", "/find-path?source=a&target=b"), store);
+    await store.createNote("a", { id: "a" });
+    await store.createNote("b", { id: "b" });
+    const res = await handleFindPath(mkReq("GET", "/find-path?source=a&target=b"), store);
     const body = await res.json() as any;
     expect(body).toBeNull();
   });
 
   test("requires source and target params", async () => {
-    const res = handleFindPath(mkReq("GET", "/find-path?source=a"), store);
+    const res = await handleFindPath(mkReq("GET", "/find-path?source=a"), store);
     expect(res.status).toBe(400);
   });
 });
 
-describe("stateless MCP transport", () => {
+describe("stateless MCP transport", async () => {
   test("tools/call works without prior initialize handshake", async () => {
     const { handleUnifiedMcp } = await import("./mcp-http.ts");
     const { writeVaultConfig, writeGlobalConfig } = await import("./config.ts");
@@ -1149,7 +1243,7 @@ describe("stateless MCP transport", () => {
     writeGlobalConfig({ port: 1940, default_vault: vaultName });
 
     const vaultStore = getVaultStore(vaultName);
-    vaultStore.createNote("test note", { tags: ["daily"] });
+    await vaultStore.createNote("test note", { tags: ["daily"] });
 
     // Direct tools/call — no initialize, no session header
     const req = new Request("http://localhost:1940/mcp", {