@openparachute/vault 0.4.0 → 0.4.4-rc.11

package/core/src/schema.ts

@@ -2,7 +2,7 @@ import { Database } from "bun:sqlite";
 import { normalizePath } from "./paths.js";
 import { rebuildIndexes } from "./indexed-fields.js";
 
-export const SCHEMA_VERSION = 16;
+export const SCHEMA_VERSION = 17;
 
 export const SCHEMA_SQL = `
 -- Notes: the universal record
@@ -69,37 +69,12 @@ CREATE TABLE IF NOT EXISTS links (
 -- tags row directly. The CREATE TABLE was removed from SCHEMA_SQL after the
 -- v14 data migration drops the table; existing v6+ vaults pick up the
 -- migration on next boot. See migrateToV14.
-
--- Note schemas (v15): schema definitions used to validate notes by path
--- prefix or tag. Replaces the v6-era _schemas/NAME notes-as-config
--- convention. Validation is non-blocking — schemas surface warnings on
--- create/update responses, never reject the write. See
--- core/src/schema-defaults.ts and patterns/tag-data-model.md §Note schemas.
 --
--- name        — primary key; the schema identifier referenced by mappings.
--- description — human-readable blurb (markdown).
--- fields      — JSON: { fieldName: { type?, enum?, description? } }.
--- required    — JSON: string[] of required field names.
-CREATE TABLE IF NOT EXISTS note_schemas (
-  name TEXT PRIMARY KEY,
-  description TEXT,
-  fields TEXT,
-  required TEXT,
-  created_at TEXT,
-  updated_at TEXT
-);
-
--- Schema mappings (v15): replaces the singleton _schema_defaults note. One
--- row per match rule; the resolver walks the table at note-write time.
--- match_kind is constrained to 'path_prefix' or 'tag'. Composite PK so
--- (schema, kind, value) is naturally unique without an extra surrogate id.
--- ON DELETE CASCADE: dropping a schema cleans up its mappings.
-CREATE TABLE IF NOT EXISTS schema_mappings (
-  schema_name TEXT NOT NULL REFERENCES note_schemas(name) ON DELETE CASCADE,
-  match_kind TEXT NOT NULL CHECK (match_kind IN ('path_prefix', 'tag')),
-  match_value TEXT NOT NULL,
-  PRIMARY KEY (schema_name, match_kind, match_value)
-);
+-- note_schemas + schema_mappings (v15) were retired in v17 (vault#267).
+-- The two-table validation subsystem turned out to be a parallel path to
+-- the per-tag fields column with zero operator usage; v17 drops both
+-- tables and the six MCP tools that managed them. Validation now reads
+-- tags.fields exclusively — see core/src/schema-defaults.ts.
 
 -- Indexed fields: SSOT for generated columns and indexes on notes derived
 -- from tag-declared fields with indexed=true. One row per indexed metadata
@@ -209,7 +184,6 @@ CREATE INDEX IF NOT EXISTS idx_note_tags_tag ON note_tags(tag_name, note_id);
 CREATE INDEX IF NOT EXISTS idx_attachments_note ON attachments(note_id);
 CREATE INDEX IF NOT EXISTS idx_links_source ON links(source_id);
 CREATE INDEX IF NOT EXISTS idx_links_target ON links(target_id);
-CREATE INDEX IF NOT EXISTS idx_schema_mappings_match ON schema_mappings(match_kind, match_value);
 -- idx_tokens_vault_name is created in migrateToV16, not here. SCHEMA_SQL
 -- runs BEFORE migrations; an upgrading v15 vault doesn't yet have the
 -- vault_name column when this section evaluates, so the index has to
@@ -285,6 +259,13 @@ export function initSchema(db: Database): void {
   // New mints via per-vault routes write the column explicitly. See vault#257.
   migrateToV16(db);
 
+  // Migrate v16 → v17: rip the standalone `note_schemas` + `schema_mappings`
+  // subsystem. Validation now reads `tags.fields` exclusively. The two
+  // tables are dropped wholesale; if a vault carried rows we log a warning
+  // naming the dropped schemas/mappings so the operator can recreate them
+  // as `tags.fields` if needed. See vault#267.
+  migrateToV17(db);
+
   // Rebuild any generated columns + indexes declared in indexed_fields.
   // No-op for a fresh vault; idempotent on existing vaults.
   rebuildIndexes(db);
@@ -572,6 +553,10 @@ function migrateToV14(db: Database): void {
  * leaves the DB in either pre-v15 or post-v15 state, never partial.
  */
 function migrateToV15(db: Database): void {
+  // note_schemas was dropped in v17; on any v17+ vault (or a v14→v17 skip),
+  // this guard returns immediately and the function is effectively dead code.
+  // Left in place rather than deleted because removing it would change initSchema's
+  // migration call ordering. Safe to delete in a future cleanup.
   if (!hasTable(db, "note_schemas") || !hasTable(db, "notes")) return;
 
   // Short-circuit: if either destination table already has data, the
@@ -721,6 +706,93 @@ function migrateToV16(db: Database): void {
   db.exec("CREATE INDEX IF NOT EXISTS idx_tokens_vault_name ON tokens(vault_name)");
 }
 
+/**
+ * Migrate v16 → v17: rip `note_schemas` + `schema_mappings` (vault#267).
+ *
+ * The two-table validation subsystem from v15 turned out to be a parallel
+ * path to `tags.fields` with zero operator usage. v17 drops both tables
+ * outright. Fresh vaults never see them; upgrading vaults lose them.
+ *
+ * If an upgrading vault DID carry rows (which Aaron's didn't, but a future
+ * operator's might), the migration logs the dropped names + mapping rules
+ * so the operator can re-create them as `tags.fields` declarations on the
+ * relevant tag rows. We don't try to auto-migrate path_prefix mappings —
+ * the new validation surface is tag-axis only, and a path_prefix → tag
+ * translation has no faithful one-to-one shape.
+ *
+ * Wrapped in BEGIN IMMEDIATE / COMMIT / ROLLBACK per the v14/v15/v16
+ * pattern from vault#251 — DROP TABLE statements are individually atomic,
+ * but the wrap means a crash mid-migration leaves either pre-v17 or
+ * post-v17 state, never partial.
+ */
+function migrateToV17(db: Database): void {
+  const hasNoteSchemas = hasTable(db, "note_schemas");
+  const hasSchemaMappings = hasTable(db, "schema_mappings");
+  if (!hasNoteSchemas && !hasSchemaMappings) return;
+
+  // Snapshot any data so the operator can recreate as `tags.fields` if
+  // needed. Read BEFORE the transaction so we don't lose the warning if
+  // the DROP fails (the COMMIT below atomically swaps state).
+  let droppedSchemas: { name: string; description: string | null }[] = [];
+  let droppedMappings: { schema_name: string; match_kind: string; match_value: string }[] = [];
+  if (hasNoteSchemas) {
+    droppedSchemas = db.prepare(
+      "SELECT name, description FROM note_schemas",
+    ).all() as { name: string; description: string | null }[];
+  }
+  if (hasSchemaMappings) {
+    droppedMappings = db.prepare(
+      "SELECT schema_name, match_kind, match_value FROM schema_mappings",
+    ).all() as { schema_name: string; match_kind: string; match_value: string }[];
+  }
+
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    // Drop the index first — the index references the table; SQLite would
+    // tear it down on DROP TABLE but the explicit DROP keeps the order
+    // obvious if a future migration reads from sqlite_master mid-flight.
+    db.exec("DROP INDEX IF EXISTS idx_schema_mappings_match");
+    // schema_mappings has an FK to note_schemas — drop it first.
+    if (hasSchemaMappings) {
+      db.exec("DROP TABLE schema_mappings");
+    }
+    if (hasNoteSchemas) {
+      db.exec("DROP TABLE note_schemas");
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+
+  if (droppedSchemas.length > 0 || droppedMappings.length > 0) {
+    const schemaNames = droppedSchemas.map((s) => s.name).join(", ");
+    const tagMappings = droppedMappings.filter((m) => m.match_kind === "tag");
+    const pathMappings = droppedMappings.filter((m) => m.match_kind === "path_prefix");
+    const lines: string[] = [
+      `[vault] migrated to schema v17 (vault#267): note_schemas + schema_mappings retired.`,
+    ];
+    if (droppedSchemas.length > 0) {
+      lines.push(`  dropped schemas (${droppedSchemas.length}): ${schemaNames}`);
+    }
+    if (tagMappings.length > 0) {
+      const list = tagMappings.map((m) => `${m.match_value}→${m.schema_name}`).join(", ");
+      lines.push(
+        `  dropped tag mappings (${tagMappings.length}): ${list}`,
+        `  recreate as \`tags.fields\` declarations on the relevant tag rows.`,
+      );
+    }
+    if (pathMappings.length > 0) {
+      const list = pathMappings.map((m) => `${m.match_value}→${m.schema_name}`).join(", ");
+      lines.push(
+        `  dropped path_prefix mappings (${pathMappings.length}): ${list}`,
+        `  no path-prefix-driven validation in v17 — file vault#267 if you need this.`,
+      );
+    }
+    console.log(lines.join("\n"));
+  }
+}
+
 function hasTable(db: Database, name: string): boolean {
   const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(name);
   return !!row;

package/core/src/store.ts

@@ -11,6 +11,7 @@ import {
   loadTagHierarchy,
   getTagDescendants,
   TAG_CONFIG_PREFIX,
+  DEFAULT_TAG_NAME,
   type TagHierarchy,
 } from "./tag-hierarchy.js";
 import {
@@ -19,7 +20,6 @@ import {
   type ResolvedSchemas,
   type ValidationStatus,
 } from "./schema-defaults.js";
-import * as noteSchemaOps from "./note-schemas.js";
 
 /**
  * bun:sqlite-backed Store implementation. Internally everything is
@@ -29,12 +29,11 @@ import * as noteSchemaOps from "./note-schemas.js";
 export class BunSqliteStore implements Store {
   public readonly hooks: HookRegistry;
 
-  // Lazy-built caches over the post-v14 `tags` table (hierarchy via
-  // parent_names) and the post-v15 `note_schemas` + `schema_mappings`
-  // tables (validation). Null means "not yet loaded or invalidated"; the
-  // next read rebuilds. We invalidate synchronously inside the writers
-  // that mutate the source tables so reads after writes always see the
-  // post-write state.
+  // Lazy-built caches over the post-v14 `tags` table — hierarchy via
+  // parent_names, schema validation via `fields`. Null means "not yet
+  // loaded or invalidated"; the next read rebuilds. We invalidate
+  // synchronously inside the writers that mutate the source rows so reads
+  // after writes always see the post-write state.
   private _tagHierarchy: TagHierarchy | null = null;
   private _schemaConfig: ResolvedSchemas | null = null;
 
@@ -55,8 +54,8 @@ export class BunSqliteStore implements Store {
   }
 
   /**
-   * Lazy accessor for the `note_schemas` + `schema_mappings` resolution.
-   * Same lifecycle as the tag hierarchy cache.
+   * Lazy accessor for the per-tag `fields` resolution. Same lifecycle as
+   * the tag hierarchy cache.
    */
   private getSchemaConfig(): ResolvedSchemas {
     if (!this._schemaConfig) this._schemaConfig = loadSchemaConfig(this.db);
@@ -79,9 +78,9 @@ export class BunSqliteStore implements Store {
    * alongside new for rename cases (a note moved out of `_tags/` should
    * still invalidate).
    *
-   * Post-v15 the schema-config cache is no longer note-driven — its
-   * invalidation hook is on `upsertNoteSchema` / `setSchemaMapping` /
-   * `deleteNoteSchema` / `deleteSchemaMapping` instead.
+   * Post-v17 the schema-config cache is purely tag-driven — its
+   * invalidation hook is on `upsertTagSchema` / `upsertTagRecord` /
+   * `deleteTagSchema` / `deleteTag` (mutations of `tags.fields`).
    */
   private invalidateConfigCachesForPath(path: string | null | undefined, oldPath?: string | null): void {
     const isTagConfig = (p: string | null | undefined): boolean =>
@@ -203,6 +202,19 @@ export class BunSqliteStore implements Store {
     }
   }
 
+  async restoreNoteTimestamps(id: string, createdAt: string, updatedAt: string): Promise<void> {
+    // Import-only: direct UPDATE so the importer can restore a note's
+    // historical `created_at`/`updated_at` from the portable-md export
+    // bytes. `updateNote` either bumps `updated_at` to wall-clock-now or
+    // (with `skipUpdatedAt: true`) leaves it untouched — neither lets
+    // the importer write a specific historical timestamp. Skips hooks
+    // by design: this isn't a user-edit, it's a state restoration.
+    // See vault#308 PR 2.
+    this.db
+      .prepare("UPDATE notes SET created_at = ?, updated_at = ? WHERE id = ?")
+      .run(createdAt, updatedAt, id);
+  }
+
   async deleteNote(id: string): Promise<void> {
     // Read before delete so we can invalidate config caches on the way out.
     const existing = noteOps.getNote(this.db, id);
@@ -219,16 +231,45 @@ export class BunSqliteStore implements Store {
    * each input tag is replaced with `{tag} ∪ descendants(tag)`. The SQL
    * builder uses this to widen the tag join from `name = ?` to
    * `name IN (...)`, so a query for `#manual` matches notes tagged with
-   * any descendant declared via `_tags/*` config notes.
+   * any descendant declared via `tags.parent_names`.
+   *
+   * `_default` magic (vault#270): when a `_default` tag row exists in the
+   * vault, it's the implicit parent of every note (tagged or not). A query
+   * filter that names `_default` is therefore equivalent to "no tag filter
+   * at all" — but the precise treatment depends on `tagMatch`:
    *
-   * No-op when no `_tags/*` notes exist (empty hierarchy → each tag
-   * expands to just itself, identical to the pre-expansion behavior).
+   * - `all` (default, AND-semantics): `_default` is universally satisfied,
+   *   so it can be dropped from the tag list. Other tags' AND-semantics
+   *   still apply. If `_default` was the only entry, drop the filter
+   *   entirely so untagged notes match.
+   * - `any` (OR-semantics): `_default` matches every note, so the disjunction
+   *   collapses to "every note." Drop the filter entirely regardless of
+   *   what else was in the list (otherwise we'd narrow to the union of
+   *   the other tags' notes — wrong).
+   *
+   * Other filters (path, metadata, dates) still apply in both cases.
    */
   private expandQueryTags(opts: QueryOpts): QueryOpts {
     if (!opts.tags || opts.tags.length === 0) return opts;
     const hierarchy = this.getTagHierarchy();
+
+    let tags = opts.tags;
+    if (hierarchy.allTags.has(DEFAULT_TAG_NAME) && tags.includes(DEFAULT_TAG_NAME)) {
+      const match = opts.tagMatch ?? "all";
+      if (match === "any") {
+        const { tags: _drop, ..._rest } = opts;
+        return _rest as QueryOpts;
+      }
+      tags = tags.filter((t) => t !== DEFAULT_TAG_NAME);
+      if (tags.length === 0) {
+        const { tags: _drop, ..._rest } = opts;
+        return _rest as QueryOpts;
+      }
+      opts = { ...opts, tags };
+    }
+
     if (hierarchy.childrenOf.size === 0) return opts;
-    const expanded = opts.tags.map((t) => Array.from(getTagDescendants(hierarchy, t)));
+    const expanded = tags.map((t) => Array.from(getTagDescendants(hierarchy, t)));
     return { ...opts, _tagsExpanded: expanded } as QueryOpts;
   }
 
@@ -237,9 +278,16 @@ export class BunSqliteStore implements Store {
     // should match notes tagged with any descendant tag. The underlying
     // FTS path already uses `IN (...)` for tags, so we flatten the
     // per-input expansions into a single union (search semantics are
-    // "any tag matches").
+    // "any tag matches"). When `_default` is among the requested tags
+    // (and a `_default` row exists), the OR collapses to "every note" —
+    // drop the tag filter entirely so the search hits the full corpus
+    // and untagged notes are reachable.
     if (opts?.tags && opts.tags.length > 0) {
       const hierarchy = this.getTagHierarchy();
+      if (hierarchy.allTags.has(DEFAULT_TAG_NAME) && opts.tags.includes(DEFAULT_TAG_NAME)) {
+        const { tags: _drop, ..._rest } = opts;
+        return noteOps.searchNotes(this.db, query, _rest);
+      }
       if (hierarchy.childrenOf.size > 0) {
         const expanded = new Set<string>();
         for (const t of opts.tags) {
@@ -277,17 +325,22 @@ export class BunSqliteStore implements Store {
 
   async deleteTag(name: string): Promise<{ deleted: boolean; notes_untagged: number }> {
     const result = noteOps.deleteTag(this.db, name);
-    // The deleted tag may have been a parent or child in the hierarchy.
+    // The deleted tag may have been a parent or child in the hierarchy
+    // and may have declared `fields` powering schema validation.
     this._tagHierarchy = null;
+    this._schemaConfig = null;
     return result;
   }
 
   async renameTag(oldName: string, newName: string): Promise<noteOps.RenameTagResult> {
     const result = noteOps.renameTag(this.db, oldName, newName);
-    // Other tags' parent_names may reference oldName — though we don't
-    // rewrite those, the hierarchy cache should be rebuilt to pick up the
-    // new row identity.
+    // Vault#240: the cascade rewrites parent_names in OTHER tag rows as
+    // part of the same transaction, plus tokens.scoped_tags and
+    // indexed_fields.declarer_tags. Both caches are tag-keyed, so they
+    // must be rebuilt regardless — the hierarchy by tag-set identity,
+    // the schema-config by parent_names + fields content.
     this._tagHierarchy = null;
+    this._schemaConfig = null;
     return result;
   }
 
@@ -297,8 +350,10 @@ export class BunSqliteStore implements Store {
   ): Promise<{ merged: Record<string, number>; target: string }> {
     const result = noteOps.mergeTags(this.db, sources, target);
     // Source tags drop out of the hierarchy; downstream callers asking
-    // for descendants of target should pick up any merged children.
+    // for descendants of target should pick up any merged children. Also
+    // bust the schema cache — `fields` declarations follow tag identity.
     this._tagHierarchy = null;
+    this._schemaConfig = null;
     return result;
   }
 
@@ -332,9 +387,9 @@ export class BunSqliteStore implements Store {
     const notes = noteOps.createNotes(this.db, inputs);
     for (const note of notes) {
       // Bulk path needs the same config-cache invalidation as singleton
-      // createNote — without it, a batch that includes `_tags/*` or
-      // `_schemas/*` notes would leave the cache stale until the next
-      // singleton write happened to bust it.
+      // createNote — without it, a batch that includes `_tags/*` notes
+      // would leave the hierarchy cache stale until the next singleton
+      // write happened to bust it.
       this.invalidateConfigCachesForPath(note.path);
       this.hooks.dispatch("created", note, this);
     }
@@ -370,11 +425,17 @@ export class BunSqliteStore implements Store {
   }
 
   async upsertTagSchema(tag: string, schema: { description?: string; fields?: Record<string, tagSchemaOps.TagFieldSchema> }) {
-    return tagSchemaOps.upsertTagSchema(this.db, tag, schema);
+    const result = tagSchemaOps.upsertTagSchema(this.db, tag, schema);
+    // `fields` drives validation — bust the schema cache so the next
+    // create/update sees the new declarations.
+    this._schemaConfig = null;
+    return result;
   }
 
   async deleteTagSchema(tag: string) {
-    return tagSchemaOps.deleteTagSchema(this.db, tag);
+    const result = tagSchemaOps.deleteTagSchema(this.db, tag);
+    if (result) this._schemaConfig = null;
+    return result;
   }
 
   async getTagSchemaMap() {
@@ -407,7 +468,20 @@ export class BunSqliteStore implements Store {
   ) {
     const result = tagSchemaOps.upsertTagRecord(this.db, tag, patch);
     if (patch.parent_names !== undefined) {
+      // parent_names drives both query expansion (tag hierarchy) AND, post
+      // vault#270, schema inheritance — bust both caches.
       this._tagHierarchy = null;
+      this._schemaConfig = null;
+    }
+    if (patch.fields !== undefined) {
+      this._schemaConfig = null;
+    }
+    // First-time creation of a tag row (e.g. an empty `_default` placeholder)
+    // changes the `_default` universal-parent gate even when no fields or
+    // parent_names are touched. Cheap to bust: caches rebuild on next read.
+    if (tag === "_default") {
+      this._tagHierarchy = null;
+      this._schemaConfig = null;
     }
     return result;
   }
@@ -431,63 +505,14 @@ export class BunSqliteStore implements Store {
   /**
    * Drop the config caches unconditionally. Used by bulk-import paths that
    * skip per-note invalidation for throughput, and by importers that
-   * directly populate `note_schemas` / `schema_mappings`.
+   * directly mutate `tags` / `tags.fields` outside the singleton write
+   * methods.
    */
   rebuildConfigCaches(): void {
     this._tagHierarchy = null;
     this._schemaConfig = null;
   }
 
-  // ---- Note schemas (post-v15: validation by path-prefix or tag) ----
-
-  async listNoteSchemas() {
-    return noteSchemaOps.listNoteSchemas(this.db);
-  }
-
-  async getNoteSchema(name: string) {
-    return noteSchemaOps.getNoteSchema(this.db, name);
-  }
-
-  /**
-   * Partial-upsert a note schema. Auto-creates the row if missing. Any
-   * patch field left undefined is preserved; pass null to clear. Empty
-   * `required: []` collapses to null. Invalidates the schema-config cache.
-   */
-  async upsertNoteSchema(name: string, patch: noteSchemaOps.NoteSchemaPatch) {
-    const result = noteSchemaOps.upsertNoteSchema(this.db, name, patch);
-    this._schemaConfig = null;
-    return result;
-  }
-
-  async deleteNoteSchema(name: string) {
-    const removed = noteSchemaOps.deleteNoteSchema(this.db, name);
-    if (removed) this._schemaConfig = null;
-    return removed;
-  }
-
-  async listSchemaMappings(opts?: noteSchemaOps.ListMappingsOpts) {
-    return noteSchemaOps.listSchemaMappings(this.db, opts ?? {});
-  }
-
-  async setSchemaMapping(
-    schema_name: string,
-    match_kind: noteSchemaOps.SchemaMappingKind,
-    match_value: string,
-  ) {
-    noteSchemaOps.setSchemaMapping(this.db, schema_name, match_kind, match_value);
-    this._schemaConfig = null;
-  }
-
-  async deleteSchemaMapping(
-    schema_name: string,
-    match_kind: noteSchemaOps.SchemaMappingKind,
-    match_value: string,
-  ) {
-    const removed = noteSchemaOps.deleteSchemaMapping(this.db, schema_name, match_kind, match_value);
-    if (removed) this._schemaConfig = null;
-    return removed;
-  }
-
   /**
    * Sync wikilinks for all notes in the vault.
    * Efficient for bulk imports — call once after importing all notes.

package/core/src/tag-hierarchy.ts

@@ -32,8 +32,23 @@ export interface TagHierarchy {
   childrenOf: Map<string, Set<string>>;
   /** Memoization cache: tag → set including the tag itself plus all transitive descendants. */
   descendantsCache: Map<string, Set<string>>;
+  /**
+   * Every known tag name in the vault. Loaded once at hierarchy build so the
+   * `_default` universal-parent magic in `getTagDescendants` can answer
+   * "expand `_default` → every tag" without a second DB scan.
+   */
+  allTags: Set<string>;
 }
 
+/**
+ * Reserved tag name treated as the implicit universal parent of every other
+ * tag (vault#270). When a row named `_default` exists in the `tags` table,
+ * its schema applies to all notes — tagged or not — and tag-hierarchy queries
+ * for `_default` expand to the full tag list. The `tags.parent_names` column
+ * is never auto-mutated; the universal-parent property lives at resolve time.
+ */
+export const DEFAULT_TAG_NAME = "_default";
+
 /**
  * Pre-v14 path prefix that marked a note as a tag-hierarchy declaration.
  * Retained as an exported constant so call-sites that still need to know
@@ -59,16 +74,21 @@ function readParentNames(raw: string | null): string[] {
 /**
  * Scan the `tags` table and build the parent→children adjacency map.
  * Each row's `parent_names` JSON array contributes one edge per parent.
+ * Also collects every known tag name in `allTags` so the `_default`
+ * universal-parent leg in `getTagDescendants` can return the full tag list
+ * without a second scan.
  */
 export function loadTagHierarchy(db: Database): TagHierarchy {
   const rows = db.prepare(
-    `SELECT name, parent_names FROM tags WHERE parent_names IS NOT NULL`,
+    `SELECT name, parent_names FROM tags`,
   ).all() as { name: string; parent_names: string | null }[];
 
   const childrenOf = new Map<string, Set<string>>();
+  const allTags = new Set<string>();
 
   for (const row of rows) {
     if (!row.name) continue;
+    allTags.add(row.name);
     const parents = readParentNames(row.parent_names);
     for (const parent of parents) {
       let children = childrenOf.get(parent);
@@ -80,18 +100,32 @@ export function loadTagHierarchy(db: Database): TagHierarchy {
     }
   }
 
-  return { childrenOf, descendantsCache: new Map() };
+  return { childrenOf, descendantsCache: new Map(), allTags };
 }
 
 /**
  * Return the tag plus all transitive descendants. Always includes the tag
  * itself, so callers can use the result as a drop-in replacement for the
  * input tag when expanding queries.
+ *
+ * Special case: `_default` is treated as the implicit parent of every tag
+ * (vault#270). When a row named `_default` exists in the `tags` table, this
+ * function returns the full set of known tag names — symmetric with the
+ * schema-inheritance model where `_default`'s fields apply to every note.
+ * When `_default` is *not* declared as a tag row, the call falls through to
+ * normal descendant traversal (which yields just `{_default}` since nothing
+ * lists it as a parent).
  */
 export function getTagDescendants(h: TagHierarchy, tag: string): Set<string> {
   const cached = h.descendantsCache.get(tag);
   if (cached) return cached;
 
+  if (tag === DEFAULT_TAG_NAME && h.allTags.has(DEFAULT_TAG_NAME)) {
+    const universal = new Set<string>(h.allTags);
+    h.descendantsCache.set(tag, universal);
+    return universal;
+  }
+
   const result = new Set<string>([tag]);
   const stack = [tag];
   while (stack.length > 0) {