@openparachute/vault 0.7.3-rc.2 → 0.7.3-rc.4

package/core/src/schema-defaults.ts

@@ -41,6 +41,7 @@
  */
 
 import { Database } from "bun:sqlite";
+import { timestampToMs } from "./cursor.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -57,7 +58,7 @@ export interface SchemaField {
    * `type_mismatch` warning that previously fired on every integer-shaped
    * field because the validator had no `"integer"` case. See vault#310.
    */
-  type?: "string" | "number" | "integer" | "boolean" | "array" | "object" | "reference";
+  type?: "string" | "number" | "integer" | "boolean" | "array" | "object" | "reference" | "date";
   enum?: string[];
   description?: string;
   /**
@@ -320,6 +321,82 @@ export function resolveNoteSchemas(
   return { effectiveTags, mergedFields, conflicts };
 }
 
+/**
+ * Normalize `date`-typed field VALUES in `metadata` to canonical UTC ISO
+ * form (`Z`-suffixed) BEFORE persisting (vault#date-field-type — mixed-
+ * offset corruption, caught in review).
+ *
+ * The bug: every consumer of an indexed `date` field — `buildOperatorClause`
+ * (query-operators.ts), `date_filter` and `order_by` (notes.ts) — compares
+ * the generated `meta_<field>` column as raw TEXT. ISO-8601 strings sort
+ * correctly under a TEXT compare ONLY when every value shares the same
+ * offset representation. `timestampToMs` (cursor.ts) — the validator both
+ * `defaultMatchesType` and `valueMatchesType` reuse — correctly ACCEPTS an
+ * explicit `±HH:MM` offset (validation was never the gap), but a value like
+ * `"2026-07-16T10:00:00+02:00"` (= `08:00Z`) persisted VERBATIM sorts AFTER
+ * `"2026-07-16T09:00:00Z"` (= `09:00Z`) under a raw string compare, even
+ * though the actual instant is earlier — a mixed-offset vault silently gets
+ * wrong range-query/order_by/date_filter results. This is the exact bug
+ * class `updated_at` got a dedicated ms-mirror column for (vault#585/#586,
+ * see `notes.ts`'s `dateFilter` block) that never extended to user-declared
+ * `date` fields.
+ *
+ * The fix is normalize-on-write, not reject-on-write (matching the
+ * "paths are normalized on write" precedent — instant preserved,
+ * representation canonicalized) — rejecting offsets would defeat the
+ * type's own motivation (calendar integrations and other emitters commonly
+ * produce offset timestamps, not always `Z`). Only a FULL timestamp (has a
+ * time component) is rewritten, to `new Date(ms).toISOString()` — always
+ * UTC, millisecond precision, `Z`-suffixed. A bare `YYYY-MM-DD` value is
+ * left untouched: it has no offset to normalize, is already canonical, and
+ * prefix-sorts correctly against full timestamps sharing the same calendar
+ * day. A value that fails `timestampToMs` is left untouched too — that's a
+ * `type_mismatch` for `valueMatchesType` to catch, not this function's job.
+ *
+ * COPY-ON-WRITE, never mutates the input `metadata` object (vault#date-
+ * field-type review round 2) — `core/` is a published library; a direct
+ * embedder holding a reference to the object THEY passed in must never see
+ * it change out from under them. Returns the SAME reference when nothing
+ * needs rewriting (the common case — no unnecessary allocation on the
+ * no-op path) or `metadata` is undefined; returns a freshly shallow-copied
+ * object, with only the rewritten field(s) replaced, the first time a
+ * rewrite is actually needed. Every call site must use the RETURNED value
+ * (not assume its input was mutated) — see `store.createNote`/`updateNote`/
+ * `createNotes`/`createNoteRaw`, all of which reassign their local
+ * `opts`/`updates`/`input` binding from the return rather than relying on a
+ * side effect.
+ *
+ * Called from `store.createNote`/`updateNote`/`createNotes`/`createNoteRaw`
+ * — the lowest chokepoint every write path (MCP, REST, import) funnels
+ * through — BEFORE the row is persisted, so the value that's validated by
+ * `validateNote`/`valueMatchesType` upstream (offset-tolerant, so
+ * normalization can't newly fail a write) and the value that's written +
+ * echoed back on the response are the SAME normalized string.
+ */
+export function normalizeDateFields(
+  resolved: ResolvedSchemas,
+  note: { tags?: string[]; metadata?: Record<string, unknown> },
+): Record<string, unknown> | undefined {
+  const metadata = note.metadata;
+  if (!metadata) return metadata;
+  const { mergedFields } = resolveNoteSchemas(resolved, note);
+  let copy: Record<string, unknown> | undefined;
+  for (const [fieldName, { spec }] of mergedFields) {
+    if (spec.type !== "date") continue;
+    const value = metadata[fieldName];
+    if (typeof value !== "string") continue;
+    // Bare `YYYY-MM-DD` (no time component) has no offset to normalize.
+    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) continue;
+    const ms = timestampToMs(value);
+    if (ms === null) continue; // unparseable — valueMatchesType's job, not ours
+    const canonical = new Date(ms).toISOString();
+    if (canonical === value) continue;
+    if (!copy) copy = { ...metadata }; // lazy: only copy once a rewrite is due
+    copy[fieldName] = canonical;
+  }
+  return copy ?? metadata;
+}
+
 function fieldSpecsEqual(a: SchemaField, b: SchemaField): boolean {
   if (a.type !== b.type) return false;
   if (!stringArraysEqual(a.enum, b.enum)) return false;
@@ -390,6 +467,13 @@ function valueMatchesType(value: unknown, type: SchemaField["type"], cardinality
         return Array.isArray(value) && value.every((item) => typeof item === "string");
       }
       return typeof value === "string";
+    // `date` validates like `string` — an ISO-8601 date (`YYYY-MM-DD`) or
+    // full RFC3339 timestamp. Reuses `cursor.ts`'s `timestampToMs` (the SAME
+    // UTC-correct parser `date_filter`'s `updated_at` bound uses), not a
+    // second date parser — see tag-schemas.ts's `VALID_FIELD_TYPES` doc
+    // comment.
+    case "date":
+      return typeof value === "string" && timestampToMs(value) !== null;
   }
 }
 

package/core/src/seed-packs.test.ts

@@ -20,7 +20,10 @@
 
 import { describe, test, expect } from "bun:test";
 import {
+  ALL_NOTES_VIEW_PATH,
   applySeedPack,
+  ARCHIVE_VIEW_PATH,
+  ARCHIVED_TAG,
   CAPTURE_ANYTHING_PATH,
   CONNECT_AI_PATH,
   DEFAULT_VAULT_DESCRIPTION,
@@ -33,11 +36,17 @@ import {
   GUIDE_TAG,
   listSeedPacks,
   NOTES_REQUIRED_TAGS,
+  PINNED_TAG,
+  PINNED_VIEW_PATH,
+  RECENT_VIEW_PATH,
   SEED_PACK_NAMES,
+  STARTER_ONTOLOGY_PACK,
   SURFACE_STARTER_CONTENT,
   SURFACE_STARTER_PACK,
   SURFACE_STARTER_PATH,
   TAGS_GRAPH_PATH,
+  VIEW_TAG,
+  VIEWS_PATH_PREFIX,
   WELCOME_PATH,
   welcomePack,
   YOURS_TO_KEEP_PATH,
@@ -335,12 +344,119 @@ describe("surface-starter pack", () => {
   });
 });
 
+describe("starter-ontology pack", () => {
+  test("exactly four tags, in constitution order: view, archived, pinned, capture", () => {
+    expect(STARTER_ONTOLOGY_PACK.name).toBe("starter-ontology");
+    expect(STARTER_ONTOLOGY_PACK.tags.map((t) => t.name)).toEqual([
+      "view",
+      "archived",
+      "pinned",
+      "capture",
+    ]);
+  });
+
+  test("opt-in, not seeded by default", () => {
+    expect(STARTER_ONTOLOGY_PACK.description).toContain("Opt-in — not seeded by default.");
+  });
+
+  test("view is the one meta tag — carries the kind/query/lane_by/date_field schema", () => {
+    expect(VIEW_TAG.name).toBe("view");
+    expect(VIEW_TAG.description).toContain("meta tag");
+    expect(VIEW_TAG.fields).toBeDefined();
+    expect(Object.keys(VIEW_TAG.fields!)).toEqual([
+      "kind",
+      "query",
+      "lane_by",
+      "date_field",
+    ]);
+
+    const kind = VIEW_TAG.fields!.kind!;
+    expect(kind.type).toBe("string");
+    expect(kind.enum).toEqual(["list", "board", "calendar", "gallery"]);
+    expect(kind.default).toBe("list");
+
+    const query = VIEW_TAG.fields!.query!;
+    expect(query.type).toBe("string");
+
+    // lane_by / date_field are optional (no default — absent stays absent).
+    expect(VIEW_TAG.fields!.lane_by!.default).toBeUndefined();
+    expect(VIEW_TAG.fields!.date_field!.default).toBeUndefined();
+  });
+
+  test("archived + pinned are plain tags — no schema", () => {
+    expect(ARCHIVED_TAG.name).toBe("archived");
+    expect(ARCHIVED_TAG.fields).toBeUndefined();
+    expect(ARCHIVED_TAG.description).toContain("out of the flow of the present");
+
+    expect(PINNED_TAG.name).toBe("pinned");
+    expect(PINNED_TAG.fields).toBeUndefined();
+    expect(PINNED_TAG.description).toContain("partition");
+  });
+
+  test("capture is reused verbatim from NOTES_REQUIRED_TAGS — byte-equal, no drift risk", () => {
+    const capture = STARTER_ONTOLOGY_PACK.tags.find((t) => t.name === "capture");
+    expect(capture).toBe(NOTES_REQUIRED_TAGS[0]); // SAME object reference, not just equal content
+    expect(capture!.description).toBe(NOTES_REQUIRED_TAGS[0]!.description);
+  });
+
+  test("four seed #view notes mirroring the app's default pages", () => {
+    expect(STARTER_ONTOLOGY_PACK.notes.map((n) => n.path)).toEqual([
+      ALL_NOTES_VIEW_PATH,
+      RECENT_VIEW_PATH,
+      PINNED_VIEW_PATH,
+      ARCHIVE_VIEW_PATH,
+    ]);
+    for (const note of STARTER_ONTOLOGY_PACK.notes) {
+      expect(note.path.startsWith(VIEWS_PATH_PREFIX)).toBe(true);
+      expect(note.tags).toEqual(["view"]);
+      expect(note.metadata?.kind).toBe("list");
+      expect(typeof note.metadata?.query).toBe("string");
+      // Every seeded query must itself be valid JSON — a downstream reader
+      // parses it as query-notes params.
+      expect(() => JSON.parse(note.metadata!.query as string)).not.toThrow();
+    }
+  });
+
+  test("All notes / Recent exclude archived explicitly (authoring-time default, not magic)", () => {
+    for (const path of [ALL_NOTES_VIEW_PATH, RECENT_VIEW_PATH]) {
+      const note = noteAt(STARTER_ONTOLOGY_PACK, path);
+      const query = JSON.parse(note.metadata!.query as string);
+      expect(query.exclude_tags).toEqual(["archived"]);
+    }
+  });
+
+  test("Recent orders by updated_at desc", () => {
+    const query = JSON.parse(noteAt(STARTER_ONTOLOGY_PACK, RECENT_VIEW_PATH).metadata!.query as string);
+    expect(query.order_by).toBe("updated_at");
+    expect(query.sort).toBe("desc");
+  });
+
+  test("Pinned queries tag:pinned; Archive queries tag:archived (the deliberate exception to exclude_tags)", () => {
+    const pinnedQuery = JSON.parse(noteAt(STARTER_ONTOLOGY_PACK, PINNED_VIEW_PATH).metadata!.query as string);
+    expect(pinnedQuery.tag).toBe("pinned");
+
+    const archiveQuery = JSON.parse(noteAt(STARTER_ONTOLOGY_PACK, ARCHIVE_VIEW_PATH).metadata!.query as string);
+    expect(archiveQuery.tag).toBe("archived");
+    expect(archiveQuery.exclude_tags).toBeUndefined();
+  });
+
+  test("no dangling wikilinks within the pack", () => {
+    const seededPaths = new Set(STARTER_ONTOLOGY_PACK.notes.map((n) => n.path));
+    for (const note of STARTER_ONTOLOGY_PACK.notes) {
+      for (const target of wikilinkTargets(note.content)) {
+        expect(seededPaths.has(target)).toBe(true);
+      }
+    }
+  });
+});
+
 describe("pack registry", () => {
-  test("lists exactly the three packs, in order", () => {
+  test("lists exactly the four packs, in order", () => {
     expect([...SEED_PACK_NAMES]).toEqual([
       "welcome",
       "getting-started",
       "surface-starter",
+      "starter-ontology",
     ]);
     expect(listSeedPacks().map((p) => p.name)).toEqual([...SEED_PACK_NAMES]);
     for (const p of listSeedPacks()) {

package/core/src/seed-packs.ts

@@ -14,6 +14,13 @@
  *     surface (UI) over the vault. NOT default-seeded (ratified 2026-07-02:
  *     Surface Starter is out of the default seed) — added on demand via
  *     `parachute-vault add-pack surface-starter` or a console affordance.
+ *   - `starter-ontology` — four starter **meta tags** (`view`, `archived`,
+ *     `pinned`, `capture`) with constitution-style descriptions, plus seed
+ *     `#view` notes mirroring the app's default pages (All notes, Recent,
+ *     Pinned, Archive). NOT default-seeded (ratified 2026-07-16 design
+ *     dialogue — deliberately opt-in; a fresh-vault materialization change
+ *     needs its own decision) — added on demand via `parachute-vault
+ *     add-pack starter-ontology` or a console affordance.
  *
  * Guides are the vault's skill files — the Parachute equivalent of a
  * `SKILL.md`. They're tagged `#guide` (GUIDE_TAG): notes that teach how this
@@ -798,6 +805,172 @@ export const SURFACE_STARTER_PACK: SeedPack = {
   ],
 };
 
+// ---------------------------------------------------------------------------
+// `starter-ontology` pack — four starter meta tags (opt-in)
+// ---------------------------------------------------------------------------
+
+/**
+ * The starter ontology, ratified in the 2026-07-16 design dialogue (Letter 1,
+ * Q5: "yes — tiny, opinionated, removable"): exactly four tags, no more.
+ * "Really want to start simple" / "don't be too prescriptive" — the vault
+ * ships the mechanisms; each parachute writes its own rules on top.
+ *
+ * A **meta tag** (the ratified user-facing term for "a tag with a schema")
+ * is `view` alone here — it carries `fields`. `archived`, `pinned`, and
+ * `capture` are plain tags: no schema, just a description that teaches the
+ * convention. Every description below is written as a constitution — it's
+ * read by both a human deciding whether to use the tag and an agent deciding
+ * how to behave around it — plain and warm, describing the DEFAULT
+ * convention rather than dictating one ("different people will draw that
+ * line differently").
+ *
+ * `capture` is NOT redeclared with new text — it's the exact `NOTES_REQUIRED_TAGS`
+ * entry, reused verbatim, because notes-ui's connect-time schema audit
+ * compares its `description` byte-for-byte (see the comment on
+ * `NOTES_REQUIRED_TAGS` above). Applying this pack must never be able to
+ * drift that string out from under the welcome pack, in either apply order.
+ *
+ * `pinned` shipped once before and was dropped as vestigial (PR #547,
+ * 2026-07-07): it was seeded onto `Welcome` with old sort-first semantics,
+ * which did nothing visible on a fresh vault (the Notes app had no list
+ * badge, and Welcome was already first). This is a different tag: the
+ * ratified semantics are partition-not-sort, it isn't stamped onto any
+ * existing note, and the pack ships a `Pinned` view that actually surfaces
+ * it.
+ */
+export const VIEW_TAG: SeedPackTag = {
+  name: "view",
+  description:
+    'A meta tag — it carries a schema, which is what makes a #view note a saved view rather than just a label. Tag a note #view and its metadata becomes the definition: `query` is the saved query itself (the same JSON shape query-notes accepts — tag, exclude_tags, search, metadata, order_by, ...), and `kind` says how to render the result (list, board, calendar, or gallery; an unrecognized or missing kind should degrade to list rather than fail — a view is never wrong to render as a list). `lane_by` names the metadata field a board\'s lanes come from; `date_field` names the date-typed field a calendar plots against — both only meaningful for their matching `kind`, and unset otherwise. The note\'s body is for people: what this view is for, when to reach for it. Because the definition lives in the vault as an ordinary note, any surface can read it and render the same view, and any agent can write one — "make me a board of my active drafts" is just creating a note. Authoring convention worth keeping: most views should write `exclude_tags: ["archived"]` into their own query rather than leaning on some surface-side default — an Archive view is the deliberate exception.',
+  fields: {
+    kind: {
+      type: "string",
+      description:
+        "How to render this view. Unrecognized or absent degrades to list — a view is never wrong to render as a list.",
+      enum: ["list", "board", "calendar", "gallery"],
+      default: "list",
+    },
+    query: {
+      type: "string",
+      description:
+        "The saved query — a JSON string of query-notes parameters (tag, exclude_tags, search, metadata, order_by, sort, ...). This is what actually determines which notes the view shows; kind only says how to draw them.",
+    },
+    lane_by: {
+      type: "string",
+      description:
+        "Board views only: the metadata field whose distinct values become the board's lanes/columns. Unset outside kind: board.",
+    },
+    date_field: {
+      type: "string",
+      description:
+        "Calendar views only: the date-typed metadata field the calendar plots notes against. Unset outside kind: calendar.",
+    },
+  },
+};
+
+export const ARCHIVED_TAG: SeedPackTag = {
+  name: "archived",
+  description:
+    "A plain tag — no schema, just a convention: this note is out of the flow of the present. Not deleted, not wrong, just done, closed, or set aside for now. The one behavior worth relying on: default views exclude archived notes unless a view's own query says otherwise (an Archive view, for instance, asks for them back on purpose). Archiving a note doesn't touch its content, tags, or links — it only changes whether it shows up by default. What actually gets archived, and when, is yours to decide: a finished project, last month's drafts, a conversation that's resolved. Different people will draw that line differently, and that's fine — the tag only promises the one thing above.",
+};
+
+export const PINNED_TAG: SeedPackTag = {
+  name: "pinned",
+  description:
+    "A plain tag — no schema, just a convention: this note gets surfaced first. Pinning is a partition, not a sort — a view that honors it renders pinned notes as their own small group above everything else, rather than nudging them up the existing order. That also means pinning doesn't fight with however the rest of a view is sorted; it just carves out a \"see this first\" spot above it. There's no built-in limit on how many notes can be pinned, and no rule about what belongs there — a current focus, something you keep needing to find, a note you're mid-thought on. Unpin by removing the tag. Different people, and different views, will use it differently; the tag only promises the placement, not the policy.",
+};
+
+export const VIEWS_PATH_PREFIX = "Views/";
+export const ALL_NOTES_VIEW_PATH = `${VIEWS_PATH_PREFIX}All notes`;
+export const RECENT_VIEW_PATH = `${VIEWS_PATH_PREFIX}Recent`;
+export const PINNED_VIEW_PATH = `${VIEWS_PATH_PREFIX}Pinned`;
+export const ARCHIVE_VIEW_PATH = `${VIEWS_PATH_PREFIX}Archive`;
+
+/**
+ * Build the `starter-ontology` pack: the four meta tags above, plus four
+ * seed `#view` notes mirroring the app's default pages — All notes, Recent,
+ * Pinned, Archive — so "default app pages are shipped views" has its data
+ * half from day one. Each view's `query` is written out explicitly
+ * (`exclude_tags: ["archived"]` where it applies) rather than relying on any
+ * surface-side default, per the authoring convention in `VIEW_TAG`'s own
+ * description. Kept tiny on purpose — these are starting points, not a
+ * demonstration of everything the schema can do.
+ *
+ * NOT applied by `src/onboarding-seed.ts`'s default materialization — opt-in
+ * only, via `parachute-vault add-pack starter-ontology` or a console
+ * affordance. A fresh-vault UX change (making this part of the default seed)
+ * is a separate decision; this pack existing makes that a one-line flip
+ * later, deliberately not taken here.
+ */
+export const STARTER_ONTOLOGY_PACK: SeedPack = {
+  name: "starter-ontology",
+  description:
+    "The starter ontology: one meta tag (view, with a schema) and three plain tags (archived, pinned, capture), each with a constitution-style description — plus four seed #view notes (All notes, Recent, Pinned, Archive) mirroring the app's default pages. Opt-in — not seeded by default.",
+  // `capture` reused verbatim from NOTES_REQUIRED_TAGS (byte-equal to the
+  // welcome pack's — see the module doc above and NOTES_REQUIRED_TAGS'
+  // comment). Order matches the constitution ordering, not upsert order.
+  tags: [VIEW_TAG, ARCHIVED_TAG, PINNED_TAG, ...NOTES_REQUIRED_TAGS],
+  notes: [
+    {
+      path: ALL_NOTES_VIEW_PATH,
+      tags: ["view"],
+      content: `# All notes
+
+Everything in the vault except what's archived. The default view — no tag
+filter, no sort override, just the whole thing minus the notes you've set
+aside.
+`,
+      metadata: {
+        kind: "list",
+        query: JSON.stringify({ exclude_tags: ["archived"] }),
+      },
+    },
+    {
+      path: RECENT_VIEW_PATH,
+      tags: ["view"],
+      content: `# Recent
+
+The vault, newest edits first. Same notes as [[${ALL_NOTES_VIEW_PATH}]] —
+archived excluded — just ordered by when they last changed.
+`,
+      metadata: {
+        kind: "list",
+        query: JSON.stringify({
+          exclude_tags: ["archived"],
+          order_by: "updated_at",
+          sort: "desc",
+        }),
+      },
+    },
+    {
+      path: PINNED_VIEW_PATH,
+      tags: ["view"],
+      content: `# Pinned
+
+Whatever you've marked #pinned — the notes surfaced first, regardless of how
+anything else in the vault is organized.
+`,
+      metadata: {
+        kind: "list",
+        query: JSON.stringify({ tag: "pinned" }),
+      },
+    },
+    {
+      path: ARCHIVE_VIEW_PATH,
+      tags: ["view"],
+      content: `# Archive
+
+Everything tagged #archived — out of the flow of the present, but never
+gone. The one view that asks archived notes back on purpose.
+`,
+      metadata: {
+        kind: "list",
+        query: JSON.stringify({ tag: "archived" }),
+      },
+    },
+  ],
+};
+
 // ---------------------------------------------------------------------------
 // Registry
 // ---------------------------------------------------------------------------
@@ -807,6 +980,7 @@ export const SEED_PACK_NAMES = [
   "welcome",
   "getting-started",
   "surface-starter",
+  "starter-ontology",
 ] as const;
 
 export type SeedPackName = (typeof SEED_PACK_NAMES)[number];
@@ -835,6 +1009,8 @@ export function getSeedPack(
       return GETTING_STARTED_PACK;
     case "surface-starter":
       return SURFACE_STARTER_PACK;
+    case "starter-ontology":
+      return STARTER_ONTOLOGY_PACK;
     default:
       return null;
   }

package/core/src/store.ts

@@ -38,6 +38,7 @@ import {
   loadSchemaConfig,
   validateNote as runValidateNote,
   resolveNoteSchemas,
+  normalizeDateFields,
   type ResolvedSchemas,
   type ValidationStatus,
 } from "./schema-defaults.js";
@@ -500,6 +501,16 @@ export class BunSqliteStore implements Store {
   // ---- Notes ----
 
   async createNote(content: string, opts?: { id?: string; path?: string; tags?: string[]; metadata?: Record<string, unknown>; created_at?: string; extension?: string; actor?: string | null; via?: string | null }): Promise<Note> {
+    // Normalize `date`-typed field values to canonical UTC ISO form BEFORE
+    // the write (vault#date-field-type — mixed-offset TEXT-compare
+    // corruption). COPY-ON-WRITE (round 2) — reassign the local `opts`
+    // binding from the returned value rather than mutating the caller's
+    // object; see `normalizeDateFields`'s doc comment.
+    if (opts?.metadata) {
+      const normalized = normalizeDateFields(this.getSchemaConfig(), { tags: opts.tags, metadata: opts.metadata });
+      if (normalized !== opts.metadata) opts = { ...opts, metadata: normalized };
+    }
+
     const note = noteOps.createNote(this.db, content, opts);
 
     if (content) {
@@ -548,6 +559,20 @@ export class BunSqliteStore implements Store {
       actor?: string | null;
       via?: string | null;
       if_updated_at?: string;
+      /**
+       * `date`-field normalization override (vault#date-field-type review
+       * round 2). By default, `normalizeDateFields` below resolves the note's
+       * effective schema against its CURRENT tags in the DB — correct when
+       * this call doesn't also change tags. A caller that adds a tag IN THIS
+       * SAME logical update (via a separate `store.tagNote` issued right
+       * after this call — see mcp.ts's `update-note` handler and the batch
+       * upsert "update"/"replace" branch) must pass the PROJECTED final tag
+       * set here instead, or a newly-added tag's `type: "date"` field never
+       * gets seen (the schema resolution would still be looking at the
+       * pre-write tag set) and its offset-bearing value would persist
+       * verbatim. Ignored when `updates.metadata` is undefined.
+       */
+      tagsForSchemaResolution?: string[];
     },
   ): Promise<Note> {
     let oldPath: string | undefined;
@@ -561,7 +586,19 @@ export class BunSqliteStore implements Store {
     if (updates.path !== undefined || updates.metadata !== undefined) {
       const existing = noteOps.getNote(this.db, id);
       if (updates.path !== undefined) oldPath = existing?.path;
-      if (updates.metadata !== undefined) priorMetadataForRefs = existing?.metadata;
+      if (updates.metadata !== undefined) {
+        priorMetadataForRefs = existing?.metadata;
+        // Normalize `date`-typed field values to canonical UTC ISO form
+        // BEFORE the write (vault#date-field-type — mixed-offset TEXT-
+        // compare corruption). COPY-ON-WRITE (round 2) — reassign the local
+        // `updates` binding from the returned value rather than mutating the
+        // caller's object; see `normalizeDateFields`'s doc comment.
+        // `tagsForSchemaResolution` (when the caller is ALSO adding a tag in
+        // this same logical update) wins over the note's current DB tags.
+        const tagsForResolution = updates.tagsForSchemaResolution ?? existing?.tags;
+        const normalized = normalizeDateFields(this.getSchemaConfig(), { tags: tagsForResolution, metadata: updates.metadata });
+        if (normalized !== updates.metadata) updates = { ...updates, metadata: normalized };
+      }
     }
 
     const note = noteOps.updateNote(this.db, id, updates);
@@ -1034,7 +1071,18 @@ export class BunSqliteStore implements Store {
   // ---- Bulk Operations ----
 
   async createNotes(inputs: noteOps.BulkNoteInput[]): Promise<Note[]> {
-    const notes = noteOps.createNotes(this.db, inputs);
+    // Same pre-write `date`-field normalization as singleton createNote
+    // (vault#date-field-type) — this bulk path bypasses it otherwise.
+    // COPY-ON-WRITE (round 2) — build a new array with only the items that
+    // actually need a rewrite replaced; never mutate the caller's `inputs`
+    // or its element objects.
+    const schemaConfig = this.getSchemaConfig();
+    const normalizedInputs = inputs.map((input) => {
+      if (!input.metadata) return input;
+      const normalized = normalizeDateFields(schemaConfig, { tags: input.tags, metadata: input.metadata });
+      return normalized !== input.metadata ? { ...input, metadata: normalized } : input;
+    });
+    const notes = noteOps.createNotes(this.db, normalizedInputs);
     for (const note of notes) {
       // Bulk path needs the same config-cache invalidation as singleton
       // createNote — without it, a batch that includes `_tags/*` notes
@@ -1244,7 +1292,7 @@ export class BunSqliteStore implements Store {
         const mapped = indexedFieldOps.mapFieldType(spec.type);
         if (!mapped) {
           throw new indexedFieldOps.IndexedFieldError(
-            `field "${fieldName}" has unsupported type "${spec.type}" for indexing (supported: string, integer, boolean, reference)`,
+            `field "${fieldName}" has unsupported type "${spec.type}" for indexing (supported: string, integer, boolean, reference, date)`,
           );
         }
         // Throws IndexedFieldError on an invalid identifier (e.g. kebab-case).
@@ -1376,6 +1424,14 @@ export class BunSqliteStore implements Store {
    * place.)
    */
   async createNoteRaw(content: string, opts?: { id?: string; path?: string; tags?: string[]; metadata?: Record<string, unknown>; created_at?: string; extension?: string }): Promise<Note> {
+    // Same pre-write `date`-field normalization as createNote
+    // (vault#date-field-type) — the legacy Obsidian importer (obsidian.ts)
+    // funnels through this path and bypasses createNote's copy otherwise.
+    // COPY-ON-WRITE (round 2) — see normalizeDateFields's doc comment.
+    if (opts?.metadata) {
+      const normalized = normalizeDateFields(this.getSchemaConfig(), { tags: opts.tags, metadata: opts.metadata });
+      if (normalized !== opts.metadata) opts = { ...opts, metadata: normalized };
+    }
     return noteOps.createNote(this.db, content, opts);
   }
 

package/core/src/tag-schemas.ts

@@ -18,6 +18,7 @@
 import { Database } from "bun:sqlite";
 import { mapFieldType, validateFieldName } from "./indexed-fields.js";
 import { loadTagHierarchy, findParentCycle } from "./tag-hierarchy.js";
+import { timestampToMs } from "./cursor.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -192,7 +193,7 @@ export class InvalidFieldDefaultError extends Error {
 
 /**
  * Thrown by `upsertTagRecord` (core/src/store.ts's chokepoint) when a
- * field's declared `type` isn't one of the six recognized values (vault#555
+ * field's declared `type` isn't one of the recognized values (vault#555
  * — `update-tag{fields:{weird:{type:"frobnicator"}}}` used to be accepted
  * and persisted verbatim, no error, for any NON-indexed field: the only
  * existing type check, `mapFieldType`, ran solely on `indexed: true` fields
@@ -255,13 +256,13 @@ export function validateFieldDefault(field: string, spec: TagFieldSchema): TagFi
 
 /**
  * The full recognized vocabulary for `TagFieldSchema.type` — storage/
- * advisory validation accepts all seven; only `string`/`integer`/`boolean`/
- * `reference` are INDEXABLE (that narrower subset is `indexed-fields.ts`'s
- * `TYPE_MAP`, enforced separately via `mapFieldType` for `indexed: true`
- * fields). Matches `defaultMatchesType`'s switch and `schema-defaults.ts`'s
- * `SchemaField.type` union — kept in lockstep by hand across the two
- * deliberately-decoupled modules (see `validateFieldDefault`'s doc comment
- * for why they don't cross-import).
+ * advisory validation accepts all eight; only `string`/`integer`/`boolean`/
+ * `reference`/`date` are INDEXABLE (that narrower subset is
+ * `indexed-fields.ts`'s `TYPE_MAP`, enforced separately via `mapFieldType`
+ * for `indexed: true` fields). Matches `defaultMatchesType`'s switch and
+ * `schema-defaults.ts`'s `SchemaField.type` union — kept in lockstep by hand
+ * across the two deliberately-decoupled modules (see `validateFieldDefault`'s
+ * doc comment for why they don't cross-import).
  *
  * `reference` (vault#typed-reference-field) is a dual-write field type: the
  * value is stored + validated exactly like `string` (an id/path/title the
@@ -270,11 +271,18 @@ export function validateFieldDefault(field: string, spec: TagFieldSchema): TagFi
  * to a note and maintains a graph `links` edge from this note to the
  * resolved target, with `relationship` set to the field name. See
  * `docs/design/typed-reference-field.md` for the full design + known gaps.
+ *
+ * `date` stores/validates like `string` (an ISO-8601 date or timestamp) so
+ * indexed `date` fields sort correctly under a plain TEXT comparison — see
+ * `defaultMatchesType`'s `"date"` case and `schema-defaults.ts`'s
+ * `valueMatchesType`, both of which reuse `cursor.ts`'s `timestampToMs`
+ * (the SAME UTC-correct parser `date_filter`'s `updated_at` bound uses) so
+ * there's exactly one ISO-parsing implementation in the codebase, not two.
  */
-export const VALID_FIELD_TYPES = ["string", "number", "integer", "boolean", "array", "object", "reference"] as const;
+export const VALID_FIELD_TYPES = ["string", "number", "integer", "boolean", "array", "object", "reference", "date"] as const;
 
 /**
- * Validate that a field's declared `type` is one of the six recognized
+ * Validate that a field's declared `type` is one of the recognized
  * values (vault#555). Returns `null` when `type` is unset (own-field checks
  * elsewhere already treat an unset type as "nothing to check against") or
  * recognized; otherwise a {@link TagFieldViolation} with `reason:
@@ -328,7 +336,7 @@ export function collectOwnFieldDefaultAndTypeViolations(
   return violations;
 }
 
-/** Same seven-type vocabulary as `TagFieldSchema.type`'s doc comment. Unknown/unset types pass (nothing to check against). */
+/** Same eight-type vocabulary as `TagFieldSchema.type`'s doc comment. Unknown/unset types pass (nothing to check against). */
 function defaultMatchesType(value: unknown, type: string): boolean {
   switch (type) {
     case "string":
@@ -348,6 +356,13 @@ function defaultMatchesType(value: unknown, type: string): boolean {
     // VALID_FIELD_TYPES's doc comment.
     case "reference":
       return typeof value === "string";
+    // `date` accepts an ISO-8601 date (`YYYY-MM-DD`) or full RFC3339
+    // timestamp — the SAME grammar `date_filter`'s `updated_at` bound
+    // parses (`timestampToMs`, imported from cursor.ts), not a second,
+    // independently-drifting date parser. See VALID_FIELD_TYPES's doc
+    // comment.
+    case "date":
+      return typeof value === "string" && timestampToMs(value) !== null;
     default:
       return true;
   }
@@ -767,7 +782,7 @@ export function collectTagFieldViolations(
         violations.push({
           field: fieldName,
           reason: "unsupported_indexed_type",
-          message: `field "${fieldName}" has unsupported type "${spec.type}" for indexing (supported: string, integer, boolean, reference)`,
+          message: `field "${fieldName}" has unsupported type "${spec.type}" for indexing (supported: string, integer, boolean, reference, date)`,
         });
       } else {
         try {