@openparachute/vault 0.6.3 → 0.6.4-rc.10

package/src/subscribe.test.ts

@@ -416,9 +416,12 @@ describe("handleSubscribe — rejected query shapes", () => {
     expect(body.error).toContain("has_links");
   });
 
-  it("date filter → 400 (M1) — legacy date_from", async () => {
+  it("date filter → 400 (M1) — bracket date_filter on created_at", async () => {
+    // The flat `date_from` param was removed in 0.6.4 (vault#288) and is now
+    // ignored, so it no longer reaches the M1 date guard. Bracket-style is the
+    // only query-string date filter; assert it's still rejected for live subs.
     const res = await handleSubscribe(
-      subscribeReq("date_from=2026-01-01"),
+      subscribeReq("meta%5Bcreated_at%5D%5Bgte%5D=2026-01-01"),
       store,
       VAULT,
       unscopedScope(),
@@ -430,6 +433,24 @@ describe("handleSubscribe — rejected query shapes", () => {
     expect(body.error).toContain("date");
   });
 
+  it("flat date_from is ignored → subscription created (vault#288 removal)", async () => {
+    // Documents the breaking change: the removed flat param no longer reaches
+    // the date guard, so a sub that ONLY carries it is now a valid (unfiltered)
+    // subscription rather than a 400.
+    const res = await handleSubscribe(
+      subscribeReq("date_from=2026-01-01"),
+      store,
+      VAULT,
+      unscopedScope(),
+      manager,
+    );
+    expect(res.status).toBe(200);
+    expect(res.headers.get("Content-Type")).toBe("text/event-stream");
+    const r = sseReader(res);
+    await r.pump();
+    await r.close();
+  });
+
   it("date filter → 400 (M1) — bracket date_filter on updated_at", async () => {
     const res = await handleSubscribe(
       subscribeReq("meta%5Bupdated_at%5D%5Bgte%5D=2026-01-01"),

package/src/test-support/spawn.ts

@@ -0,0 +1,85 @@
+/**
+ * Shared subprocess helper for tests (vault#325 Part 1).
+ *
+ * THE RULE — never `Bun.spawnSync` in a test that keeps an in-process
+ * `Bun.serve` listening for the child to probe.
+ *
+ * `Bun.spawnSync` blocks the parent's event loop until the child exits.
+ * If the child makes an HTTP request back to a server the *same test
+ * process* is hosting (e.g. the CLI's daemon-busy pre-flight fetching a
+ * stub `/health`), the parent can't answer — the child's request times
+ * out into the "nothing listening" branch and the assertion silently
+ * tests the wrong path (the guard never fires, or fails for a non-obvious
+ * reason). This bit the daemon-busy import guard; the fix landed in
+ * vault#324 (`src/import-daemon-busy.test.ts`) and this helper is the
+ * institutional-memory follow-up so future subprocess tests reach for the
+ * safe primitive by default.
+ *
+ * `runSubprocess` uses async `Bun.spawn` + `await proc.exited`, so the
+ * parent's event loop keeps servicing requests while the child runs.
+ *
+ * NOTE on what's *fine*: `Bun.spawnSync` is safe in tests that don't run
+ * an in-test server the child talks to over HTTP — e.g. shelling out to
+ * `git` to build a fixture repo (`mirror-*.test.ts`), or a `Bun.serve`
+ * that merely *holds a port* so the child's `lsof`/availability probe
+ * sees it occupied (`doctor.test.ts`). The deadlock is specifically
+ * "child fetches the parent test process's server." When in doubt, use
+ * this helper — it's never wrong, only sometimes unnecessary.
+ */
+
+export interface RunSubprocessResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+export interface RunSubprocessOptions {
+  cmd: string[];
+  cwd?: string;
+  /** Extra env merged over `process.env`. `undefined` values delete the key. */
+  env?: Record<string, string | undefined>;
+  /** Optional bytes piped to the child's stdin. */
+  stdin?: string;
+}
+
+/**
+ * Run a subprocess WITHOUT blocking the event loop.
+ *
+ * Drop-in for the `Bun.spawnSync({ cmd, env, stdout, stderr })` pattern
+ * that recurs across the CLI integration tests, but built on async
+ * `Bun.spawn` so an in-process `Bun.serve` the child probes can still
+ * answer. Returns once the child has exited, with decoded stdout/stderr.
+ */
+export async function runSubprocess(
+  opts: RunSubprocessOptions,
+): Promise<RunSubprocessResult> {
+  const env: Record<string, string> = { ...(process.env as Record<string, string>) };
+  if (opts.env) {
+    for (const [k, v] of Object.entries(opts.env)) {
+      if (v === undefined) delete env[k];
+      else env[k] = v;
+    }
+  }
+
+  const proc = Bun.spawn({
+    cmd: opts.cmd,
+    cwd: opts.cwd,
+    env,
+    stdin: opts.stdin === undefined ? undefined : "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  if (opts.stdin !== undefined) {
+    proc.stdin!.write(opts.stdin);
+    await proc.stdin!.end();
+  }
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  return { exitCode: exitCode ?? -1, stdout, stderr };
+}

package/src/triggers-api.ts

@@ -30,6 +30,7 @@ import {
   type TriggerInput,
 } from "../core/src/triggers-store.ts";
 import { registerVaultTrigger } from "./triggers.ts";
+import { SUPPORTED_OPS } from "../core/src/query-operators.ts";
 import { hasScopeForVault, SCOPE_ADMIN } from "./scopes.ts";
 import type { AuthResult } from "./auth.ts";
 
@@ -135,6 +136,29 @@ function validateInput(body: unknown):
   if (typeof b.when !== "object" || b.when === null || Array.isArray(b.when)) {
     return { ok: false, message: "`when` is required and must be an object" };
   }
+  // Value-matched metadata predicate (vault#299 Part B): when present, each
+  // field must map to an operator-object whose keys are all supported
+  // operators. Fail at registration so a typo'd operator (`{ state: { equals:
+  // ... } }`) is a 400, not a silently-never-firing trigger.
+  const whenMeta = (b.when as Record<string, unknown>).metadata;
+  if (whenMeta !== undefined) {
+    if (typeof whenMeta !== "object" || whenMeta === null || Array.isArray(whenMeta)) {
+      return { ok: false, message: "`when.metadata` must be an object mapping field → operator-object" };
+    }
+    for (const [field, opObj] of Object.entries(whenMeta as Record<string, unknown>)) {
+      if (typeof opObj !== "object" || opObj === null || Array.isArray(opObj)) {
+        return { ok: false, message: `\`when.metadata.${field}\` must be an operator-object, e.g. { eq: "published" }` };
+      }
+      for (const op of Object.keys(opObj as Record<string, unknown>)) {
+        if (!SUPPORTED_OPS.includes(op as (typeof SUPPORTED_OPS)[number])) {
+          return {
+            ok: false,
+            message: `\`when.metadata.${field}\` has unknown operator "${op}". Supported: ${SUPPORTED_OPS.join(", ")}.`,
+          };
+        }
+      }
+    }
+  }
 
   if (typeof b.action !== "object" || b.action === null || Array.isArray(b.action)) {
     return { ok: false, message: "`action` is required and must be an object" };

package/src/triggers.test.ts

@@ -95,6 +95,39 @@ describe("buildPredicate", () => {
     expect(pred(makeNote({ tags: ["reader"] }))).toBe(false);
     expect(pred(makeNote({ tags: ["reader", "important"] }))).toBe(true);
   });
+
+  // Value-matched metadata grammar (vault#299 Part B).
+  it("metadata eq: fires only when the field equals the value", () => {
+    const pred = buildPredicate({ metadata: { state: { eq: "published" } } }, "publish_hook");
+    expect(pred(makeNote({ metadata: { state: "published" } }))).toBe(true);
+    expect(pred(makeNote({ metadata: { state: "drafted" } }))).toBe(false);
+    expect(pred(makeNote({ metadata: {} }))).toBe(false); // absent → no fire
+  });
+
+  it("metadata in: fires on membership", () => {
+    const pred = buildPredicate({ metadata: { state: { in: ["produced", "published"] } } }, "h");
+    expect(pred(makeNote({ metadata: { state: "produced" } }))).toBe(true);
+    expect(pred(makeNote({ metadata: { state: "idea" } }))).toBe(false);
+  });
+
+  it("metadata combines with tag + presence filters (all must hold)", () => {
+    const pred = buildPredicate(
+      { tags: ["piece"], metadata: { state: { eq: "published" } }, missing_metadata: ["notified_at"] },
+      "h",
+    );
+    expect(pred(makeNote({ tags: ["piece"], metadata: { state: "published" } }))).toBe(true);
+    // right state, wrong tag.
+    expect(pred(makeNote({ tags: ["other"], metadata: { state: "published" } }))).toBe(false);
+    // right tag + state but already notified.
+    expect(
+      pred(makeNote({ tags: ["piece"], metadata: { state: "published", notified_at: "x" } })),
+    ).toBe(false);
+  });
+
+  it("a malformed operator never throws from the predicate (treated as no-match)", () => {
+    const pred = buildPredicate({ metadata: { state: { bogus: "x" } as any } }, "h");
+    expect(pred(makeNote({ metadata: { state: "published" } }))).toBe(false);
+  });
 });
 
 describe("registerTriggers — dispatch modes", async () => {

package/src/triggers.ts

@@ -30,6 +30,7 @@ import { mkdirSync, readFileSync, writeFileSync, existsSync } from "fs";
 import crypto from "node:crypto";
 import type { Note, Store, Attachment } from "../core/src/types.ts";
 import type { HookRegistry, HookEvent, NoteHookPayload } from "../core/src/hooks.ts";
+import { matchesOperator } from "../core/src/query-operators.ts";
 import type { TriggerConfig, TriggerWhen } from "./config.ts";
 import type { StoredTrigger } from "../core/src/triggers-store.ts";
 import { getVaultNameForStore } from "./vault-store.ts";
@@ -106,6 +107,22 @@ export function buildPredicate(when: TriggerWhen, triggerName: string): (note: N
       }
     }
 
+    // Value-matched metadata filter (vault#299 Part B). Each field's
+    // operator-object is evaluated against the note's live metadata with the
+    // SAME engine query-notes uses. ALL fields must match (AND). A malformed
+    // operator throws at registration-time validation, not here — by the time
+    // the predicate runs the shape is known-good, but we guard defensively so
+    // a bad config can never crash the hook dispatch loop (treat as no-match).
+    if (when.metadata) {
+      for (const [field, opObj] of Object.entries(when.metadata)) {
+        try {
+          if (!matchesOperator(field, meta?.[field], opObj)) return false;
+        } catch {
+          return false;
+        }
+      }
+    }
+
     return true;
   };
 }

package/src/vault-remove.test.ts

@@ -141,13 +141,12 @@ describe("vault remove — last-vault auto_create marker", () => {
     // resurrection of a freshly-credentialed "default".
     expect(bootAutoCreateAllowed(config)).toBe(false);
 
-    // services.json was still refreshed: with zero vaults the row falls back
-    // to the manifest's canonical paths — the SAME row a subsequent boot's
-    // selfRegister writes, so CLI-remove and boot agree on the zero-vault
-    // registration shape (and the hub still sees the module as installed).
+    // services.json was still refreshed: with zero vaults the row carries
+    // paths: [] (#478) — the row stays present so the hub sees the module as
+    // installed, but advertises no /vault/<name> path (no phantom default).
     const vault = readServices(home).find((s) => s.name === "parachute-vault");
     expect(vault).toBeDefined();
-    expect(vault!.paths).toEqual(["/vault/default"]);
+    expect(vault!.paths).toEqual([]);
   });
 
   test("removing a NON-last vault does not write the marker", () => {

package/src/vault.test.ts

@@ -1393,6 +1393,99 @@ describe("scoped MCP wrapper", async () => {
     closeAllStores();
   });
 
+  // -- Q6 through the MCP TRANSPORT (vault#325 Part 2) --------------------
+  //
+  // The two tests above call `tool.execute()` directly — that exercises the
+  // tag-scope WRAPPER but bypasses `handleScopedMcp`: the JSON-RPC transport,
+  // the `hasScopeForVault` tool-visibility gate, and the tools/call dispatch.
+  // The HTTP-layer twin lives in `routing.test.ts` (Q6 read-path). What was
+  // missing — and what this pins — is the orphan-sub-tag fail-open driven
+  // through the actual MCP `tools/call` path a real client hits. Same fixture
+  // as the HTTP test (`#health/food` with no `_tags/health/food` schema,
+  // token allowlisted for `health`), different transport.
+
+  test("MCP query-notes (tools/call) sees orphan sub-tag via string-form root (vault#325 Part 2)", async () => {
+    const { handleScopedMcp } = await import("./mcp-http.ts");
+    const { writeVaultConfig } = await import("./config.ts");
+    const { getVaultStore, closeAllStores } = await import("./vault-store.ts");
+
+    const vaultName = `mcp-orphan-query-${Date.now()}`;
+    writeVaultConfig({ name: vaultName, api_keys: [], created_at: new Date().toISOString() });
+    const store = getVaultStore(vaultName);
+    // No `_tags/health/food` schema — this is the orphan case. The hierarchy
+    // is implicit, so authorization must fall back to the string-form root.
+    const orphan = await store.createNote("orphan", { tags: ["health/food"] });
+
+    const auth = {
+      permission: "read" as const,
+      scopes: ["vault:read"],
+      legacyDerived: false,
+      scoped_tags: ["health"],
+    };
+
+    // The URL is inert here — handleScopedMcp hands it to the SDK
+    // transport, which only reads the body; the `vaultName` route wiring
+    // is exercised by routing.test.ts, not this transport-level test. The
+    // `accept` header is load-bearing: `enableJsonResponse` returns JSON
+    // only when text/event-stream is also acceptable, else it streams SSE.
+    const callReq = (id: number, name: string, args: Record<string, unknown>) =>
+      new Request(`http://localhost:1940/vault/${vaultName}/mcp`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          accept: "application/json, text/event-stream",
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id,
+          method: "tools/call",
+          params: { name, arguments: args },
+        }),
+      });
+
+    // Fetch the orphan by id through the MCP transport with a token scoped
+    // to ["health"]. The orphan is tagged `health/food` (no schema) → the
+    // string-form fallback resolves the root `health` → in allowlist → the
+    // note must come back rather than 404/forbidden.
+    const res = await handleScopedMcp(callReq(1, "query-notes", { id: orphan.id }), vaultName, auth as any);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as any;
+    // tools/call returns content[].text with the JSON-stringified tool result.
+    expect(body.result?.isError).toBeFalsy();
+    const text: string = body.result.content[0].text;
+    const parsed = JSON.parse(text);
+    expect(parsed.id).toBe(orphan.id);
+    expect(parsed.tags).toContain("health/food");
+
+    // Control: a token scoped to a DIFFERENT root must NOT see the orphan
+    // through the same transport — proves the green result above is the
+    // fail-open fallback firing, not scoping being inert.
+    const denied = {
+      permission: "read" as const,
+      scopes: ["vault:read"],
+      legacyDerived: false,
+      scoped_tags: ["work"],
+    };
+    const resDenied = await handleScopedMcp(
+      callReq(2, "query-notes", { id: orphan.id }),
+      vaultName,
+      denied as any,
+    );
+    expect(resDenied.status).toBe(200);
+    const deniedBody = (await resDenied.json()) as any;
+    const deniedText: string = deniedBody.result.content[0].text;
+    const deniedParsed = JSON.parse(deniedText);
+    // Out-of-scope single-note fetch fails closed: the wrapper replaces the
+    // note body with `{ error: "Note not found" }` (no content/tags leak).
+    // This proves the `health`-scoped green result above is the fail-open
+    // string-form fallback firing, not the wrapper being a no-op.
+    expect(deniedParsed.error).toBe("Note not found");
+    expect(deniedParsed.content).toBeUndefined();
+    expect(deniedParsed.tags).toBeUndefined();
+
+    closeAllStores();
+  });
+
   // -- Q5: MCP delete-tag dependency check -------------------------------
 
   test("MCP delete-tag returns tag_in_use_by_tokens when a vestigial tag-scoped token row references the tag", async () => {
@@ -1769,13 +1862,15 @@ describe("HTTP /notes", async () => {
     expect(body.map((n) => n.content)).toEqual(["plain"]);
   });
 
-  // ---- updated_at filter via date_field (vault#285 friction point 1.5) ----
+  // ---- updated_at filter via bracket date (vault#285 friction point 1.5) ----
   //
-  // HTTP plumbing routes `date_field=updated_at&date_from=…` straight to
-  // the core `dateFilter` resolver, which now recognizes `updated_at` as
-  // a real column. Smoke-tests the end-to-end HTTP path; the engine-side
-  // semantics are exercised in core.test.ts.
-  test("GET /notes?date_field=updated_at filters by last-write time", async () => {
+  // HTTP plumbing routes `meta[updated_at][gte]=…` straight to the core
+  // `dateFilter` resolver, which recognizes `updated_at` as a real column.
+  // Smoke-tests the end-to-end HTTP path; the engine-side semantics are
+  // exercised in core.test.ts. (The flat `date_field=updated_at&date_from=…`
+  // shape was removed in 0.6.4 — vault#288 — bracket-style is the only
+  // query-string date filter.)
+  test("GET /notes?meta[updated_at][gte]=… filters by last-write time", async () => {
     const a = await store.createNote("untouched", { id: "ua", path: "ua" });
     const b = await store.createNote("modified", { id: "ub", path: "ub" });
     // Bump b's updated_at into the test window, leave a's at its createdAt.
@@ -1785,7 +1880,7 @@ describe("HTTP /notes", async () => {
       .run("2026-04-25T00:00:00.000Z", b.id);
 
     const res = await handleNotes(
-      mkReq("GET", "/notes?date_field=updated_at&date_from=2026-04-01&include_content=true"),
+      mkReq("GET", "/notes?meta[updated_at][gte]=2026-04-01&include_content=true"),
       store,
       "",
     );
@@ -2787,7 +2882,7 @@ describe("HTTP /notes", async () => {
     });
 
     // ---- Bridge: created_at / updated_at via brackets route to dateFilter ----
-    test("`meta[created_at][gte]=…` routes to dateFilter (same result as flat date_field)", async () => {
+    test("`meta[created_at][gte]=…` routes to dateFilter", async () => {
       await store.createNote("old", { created_at: "2026-01-15T00:00:00.000Z" });
       await store.createNote("new", { created_at: "2026-04-15T00:00:00.000Z" });
 
@@ -2797,14 +2892,37 @@ describe("HTTP /notes", async () => {
         "",
       );
       const bracketBody = await bracketRes.json() as any[];
-      const flatRes = await handleNotes(
+      expect(bracketBody.map((n) => n.content)).toEqual(["new"]);
+    });
+
+    // ---- Removed: flat date params are now ignored (vault#288, breaking) ----
+    // The flat `date_field` / `date_from` / `date_to` query params were
+    // removed in 0.6.4. A request that passes ONLY the flat shape is no
+    // longer date-filtered — it comes back unfiltered. Use bracket-style
+    // (`meta[created_at][gte]=…`) instead. (The MCP `date_from`/`date_to`
+    // shorthand is a separate, supported path and is unaffected.)
+    test("flat date params (date_field/date_from/date_to) are ignored", async () => {
+      await store.createNote("old", { created_at: "2026-01-15T00:00:00.000Z" });
+      await store.createNote("new", { created_at: "2026-04-15T00:00:00.000Z" });
+
+      const targetedRes = await handleNotes(
         mkReq("GET", "/notes?date_field=created_at&date_from=2026-04-01&include_content=true"),
         store,
         "",
       );
-      const flatBody = await flatRes.json() as any[];
-      expect(bracketBody.map((n) => n.content)).toEqual(["new"]);
-      expect(bracketBody.map((n) => n.content)).toEqual(flatBody.map((n) => n.content));
+      const targetedBody = await targetedRes.json() as any[];
+      expect(targetedRes.status).toBe(200);
+      // Both notes returned — the flat param did not filter.
+      expect(targetedBody.map((n) => n.content).sort()).toEqual(["new", "old"]);
+
+      const bareRes = await handleNotes(
+        mkReq("GET", "/notes?date_from=2026-04-01&include_content=true"),
+        store,
+        "",
+      );
+      const bareBody = await bareRes.json() as any[];
+      expect(bareRes.status).toBe(200);
+      expect(bareBody.map((n) => n.content).sort()).toEqual(["new", "old"]);
     });
 
     test("`meta[updated_at][gte]=…` routes to dateFilter on n.updated_at", async () => {
@@ -2954,13 +3072,14 @@ describe("HTTP /notes", async () => {
       expect(body.error).toContain("not_in");
     });
 
-    // ---- Precedence on overlap ----
-    test("when both flat and bracket date params overlap, bracket wins", async () => {
+    // ---- Bracket applies; co-passed flat params are ignored (vault#288) ----
+    test("bracket date filter applies even when removed flat params are also passed", async () => {
       await store.createNote("old", { created_at: "2026-01-15T00:00:00.000Z" });
       await store.createNote("new", { created_at: "2026-04-15T00:00:00.000Z" });
-      // Bracket says "from 2026-04-01"; flat says "from 2020-01-01". If
-      // flat won, both notes would match. The bracket-wins precedence is
-      // verified by getting back only the post-April note.
+      // Bracket says "from 2026-04-01"; the (removed) flat params say "from
+      // 2020-01-01". The flat params are now inert, so only the bracket
+      // filter applies — back comes only the post-April note. (Pre-0.6.4
+      // this exercised bracket-wins precedence; flat is now simply ignored.)
       const res = await handleNotes(
         mkReq(
           "GET",
@@ -4012,6 +4131,36 @@ describe("HTTP PATCH /notes/:idOrPath (update)", async () => {
     expect(body.metadata).toEqual({ a: 1, b: 2 });
   });
 
+  test("PATCH metadata null DELETES the key (RFC 7386), not a literal null (vault#478/#479)", async () => {
+    await store.createNote("doc", { id: "x", metadata: { keep: "yes", drop: "old", n: 3 } });
+    const res = await handleNotes(
+      mkReq("PATCH", "/notes/x", { metadata: { drop: null }, force: true }),
+      store,
+      "/x",
+    );
+    expect(res.status).toBe(200);
+    const body = await res.json() as any;
+    // Key removed entirely — must NOT survive as a literal JSON null.
+    expect(body.metadata).not.toHaveProperty("drop");
+    expect(body.metadata).toEqual({ keep: "yes", n: 3 });
+    // Persisted state matches the response (round-trips).
+    const fresh = await store.getNote("x");
+    expect(fresh!.metadata).not.toHaveProperty("drop");
+    expect(fresh!.metadata).toEqual({ keep: "yes", n: 3 });
+  });
+
+  test("PATCH metadata key-rename in one call: set new, null-delete old (vault#478)", async () => {
+    await store.createNote("doc", { id: "x", metadata: { "old-key": "v", stable: true } });
+    const res = await handleNotes(
+      mkReq("PATCH", "/notes/x", { metadata: { new_key: "v", "old-key": null }, force: true }),
+      store,
+      "/x",
+    );
+    const body = await res.json() as any;
+    expect(body.metadata).not.toHaveProperty("old-key");
+    expect(body.metadata).toEqual({ new_key: "v", stable: true });
+  });
+
   test("PATCH adds/removes tags", async () => {
     await store.createNote("x", { id: "x", tags: ["old"] });
     const res = await handleNotes(
@@ -4789,6 +4938,28 @@ describe("HTTP /tags", async () => {
       .filter((n) => n.startsWith("meta_"));
   }
 
+  test("PUT /tags/:name with a bad indexed-field name returns 400 + leaves schema unchanged (vault#478)", async () => {
+    // kebab-case indexed field violates [A-Za-z0-9_]. Pre-fix this persisted
+    // the declaration then 500'd on index creation, leaving a tag claiming an
+    // index the engine couldn't build (the "lying schema" loop).
+    const res = await handleTags(
+      mkReq("PUT", "/tags/meeting", { fields: { "meeting-type": { type: "string", indexed: true } } }),
+      store,
+      "/meeting",
+    );
+    expect(res.status).toBe(400);
+    const body = await res.json() as any;
+    expect(body.error_type).toBe("invalid_indexed_field");
+    expect(body.error).toMatch(/invalid field name/);
+
+    // Schema is untouched — no poisoned field declared.
+    const record = await store.getTagRecord("meeting");
+    expect(record?.fields?.["meeting-type"]).toBeUndefined();
+    // No orphan/lying index: neither the generated column nor an indexed_fields row.
+    expect(notesMetaCols()).not.toContain("meta_meeting-type");
+    expect(buildVaultProjection(db).indexed_fields.map((f) => f.name)).not.toContain("meeting-type");
+  });
+
   test("PUT /tags/:name {fields:null} drops the orphaned generated column", async () => {
     // Declare an indexed field via REST PUT — column materializes.
     await handleTags(