@openparachute/vault 0.6.4-rc.5 → 0.6.4-rc.7

package/README.md

@@ -586,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openparachute/vault",
-  "version": "0.6.4-rc.5",
+  "version": "0.6.4-rc.7",
   "description": "Agent-native knowledge graph. Notes, tags, links over MCP.",
   "module": "src/cli.ts",
   "type": "module",

package/src/import-daemon-busy.test.ts

@@ -15,30 +15,21 @@ import { resolve } from "path";
 import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
+import { runSubprocess } from "./test-support/spawn.ts";
 
 const CLI = resolve(import.meta.dir, "cli.ts");
 
+// Async spawn — the daemon-busy probe inside the CLI fetches the test
+// process's stub server, so the parent event loop must keep servicing
+// requests while the child runs. `Bun.spawnSync` blocks the event loop and
+// the in-test server can't answer, which makes every probe time out into
+// the "not listening" branch (vault#324). `runSubprocess` is the shared
+// safe primitive (vault#325 Part 1) — see src/test-support/spawn.ts.
 async function runCli(
   args: string[],
   env: Record<string, string>,
 ): Promise<{ exitCode: number; stdout: string; stderr: string }> {
-  // Async spawn — the daemon-busy probe inside the CLI fetches the test
-  // process's stub server, so the parent event loop must keep servicing
-  // requests while the child runs. Bun.spawnSync blocks the event loop
-  // and the in-test server can't answer, which makes every probe time
-  // out into the "not listening" branch.
-  const proc = Bun.spawn({
-    cmd: ["bun", CLI, ...args],
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...process.env, ...env },
-  });
-  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 };
+  return runSubprocess({ cmd: ["bun", CLI, ...args], env });
 }
 
 let home: string;

package/src/routes.ts

@@ -328,7 +328,7 @@ function parseMetaBrackets(url: URL): {
         return {
           error: json(
             {
-              error: `bracket-date filter on \`${field}\` supports only \`gte\` (inclusive lower bound) and \`lt\` (exclusive upper bound). Got: \`${op}\`. The dateFilter contract uses these two ops because the equivalent flat shape (\`date_field=${field}&date_from=…&date_to=…\`) is half-open by design.`,
+              error: `bracket-date filter on \`${field}\` supports only \`gte\` (inclusive lower bound) and \`lt\` (exclusive upper bound). Got: \`${op}\`. The dateFilter contract is half-open by design.`,
               code: "INVALID_QUERY",
             },
             400,
@@ -623,20 +623,13 @@ export function parseNotesQueryOpts(url: URL): {
     lastUpdatedBy: parseQuery(url, "last_updated_by") ?? undefined,
     createdVia: parseQuery(url, "created_via") ?? undefined,
     lastUpdatedVia: parseQuery(url, "last_updated_via") ?? undefined,
-    ...(bracket.dateFilter
-      ? { dateFilter: bracket.dateFilter }
-      : parseQuery(url, "date_field")
-        ? {
-            dateFilter: {
-              field: parseQuery(url, "date_field")!,
-              from: parseQuery(url, "date_from") ?? undefined,
-              to: parseQuery(url, "date_to") ?? undefined,
-            },
-          }
-        : {
-            dateFrom: parseQuery(url, "date_from") ?? undefined,
-            dateTo: parseQuery(url, "date_to") ?? undefined,
-          }),
+    // Date-range filtering on the query string is bracket-style only:
+    // `?meta[created_at][gte]=…&meta[created_at][lt]=…` (see
+    // `parseMetaBrackets`). The flat `date_field` / `date_from` / `date_to`
+    // params were removed in 0.6.4 (vault#288, breaking) — they are now
+    // ignored. The MCP `date_from` / `date_to` shorthand is a separate,
+    // supported convenience and is unaffected.
+    ...(bracket.dateFilter ? { dateFilter: bracket.dateFilter } : {}),
     sort: (parseQuery(url, "sort") as "asc" | "desc") ?? undefined,
     orderBy: parseQuery(url, "order_by") ?? undefined,
     limit: parseInt10(parseQuery(url, "limit")) ?? 50,
@@ -907,7 +900,7 @@ async function handleNotesInner(
 
       // Structured query
       //
-      // Two filter syntaxes coexist on this endpoint:
+      // Date-range filtering on the query string uses one syntax:
       //
       //   - **Bracket-style** (canonical, vault#285 friction point 1.3):
       //     `?meta[field][op]=value` / `?meta[created_at][gte]=…`. Exposes
@@ -915,21 +908,18 @@ async function handleNotesInner(
       //     not_in/exists) and the dateFilter bridge through one consistent
       //     shape. See `parseMetaBrackets` for the grammar.
       //
-      //   - **Flat date params** (DEPRECATED): `?date_field=created_at&
-      //     date_from=…&date_to=…` and the legacy `?date_from=…&date_to=…`.
-      //     Still functional through 0.5.x; planned removal in a later 0.x
-      //     (vault#288). New consumers should use bracket-style.
-      //
-      // Precedence on overlap: bracket-style wins. If a caller passes both
-      // `meta[created_at][gte]=X` and `date_field=created_at&date_from=Y`,
-      // the bracket form is the dateFilter the engine sees; the flat
-      // params are silently dropped. We don't error — the bracket form is
-      // documented as canonical, and rejecting the overlap would block a
-      // realistic migration path where a caller half-converted their code.
+      // The flat date params (`?date_field=created_at&date_from=…&date_to=…`
+      // and the legacy bare `?date_from=…&date_to=…`) were REMOVED in 0.6.4
+      // (vault#288, breaking change). They are now silently ignored — a
+      // request that passes only flat date params comes back unfiltered.
+      // Bracket-style is functionally complete (full operator set), so no
+      // capability was lost. Migrate `date_field=created_at&date_from=X` to
+      // `meta[created_at][gte]=X` (and `date_to=Y` to `meta[created_at][lt]=Y`).
       //
       // Surface asymmetry: REST flattens to a query string; MCP takes a
-      // nested `date_filter: { field, from, to }` object directly. Both
-      // lower to the same store-level `dateFilter` shape.
+      // nested `date_filter: { field, from, to }` object directly (plus a
+      // top-level `date_from` / `date_to` shorthand, which is unaffected by
+      // this removal). Both lower to the same store-level `dateFilter` shape.
       // Structured-query parsing is shared with the live `/subscribe` route
       // (see `parseNotesQueryOpts`) so both endpoints lower an identical query
       // string to the same `QueryOpts` — predicate parity by construction.

package/src/scale.bench.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Opt-in scale smoke (vault#325 Part 3).
+ *
+ * Guards the synthetic scale harness against bit-rot WITHOUT slowing the
+ * default `bun test` gate. The real benchmark lives in
+ * `scripts/scale-bench.ts` (10k / 50k / 100k); this is a fast, tiny-size
+ * functional smoke of the same hot-path code so a green CI run still
+ * proves the harness paths execute end-to-end.
+ *
+ * SKIPPED BY DEFAULT. To run it:
+ *
+ *   VAULT_SCALE_BENCH=1 bun test ./src/scale.bench.test.ts
+ *
+ * For real timings + the documented ceiling, run the standalone harness:
+ *
+ *   bun scripts/scale-bench.ts          # 10000 50000 100000
+ *
+ * See docs/SCALE.md.
+ */
+
+import { describe, test, expect } from "bun:test";
+import { Database } from "bun:sqlite";
+import { BunSqliteStore } from "../core/src/store.ts";
+import { generateMcpTools } from "../core/src/mcp.ts";
+import { exportVaultToDir } from "../core/src/portable-md.ts";
+import type { BulkNoteInput } from "../core/src/notes.ts";
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+const ENABLED = process.env.VAULT_SCALE_BENCH === "1";
+
+// `describe.skipIf` keeps the suite registered (so it shows in the test list)
+// but contributes zero runtime to the default gate. Size is intentionally
+// tiny — this is a functional smoke, not a timing run.
+describe.skipIf(!ENABLED)("scale harness smoke (opt-in: VAULT_SCALE_BENCH=1)", () => {
+  test("seed + hot-path queries + export run at small N", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "vault-scale-smoke-"));
+    const db = new Database(join(dir, "smoke.db"));
+    const store = new BunSqliteStore(db);
+    try {
+      const N = 500;
+
+      // Declare the indexed field via the update-tag tool (the owner of the
+      // indexed_fields lifecycle — mirrors scripts/scale-bench.ts).
+      const tools = generateMcpTools(store);
+      const updateTag = tools.find((t) => t.name === "update-tag");
+      expect(updateTag).toBeDefined();
+      await updateTag!.execute({
+        tag: "work",
+        fields: { status: { type: "string", indexed: true } },
+      });
+
+      const inputs: BulkNoteInput[] = Array.from({ length: N }, (_, i) => ({
+        id: `note-${i}`,
+        path: `notes/note-${i}`,
+        content: `# Note ${i}\n\nconsectetur body ${i}`,
+        tags: i % 3 === 0 ? ["work", "work/meeting"] : ["health"],
+        metadata: { status: i % 2 === 0 ? "active" : "done", seq: i },
+      }));
+      await store.createNotes(inputs);
+
+      // Hot paths — same shapes the standalone harness times.
+      expect((await store.queryNotes({ tags: ["health"], limit: 50 })).length).toBeGreaterThan(0);
+      expect(
+        (await store.queryNotes({ metadata: { status: { eq: "active" } }, limit: 50 })).length,
+      ).toBeGreaterThan(0);
+      expect((await store.queryNotes({ orderBy: "status", limit: 50 })).length).toBe(50);
+      expect((await store.searchNotes("consectetur", { limit: 50 })).length).toBeGreaterThan(0);
+
+      const stats = await exportVaultToDir(store, {
+        outDir: join(dir, "export"),
+        vaultName: "smoke",
+        exportedAt: "2026-01-01T00:00:00Z",
+      });
+      expect(stats.notes).toBe(N);
+    } finally {
+      db.close();
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

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/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",