@openparachute/vault 0.6.4-rc.1 → 0.6.4-rc.10

package/README.md

@@ -273,6 +273,31 @@ description: |
 
 Sent as the MCP server instruction at session start.
 
+### Schema enforcement & state machines (vault#299)
+
+Tag-field schemas (`update-tag`'s `fields`) are **advisory by default** — a violating write succeeds and the response carries `validation_status` warnings the agent can self-correct on. That's right for organic single-vault use. Once a vault has multiple writers (humans + agents), opt individual fields into **strict** enforcement:
+
+```yaml
+tag: concept-seed
+fields:
+  state:    { type: string, enum: [idea, drafted, scripted, produced, published, killed], strict: true }
+  title:    { type: string, required: true, strict: true }
+  owners:   { type: array,  cardinality: many, strict: true }
+  priority: { type: number }   # advisory (default)
+  notes:    { type: string }   # advisory — free-form stays free-form
+```
+
+`strict: true` flips **all** of that field's declared constraints together — `type` + `enum` + `required` + `cardinality` — from warnings to hard write rejections (all-or-nothing per field). A violating create/update is rejected with a single `schema_validation` error carrying **every** per-field violation (MCP `data.error_type: "schema_validation"` / HTTP 422), and nothing is written. Strictness is **per-field**, so a free-form `notes` field stays advisory on an otherwise-strict tag. Declared strict fields surface in `vault-info` and the connect-time brief so an agent knows the contract before writing.
+
+**Migration bypass.** A token holding the `vault:migrate` scope (broad) or `vault:<name>:migrate` (narrowed) skips strict enforcement — for backfilling/migrating existing non-conforming notes. It's an orthogonal capability (an `admin` token does **not** bypass unless it also holds `migrate`), and every bypassed write is logged to the daemon's structured log (`[schema-bypass] {...}` with the actor/via and waived violations) for later audit.
+
+**Compare-and-set state transitions.** Advance a state machine race-safely in one round trip instead of read → check → conditional update. `update-note`'s `state_transition: { field, from, to }` atomically sets `field` to `to` **only if** it currently equals `from`; otherwise it's rejected with a distinct `transition_conflict` error. A **missing field** counts as a conflict; pass `from: null` to match a field that is absent or explicitly null. A **transition-only** update needs no `if_updated_at`/`force` — the compare-and-set IS the precondition. Combinable with other field updates in the same call (they land in the same atomic UPDATE), but a combined call still needs `if_updated_at`/`force` for the *other* fields — the CAS only guards the transitioned field, not the rest of the merge.
+
+```jsonc
+// advance a seed from idea → drafted, race-safely
+update-note { "id": "Seeds/my-idea", "state_transition": { "field": "state", "from": "idea", "to": "drafted" } }
+```
+
 ## Features
 
 ### Wikilink auto-linking
@@ -321,7 +346,19 @@ triggers:
       send: content
 ```
 
-**Predicate fields**: `tags` (all must match), `has_content` (true/false), `missing_metadata` (keys that must be absent), `has_metadata` (keys that must be present).
+**Predicate fields**: `tags` (all must match), `has_content` (true/false), `missing_metadata` (keys that must be absent), `has_metadata` (keys that must be present), and `metadata` (value-matched — a field → operator-object map using the same operators as `query-notes`: `eq/ne/gt/gte/lt/lte/in/not_in/exists`). All predicate fields are ANDed. Value-matching lets a trigger fire on a specific transition rather than every edit (vault#299):
+
+```yaml
+  - name: announce-published
+    events: [updated]
+    when:
+      tags: [piece]
+      metadata:
+        state: { eq: published }     # fire only when state reaches "published"
+      missing_metadata: [announced_at]
+    action:
+      webhook: https://example.com/announce
+```
 
 **Two-phase markers**: On match, the trigger sets `<name>_pending_at` metadata before calling the webhook, then replaces it with `<name>_rendered_at` on success. This prevents re-entry and concurrent runs.
 
@@ -549,16 +586,12 @@ Range params require content in the response — with `include_content=false` (o
 
 ### Incremental rebuilds: "what changed since X"
 
-The SSG / sync pattern. Two equivalent forms — bracket-style is canonical going forward; the flat form is the same shape that ships through the REST/MCP date filter today.
+The SSG / sync pattern. Bracket-style is the query-string date filter. (The flat `date_field` / `date_from` / `date_to` params were removed in 0.6.4 — vault#288 — and are now ignored.)
 
 ```bash
-# Bracket-style (canonical)
+# Bracket-style (the query-string date filter)
 curl -H "Authorization: Bearer $VAULT_TOKEN" \
   "http://localhost:1940/vault/default/api/notes?meta[updated_at][gte]=2026-04-01T00:00:00Z"
-
-# Flat form (DEPRECATED in 0.4.3; planned removal in a later 0.x per vault#288)
-curl -H "Authorization: Bearer $VAULT_TOKEN" \
-  "http://localhost:1940/vault/default/api/notes?date_field=updated_at&date_from=2026-04-01T00:00:00Z"
 ```
 
 ```jsonc
@@ -910,7 +943,7 @@ cp .env.example .env   # edit with your config
 docker compose up -d
 ```
 
-Optionally set `PARACHUTE_VAULT_NAME` to choose a name for your first vault (defaults to `default`). Lowercase alphanumeric + hyphens or underscores, 2–32 chars.
+Set `PARACHUTE_VAULT_NAME` to auto-create a first vault on startup (name: lowercase alphanumeric + hyphens or underscores, 2–32 chars). Without it the server boots with zero vaults — create one explicitly via the admin wizard, `parachute init --vault-name <name>`, or `parachute-vault create <name>`.
 
 ### Cloud platforms
 
@@ -935,9 +968,11 @@ typical v0.6 self-host wants. If you're not sure, use the hub-managed
 path above. The standalone Blueprint stays in tree because some
 operators specifically want this shape (vault#341).
 
-Optionally set `PARACHUTE_VAULT_NAME` to choose a name for your first
-vault (defaults to `default`). Lowercase alphanumeric + hyphens or
-underscores, 2–32 chars.
+Set `PARACHUTE_VAULT_NAME` to auto-create a first vault on startup (name:
+lowercase alphanumeric + hyphens or underscores, 2–32 chars). Without it
+the server boots with zero vaults — create one explicitly via the admin
+wizard, `parachute init --vault-name <name>`, or `parachute-vault create
+<name>`.
 
 #### Other platforms
 

package/core/src/attribution.test.ts

@@ -0,0 +1,273 @@
+/**
+ * Write-attribution (vault#298) — per-identity (`*_by`) + per-interface
+ * (`*_via`) provenance at the store layer.
+ *
+ * Covers the core contract:
+ *   - create stamps BOTH axes onto created_* AND mirrors into last_updated_*
+ *   - update bumps ONLY last_updated_* (created_* is set-once)
+ *   - a `skipUpdatedAt` machine write does NOT claim authorship
+ *   - no-attribution writes leave the columns NULL (never "")
+ *   - the four query-notes filters (created_by / last_updated_by /
+ *     created_via / last_updated_via)
+ *   - legacy rows written before the v23 migration stay NULL and don't crash
+ *   - the cursor binds the attribution filters (changing them invalidates it)
+ *
+ * The auth → AuthResult → MCP/REST threading is exercised separately in
+ * src/attribution-threading.test.ts (it needs the server-side auth context).
+ */
+import { describe, it, expect, beforeEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import { SqliteStore } from "./store.js";
+import { initSchema, SCHEMA_VERSION } from "./schema.js";
+
+let store: SqliteStore;
+let db: Database;
+
+beforeEach(() => {
+  db = new Database(":memory:");
+  store = new SqliteStore(db);
+});
+
+function rawRow(id: string) {
+  return db
+    .prepare(
+      "SELECT created_by, created_via, last_updated_by, last_updated_via FROM notes WHERE id = ?",
+    )
+    .get(id) as {
+    created_by: string | null;
+    created_via: string | null;
+    last_updated_by: string | null;
+    last_updated_via: string | null;
+  };
+}
+
+describe("write-attribution — schema", () => {
+  it("bumped SCHEMA_VERSION to 23", () => {
+    expect(SCHEMA_VERSION).toBe(23);
+  });
+
+  it("the four columns exist and are indexed", () => {
+    const cols = (db.prepare("PRAGMA table_info(notes)").all() as { name: string }[]).map(
+      (r) => r.name,
+    );
+    expect(cols).toContain("created_by");
+    expect(cols).toContain("created_via");
+    expect(cols).toContain("last_updated_by");
+    expect(cols).toContain("last_updated_via");
+
+    const idx = (
+      db
+        .prepare("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='notes'")
+        .all() as { name: string }[]
+    ).map((r) => r.name);
+    expect(idx).toContain("idx_notes_created_by");
+    expect(idx).toContain("idx_notes_created_via");
+    expect(idx).toContain("idx_notes_last_updated_by");
+    expect(idx).toContain("idx_notes_last_updated_via");
+  });
+});
+
+describe("write-attribution — per-identity (WHO) + per-interface (VIA)", () => {
+  it("create captures actor + via on BOTH the created_* and last_updated_* pairs", async () => {
+    const note = await store.createNote("hi", { actor: "aaron", via: "mcp" });
+    // Read-model surfaces both axes.
+    expect(note.createdBy).toBe("aaron");
+    expect(note.createdVia).toBe("mcp");
+    // First write IS the most-recent write — mirrored.
+    expect(note.lastUpdatedBy).toBe("aaron");
+    expect(note.lastUpdatedVia).toBe("mcp");
+
+    const row = rawRow(note.id);
+    expect(row.created_by).toBe("aaron");
+    expect(row.created_via).toBe("mcp");
+    expect(row.last_updated_by).toBe("aaron");
+    expect(row.last_updated_via).toBe("mcp");
+  });
+
+  it("update bumps last_updated_* but leaves created_* untouched (set-once)", async () => {
+    const note = await store.createNote("v1", { actor: "aaron", via: "mcp" });
+    const updated = await store.updateNote(note.id, {
+      content: "v2",
+      actor: "mathilda",
+      via: "surface:meeting-ingest",
+    });
+
+    // created_* pins the ORIGINAL author/channel forever.
+    expect(updated.createdBy).toBe("aaron");
+    expect(updated.createdVia).toBe("mcp");
+    // last_updated_* reflects the most recent writer.
+    expect(updated.lastUpdatedBy).toBe("mathilda");
+    expect(updated.lastUpdatedVia).toBe("surface:meeting-ingest");
+
+    const row = rawRow(note.id);
+    expect(row.created_by).toBe("aaron");
+    expect(row.last_updated_by).toBe("mathilda");
+    expect(row.last_updated_via).toBe("surface:meeting-ingest");
+  });
+
+  it("append/prepend updates also record the most-recent author", async () => {
+    const note = await store.createNote("base", { actor: "aaron", via: "mcp" });
+    const after = await store.updateNote(note.id, {
+      append: " +more",
+      actor: "agent:nightly",
+      via: "agent:nightly",
+    });
+    expect(after.content).toBe("base +more");
+    expect(after.createdBy).toBe("aaron");
+    expect(after.lastUpdatedBy).toBe("agent:nightly");
+    expect(after.lastUpdatedVia).toBe("agent:nightly");
+  });
+
+  it("a skipUpdatedAt machine write does NOT claim authorship", async () => {
+    const note = await store.createNote("x", { actor: "aaron", via: "mcp" });
+    const before = rawRow(note.id);
+    // A hook-style marker write: passes actor/via but skipUpdatedAt — should
+    // not bump updated_at NOR rewrite last_updated_*.
+    await store.updateNote(note.id, {
+      metadata: { marker: true },
+      skipUpdatedAt: true,
+      actor: "some-hook",
+      via: "operator",
+    });
+    const after = rawRow(note.id);
+    expect(after.last_updated_by).toBe(before.last_updated_by); // still "aaron"
+    expect(after.last_updated_by).toBe("aaron");
+    expect(after.last_updated_via).toBe("mcp");
+  });
+
+  it("an attribution-less update honestly clears the most-recent author (NULL, not stale)", async () => {
+    const note = await store.createNote("x", { actor: "aaron", via: "mcp" });
+    // A real edit arriving with no attribution context — the latest writer is
+    // unknown; we must NOT leave "aaron" as the apparent last editor.
+    const after = await store.updateNote(note.id, { content: "y" });
+    expect(after.createdBy).toBe("aaron"); // original author preserved
+    expect(after.lastUpdatedBy).toBeNull();
+    expect(after.lastUpdatedVia).toBeNull();
+  });
+});
+
+describe("write-attribution — no context → NULL (never empty string)", () => {
+  it("create without actor/via leaves all four columns NULL", async () => {
+    const note = await store.createNote("anon");
+    const row = rawRow(note.id);
+    expect(row.created_by).toBeNull();
+    expect(row.created_via).toBeNull();
+    expect(row.last_updated_by).toBeNull();
+    expect(row.last_updated_via).toBeNull();
+    expect(note.createdBy).toBeNull();
+    expect(note.createdVia).toBeNull();
+  });
+
+  it("empty / whitespace-only actor/via normalize to NULL", async () => {
+    const note = await store.createNote("e", { actor: "   ", via: "" });
+    const row = rawRow(note.id);
+    expect(row.created_by).toBeNull();
+    expect(row.created_via).toBeNull();
+  });
+});
+
+describe("write-attribution — query filters", () => {
+  beforeEach(async () => {
+    await store.createNote("a", { actor: "aaron", via: "mcp" });
+    await store.createNote("b", { actor: "mathilda", via: "surface:meeting-ingest" });
+    const c = await store.createNote("c", { actor: "aaron", via: "api" });
+    // c's most-recent write is by the nightly agent via mcp.
+    await store.updateNote(c.id, { content: "c2", actor: "agent:nightly", via: "mcp" });
+    await store.createNote("legacy"); // no attribution
+  });
+
+  it("created_by selects only that principal's CREATED notes", async () => {
+    const aaron = await store.queryNotes({ createdBy: "aaron" });
+    expect(aaron.map((n) => n.content).sort()).toEqual(["a", "c2"]);
+  });
+
+  it("last_updated_by selects by MOST-RECENT author (agent's edit on c)", async () => {
+    const byAgent = await store.queryNotes({ lastUpdatedBy: "agent:nightly" });
+    expect(byAgent.map((n) => n.content)).toEqual(["c2"]);
+    // aaron created c but is no longer its last editor.
+    const aaronLatest = await store.queryNotes({ lastUpdatedBy: "aaron" });
+    expect(aaronLatest.map((n) => n.content)).toEqual(["a"]);
+  });
+
+  it("created_via / last_updated_via filter on the interface axis", async () => {
+    const viaSurface = await store.queryNotes({ createdVia: "surface:meeting-ingest" });
+    expect(viaSurface.map((n) => n.content)).toEqual(["b"]);
+    const lastViaMcp = await store.queryNotes({ lastUpdatedVia: "mcp" });
+    // "a" (created via mcp, never updated) + "c2" (last updated via mcp).
+    expect(lastViaMcp.map((n) => n.content).sort()).toEqual(["a", "c2"]);
+  });
+
+  it("an attribution filter never matches legacy/unattributed (NULL) rows", async () => {
+    const any = await store.queryNotes({ createdBy: "aaron" });
+    expect(any.some((n) => n.content === "legacy")).toBe(false);
+  });
+});
+
+describe("write-attribution — legacy backfill (v23 migration)", () => {
+  it("a pre-v23 vault: existing rows stay NULL, new rows attribute, no crash", () => {
+    // Build a v22-shaped notes table by hand (no attribution columns) +
+    // schema_version row, then run initSchema to drive the v23 migration.
+    const legacy = new Database(":memory:");
+    legacy.exec(`
+      CREATE TABLE notes (
+        id TEXT PRIMARY KEY,
+        content TEXT DEFAULT '',
+        path TEXT,
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT,
+        extension TEXT NOT NULL DEFAULT 'md'
+      );
+      CREATE TABLE schema_version (version INTEGER PRIMARY KEY, applied_at TEXT);
+      INSERT INTO schema_version (version, applied_at) VALUES (22, '2026-01-01T00:00:00.000Z');
+      INSERT INTO notes (id, content, created_at, updated_at)
+        VALUES ('old-1', 'pre-existing', '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z');
+    `);
+
+    // Should migrate without throwing.
+    initSchema(legacy);
+
+    const ver = (legacy.prepare("SELECT MAX(version) AS v FROM schema_version").get() as {
+      v: number;
+    }).v;
+    expect(ver).toBe(23);
+
+    // Legacy row: attribution columns exist now but are NULL (not fabricated).
+    const old = legacy
+      .prepare("SELECT created_by, last_updated_by, created_via FROM notes WHERE id = ?")
+      .get("old-1") as { created_by: string | null; last_updated_by: string | null; created_via: string | null };
+    expect(old.created_by).toBeNull();
+    expect(old.last_updated_by).toBeNull();
+    expect(old.created_via).toBeNull();
+
+    // A NEW write on the migrated DB attributes correctly.
+    const migratedStore = new SqliteStore(legacy);
+    return migratedStore.createNote("fresh", { actor: "aaron", via: "mcp" }).then((n) => {
+      expect(n.createdBy).toBe("aaron");
+      expect(n.createdVia).toBe("mcp");
+      // The legacy row is still NULL and still queryable.
+      return migratedStore.queryNotes({ createdBy: "aaron" }).then((res) => {
+        expect(res.map((x) => x.content)).toEqual(["fresh"]);
+      });
+    });
+  });
+
+  it("re-running the v23 migration is idempotent (no duplicate-column error)", () => {
+    const again = new Database(":memory:");
+    const s = new SqliteStore(again); // runs migrations once
+    initSchema(again); // run again — must not throw
+    expect(() => s.createNote("ok", { actor: "x", via: "api" })).not.toThrow();
+  });
+});
+
+describe("write-attribution — cursor binding", () => {
+  it("changing an attribution filter between cursor polls invalidates the cursor", async () => {
+    await store.createNote("a", { actor: "aaron", via: "mcp" });
+    const page = await store.queryNotesPaged({ createdBy: "aaron" });
+    // Reusing the cursor under a DIFFERENT createdBy must be rejected, not
+    // silently continue aaron's watermark.
+    await expect(
+      store.queryNotesPaged({ createdBy: "mathilda", cursor: page.next_cursor }),
+    ).rejects.toThrow(/different query/i);
+  });
+});

package/core/src/core.test.ts

@@ -5,6 +5,7 @@ import { generateMcpTools } from "./mcp.js";
 import { initSchema } from "./schema.js";
 import { decodeCursor } from "./cursor.js";
 import { traverseLinks } from "./links.js";
+import * as indexedFieldOps from "./indexed-fields.js";
 
 let store: SqliteStore;
 let db: Database;
@@ -2169,6 +2170,50 @@ describe("MCP tools", async () => {
     expect(result.extension).toBe("csv");
   });
 
+  // ---- Metadata key-deletion via null tombstone (vault#478 / #479) ---------
+
+  it("update-note deletes a metadata key when its value is null (RFC 7386)", async () => {
+    const note = await store.createNote("m", {
+      metadata: { keep: "yes", drop: "old", other: 1 },
+    });
+    const tools = generateMcpTools(store);
+    const updateNote = tools.find((t) => t.name === "update-note")!;
+    await updateNote.execute({ id: note.id, metadata: { drop: null }, force: true });
+
+    const fresh = await store.getNote(note.id);
+    // The deleted key is GONE — not a literal JSON null.
+    expect(fresh!.metadata).not.toHaveProperty("drop");
+    // Other keys are untouched.
+    expect(fresh!.metadata).toMatchObject({ keep: "yes", other: 1 });
+  });
+
+  it("update-note metadata key-rename in one call (new key set, old key deleted)", async () => {
+    const note = await store.createNote("m", {
+      metadata: { "old-key": "v", stable: true },
+    });
+    const tools = generateMcpTools(store);
+    const updateNote = tools.find((t) => t.name === "update-note")!;
+    await updateNote.execute({
+      id: note.id,
+      metadata: { new_key: "v", "old-key": null },
+      force: true,
+    });
+
+    const fresh = await store.getNote(note.id);
+    expect(fresh!.metadata).not.toHaveProperty("old-key");
+    expect(fresh!.metadata).toMatchObject({ new_key: "v", stable: true });
+  });
+
+  it("deleting an absent metadata key is a no-op (round-trips cleanly)", async () => {
+    const note = await store.createNote("m", { metadata: { a: 1 } });
+    const tools = generateMcpTools(store);
+    const updateNote = tools.find((t) => t.name === "update-note")!;
+    await updateNote.execute({ id: note.id, metadata: { ghost: null }, force: true });
+    const fresh = await store.getNote(note.id);
+    expect(fresh!.metadata).toEqual({ a: 1 });
+    expect(fresh!.metadata).not.toHaveProperty("ghost");
+  });
+
   it("query-notes filters by extension (vault#328)", async () => {
     await store.createNote("md note", { path: "a" });
     await store.createNote("csv note", { path: "b", extension: "csv" });
@@ -5301,6 +5346,87 @@ describe("tag record API (patterns/tag-data-model.md)", async () => {
     expect((await store.queryNotes({ tags: ["manual"] })).length).toBe(0);
     expect(await store.getTagRecord("voice")).toBeNull();
   });
+
+  // ---- Indexed-field atomicity (vault#478) ----------------------------------
+
+  it("upsertTagRecord with a bad indexed-field name throws IndexedFieldError and leaves the schema unchanged", async () => {
+    // kebab-case field name violates [A-Za-z0-9_] / no-leading-digit. The
+    // declaration must NOT persist, and no orphan/lying index may be created.
+    await expect(
+      store.upsertTagRecord("meeting", {
+        description: "meetings",
+        fields: { "meeting-type": { type: "string", indexed: true } },
+      }),
+    ).rejects.toThrow(indexedFieldOps.IndexedFieldError);
+
+    // Schema is untouched — the tag row may not even exist, and definitely
+    // doesn't claim the poisoned field.
+    const record = await store.getTagRecord("meeting");
+    expect(record?.fields?.["meeting-type"]).toBeUndefined();
+
+    // No backing index row was created for the bad field.
+    expect(indexedFieldOps.getIndexedField(db, "meeting-type")).toBeNull();
+    // And the generated column doesn't exist either.
+    const cols = (db.prepare("PRAGMA table_xinfo(notes)").all() as { name: string }[]).map(
+      (c) => c.name,
+    );
+    expect(cols).not.toContain("meta_meeting-type");
+  });
+
+  it("upsertTagRecord with an unindexable type throws and leaves the schema unchanged", async () => {
+    await expect(
+      store.upsertTagRecord("meeting", {
+        fields: { attendees: { type: "json", indexed: true } },
+      }),
+    ).rejects.toThrow(indexedFieldOps.IndexedFieldError);
+    const record = await store.getTagRecord("meeting");
+    expect(record?.fields?.attendees).toBeUndefined();
+    expect(indexedFieldOps.getIndexedField(db, "attendees")).toBeNull();
+  });
+
+  it("a bad indexed field does NOT corrupt a prior valid declaration on the same tag", async () => {
+    // First, a clean valid indexed field.
+    await store.upsertTagRecord("meeting", {
+      fields: { held_on: { type: "string", indexed: true } },
+    });
+    expect(indexedFieldOps.getIndexedField(db, "held_on")?.declarerTags).toContain("meeting");
+
+    // Now an update that adds a poisoned field. The whole write must roll
+    // back — the prior valid field survives untouched.
+    await expect(
+      store.upsertTagRecord("meeting", {
+        fields: {
+          held_on: { type: "string", indexed: true },
+          "bad-field": { type: "string", indexed: true },
+        },
+      }),
+    ).rejects.toThrow(indexedFieldOps.IndexedFieldError);
+
+    const record = await store.getTagRecord("meeting");
+    expect(record?.fields?.held_on?.indexed).toBe(true);
+    expect(record?.fields?.["bad-field"]).toBeUndefined();
+    expect(indexedFieldOps.getIndexedField(db, "held_on")?.declarerTags).toContain("meeting");
+    expect(indexedFieldOps.getIndexedField(db, "bad-field")).toBeNull();
+  });
+
+  it("upsertTagRecord with fields:null releases indexed fields (transaction commits the release path)", async () => {
+    // Declare an indexed field, then clear all fields — the release path runs
+    // inside the same transaction as the persist. It must commit cleanly:
+    // the row, generated column, and index all drop.
+    await store.upsertTagRecord("meeting", {
+      fields: { held_on: { type: "string", indexed: true } },
+    });
+    expect(indexedFieldOps.getIndexedField(db, "held_on")?.declarerTags).toContain("meeting");
+
+    await store.upsertTagRecord("meeting", { fields: null });
+    const record = await store.getTagRecord("meeting");
+    expect(record?.fields).toBeUndefined();
+    expect(indexedFieldOps.getIndexedField(db, "held_on")).toBeNull();
+    const cols = (db.prepare("PRAGMA table_xinfo(notes)").all() as { name: string }[]).map(
+      (c) => c.name,
+    );
+    expect(cols).not.toContain("meta_held_on");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/core/src/cursor.ts

@@ -160,6 +160,14 @@ export interface QueryHashInputs {
   extension?: string | string[];
   ids?: string[];
   metadata?: Record<string, unknown>;
+  // Write-attribution filters (vault#298) — part of the result-set-affecting
+  // opts, so they're bound into the cursor: changing "who/via" between polls
+  // invalidates the cursor with cursor_query_mismatch rather than silently
+  // continuing the prior filter's watermark.
+  createdBy?: string;
+  lastUpdatedBy?: string;
+  createdVia?: string;
+  lastUpdatedVia?: string;
   dateFrom?: string;
   dateTo?: string;
   dateFilter?: { field?: string; from?: string; to?: string };