@openparachute/vault 0.3.3 → 0.4.3

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 = 12;
+export const SCHEMA_VERSION = 17;
 
 export const SCHEMA_SQL = `
 -- Notes: the universal record
@@ -15,9 +15,27 @@ CREATE TABLE IF NOT EXISTS notes (
   updated_at TEXT
 );
 
--- Tags: flat labels
+-- Tags: first-class identity carrying schema, hierarchy, and typed-link
+-- declarations. One row per tag; no notes-as-config sidecars for these
+-- concerns. See parachute-patterns/patterns/tag-data-model.md.
+--
+-- description    — human-readable blurb (markdown).
+-- fields         — JSON: indexed metadata field declarations per
+--                  query-operators.md. Replaces v6-era tag_schemas.fields.
+-- relationships  — JSON: typed-link declarations
+--                  ({ "rel": { target_tag, cardinality, description? } }).
+--                  Cardinality vocabulary: one | optional | many | many-required.
+--                  Phase 1 informational — declared but not enforced at write.
+-- parent_names   — JSON array of parent tag names. Replaces the v6-era
+--                  _tags/NAME config-note hierarchy.
 CREATE TABLE IF NOT EXISTS tags (
-  name TEXT PRIMARY KEY
+  name TEXT PRIMARY KEY,
+  description TEXT,
+  fields TEXT,
+  relationships TEXT,
+  parent_names TEXT,
+  created_at TEXT,
+  updated_at TEXT
 );
 
 -- Note-Tag join
@@ -47,12 +65,16 @@ CREATE TABLE IF NOT EXISTS links (
   UNIQUE(source_id, target_id, relationship)
 );
 
--- Tag schemas: optional metadata schema per tag
-CREATE TABLE IF NOT EXISTS tag_schemas (
-  tag_name TEXT PRIMARY KEY REFERENCES tags(name) ON DELETE CASCADE,
-  description TEXT,
-  fields TEXT -- JSON: { "field_name": { "type": "string", "description": "..." }, ... }
-);
+-- tag_schemas (v6) was retired in v14; description + fields lifted onto the
+-- 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 + 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
@@ -73,6 +95,19 @@ CREATE TABLE IF NOT EXISTS indexed_fields (
 -- one-release-cycle back-compat window and will be dropped in a future
 -- migration.
 --
+-- scoped_tags is a JSON-encoded array of root tag names that constrain the
+-- token's effective access (intersection with the scopes column). NULL
+-- means unscoped — full vault access per scopes. Introduced in v13 per
+-- patterns/tag-scoped-tokens.md. Hierarchy expansion is applied at auth
+-- time via getTagDescendants; the column stores root names only.
+--
+-- vault_name (v16) binds the token to a single vault. NULL means the
+-- token is server-wide / legacy (pre-v16 rows backfill to NULL on the
+-- migration; auth treats NULL as accept-any-vault for back-compat).
+-- New tokens minted via per-vault routes write the column explicitly so
+-- cross-vault presentation rejects in authenticateVaultRequest. See
+-- vault#257.
+--
 -- scope_tag / scope_path_prefix are deprecated Phase-0 columns — never
 -- enforced at runtime, kept only for schema stability.
 CREATE TABLE IF NOT EXISTS tokens (
@@ -80,11 +115,13 @@ CREATE TABLE IF NOT EXISTS tokens (
   label TEXT NOT NULL,
   permission TEXT NOT NULL DEFAULT 'admin',
   scopes TEXT,
+  scoped_tags TEXT,
   scope_tag TEXT,
   scope_path_prefix TEXT,
   expires_at TEXT,
   created_at TEXT NOT NULL,
-  last_used_at TEXT
+  last_used_at TEXT,
+  vault_name TEXT
 );
 
 -- OAuth: registered clients (Dynamic Client Registration)
@@ -147,6 +184,12 @@ 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);
+-- 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
+-- live downstream of the ALTER TABLE that adds the column. Fresh vaults
+-- (column already present from this CREATE TABLE) still get the index
+-- because migrateToV16 also runs the unconditional CREATE INDEX path.
 `;
 
 /**
@@ -194,6 +237,35 @@ export function initSchema(db: Database): void {
   // Migrate v11 → v12: add `scopes` column to tokens for Phase 2 enforcement.
   migrateToV12(db);
 
+  // Migrate v12 → v13: add `scoped_tags` column to tokens for tag-scoped tokens.
+  migrateToV13(db);
+
+  // Migrate v13 → v14: tag-data-model reshape. Augment `tags` row with
+  // description/fields/relationships/parent_names/timestamps; copy data
+  // from the v6-era tag_schemas sidecar and from `_tags/<name>` config
+  // notes; drop tag_schemas after copy. See patterns/tag-data-model.md.
+  migrateToV14(db);
+
+  // Migrate v14 → v15: retire the `_schemas/<name>` and `_schema_defaults`
+  // notes-as-config sidecars. Copy each `_schemas/<name>` note into the
+  // new `note_schemas` table and the `_schema_defaults` mappings into
+  // `schema_mappings`. The legacy notes are LEFT IN PLACE — they are
+  // inert post-v15 (no resolver reads them) and serve as audit trail.
+  migrateToV15(db);
+
+  // Migrate v15 → v16: add `vault_name` column to tokens. Existing rows
+  // backfill to NULL ("server-wide / legacy" semantic) — auth accepts
+  // NULL for any vault, so today's pvt_* tokens keep working unchanged.
+  // 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);
@@ -258,7 +330,7 @@ function migrateToV5(db: Database): void {
     // Keep first, rename the rest
     for (let i = 1; i < ids.length; i++) {
       const newPath = `${dupe.path}-${i}`;
-      db.prepare("UPDATE notes SET path = ? WHERE id = ?").run(newPath, ids[i]);
+      db.prepare("UPDATE notes SET path = ? WHERE id = ?").run(newPath, ids[i]!);
     }
   }
 
@@ -337,6 +409,390 @@ function migrateToV12(db: Database): void {
   }
 }
 
+/**
+ * Migrate v12 → v13: add `scoped_tags` column to tokens. NULL means unscoped
+ * (current full-vault behavior); a JSON array of root tag names narrows the
+ * token's access to notes carrying one of those tags or a sub-tag thereof
+ * (hierarchy expansion via getTagDescendants at auth time). See
+ * parachute-patterns/patterns/tag-scoped-tokens.md.
+ */
+function migrateToV13(db: Database): void {
+  if (hasTable(db, "tokens") && !hasColumn(db, "tokens", "scoped_tags")) {
+    db.exec("ALTER TABLE tokens ADD COLUMN scoped_tags TEXT");
+  }
+}
+
+/**
+ * Migrate v13 → v14: tag-data-model reshape (patterns/tag-data-model.md).
+ *
+ * Augments the `tags` table with five new columns and one timestamp pair,
+ * then copies pre-existing data from two notes-as-config sidecars:
+ *
+ *   - tag_schemas (v6 sidecar) → tags.{description,fields}
+ *   - notes at path `_tags/<name>` → tags.parent_names (from metadata.parents)
+ *
+ * After the copy lands, `tag_schemas` is dropped. The `_tags/<name>` notes
+ * are LEFT IN PLACE — they're harmless historical record and a user might
+ * have other content there. Future writes go to the tags row directly.
+ *
+ * Wrapped in BEGIN IMMEDIATE / COMMIT (with a try/catch ROLLBACK) so a
+ * crash mid-migration leaves the DB in either pre-v14 or post-v14 state,
+ * never half-migrated. Each step remains individually idempotent — the
+ * transaction wrap is belt-and-suspenders, not load-bearing — so a future
+ * reader who removes the `hasColumn` / `hasTable` guards still gets correct
+ * behavior on retry.
+ */
+function migrateToV14(db: Database): void {
+  if (!hasTable(db, "tags")) return;
+
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    // 1. ALTER TABLE — additive, idempotent.
+    const cols: [string, string][] = [
+      ["description", "TEXT"],
+      ["fields", "TEXT"],
+      ["relationships", "TEXT"],
+      ["parent_names", "TEXT"],
+      ["created_at", "TEXT"],
+      ["updated_at", "TEXT"],
+    ];
+    for (const [col, type] of cols) {
+      if (!hasColumn(db, "tags", col)) {
+        db.exec(`ALTER TABLE tags ADD COLUMN ${col} ${type}`);
+      }
+    }
+
+    const now = new Date().toISOString();
+    let copiedSchemas = 0;
+    let copiedHierarchy = 0;
+
+    // 2. Copy tag_schemas → tags.{description,fields}.
+    if (hasTable(db, "tag_schemas")) {
+      const rows = db.prepare(
+        "SELECT tag_name, description, fields FROM tag_schemas",
+      ).all() as { tag_name: string; description: string | null; fields: string | null }[];
+      const upsert = db.prepare(
+        "INSERT OR IGNORE INTO tags (name, created_at, updated_at) VALUES (?, ?, ?)",
+      );
+      const update = db.prepare(
+        "UPDATE tags SET description = ?, fields = ?, updated_at = ? WHERE name = ?",
+      );
+      for (const row of rows) {
+        upsert.run(row.tag_name, now, now);
+        update.run(row.description, row.fields, now, row.tag_name);
+        copiedSchemas++;
+      }
+    }
+
+    // 3. Copy `_tags/<name>` notes' metadata.parents → tags.parent_names.
+    // Only runs if the notes table exists (it always does post-SCHEMA_SQL,
+    // but stay defensive — initSchema runs SCHEMA_SQL first so this is true).
+    if (hasTable(db, "notes")) {
+      const tagNotes = db.prepare(
+        "SELECT path, metadata FROM notes WHERE path GLOB '_tags/*'",
+      ).all() as { path: string; metadata: string | null }[];
+      const upsert = db.prepare(
+        "INSERT OR IGNORE INTO tags (name, created_at, updated_at) VALUES (?, ?, ?)",
+      );
+      const update = db.prepare(
+        "UPDATE tags SET parent_names = ?, updated_at = ? WHERE name = ?",
+      );
+      for (const note of tagNotes) {
+        const tagName = note.path.slice("_tags/".length);
+        if (!tagName) continue;
+        let parents: string[] | null = null;
+        try {
+          const meta = note.metadata ? JSON.parse(note.metadata) : {};
+          const raw = meta?.parents;
+          if (Array.isArray(raw) && raw.length > 0) {
+            const cleaned = raw.filter((p: unknown): p is string => typeof p === "string" && p.length > 0);
+            if (cleaned.length > 0) parents = cleaned;
+          }
+        } catch {
+          // Malformed metadata — skip; the note is left untouched.
+          continue;
+        }
+        if (!parents) continue;
+        upsert.run(tagName, now, now);
+        update.run(JSON.stringify(parents), now, tagName);
+        copiedHierarchy++;
+      }
+    }
+
+    // 4. Backfill timestamps for rows the copies didn't touch.
+    db.exec(`UPDATE tags SET created_at = '${now}' WHERE created_at IS NULL`);
+
+    // 5. Drop the sidecar after the copy is complete.
+    if (hasTable(db, "tag_schemas")) {
+      db.exec("DROP TABLE tag_schemas");
+    }
+
+    db.exec("COMMIT");
+
+    if (copiedSchemas > 0 || copiedHierarchy > 0) {
+      console.log(
+        `[vault] migrated to schema v14: copied ${copiedSchemas} tag_schemas + ${copiedHierarchy} _tags/* hierarchies onto tags rows`,
+      );
+    }
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+
+/**
+ * Migrate v14 → v15: retire `_schemas/<name>` + `_schema_defaults` notes
+ * as the canonical source for schema definitions and mapping rules. After
+ * this migration the resolver reads from `note_schemas` and
+ * `schema_mappings` tables. The legacy notes are LEFT IN PLACE — they're
+ * harmless historical record and a user might have other content there.
+ *
+ * Idempotent: SCHEMA_SQL creates the tables before this runs (CREATE TABLE
+ * IF NOT EXISTS); the data copy uses INSERT OR IGNORE so re-running on a
+ * post-v15 DB is a no-op. Wrapped in BEGIN/COMMIT so a crash mid-migration
+ * 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
+  // migration has run before. `||` not `&&` — a vault with schemas but zero
+  // mappings (or mappings but zero schemas) is a valid post-v15 state, and
+  // re-scanning notes on every boot would be wasted I/O.
+  const hasSchemas = (db.prepare(
+    "SELECT 1 FROM note_schemas LIMIT 1",
+  ).get()) !== null;
+  const hasMappings = (db.prepare(
+    "SELECT 1 FROM schema_mappings LIMIT 1",
+  ).get()) !== null;
+  if (hasSchemas || hasMappings) return;
+
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const now = new Date().toISOString();
+    let copiedSchemas = 0;
+    let copiedMappings = 0;
+
+    // 1. Copy `_schemas/<name>` notes → note_schemas.
+    const defRows = db.prepare(
+      "SELECT path, metadata FROM notes WHERE path GLOB '_schemas/*'",
+    ).all() as { path: string; metadata: string | null }[];
+    const insertSchema = db.prepare(
+      "INSERT OR IGNORE INTO note_schemas (name, description, fields, required, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+    );
+    for (const row of defRows) {
+      const name = row.path.slice("_schemas/".length);
+      if (!name) continue;
+      let description: string | null = null;
+      let fields: string | null = null;
+      let required: string | null = null;
+      try {
+        const meta = row.metadata ? JSON.parse(row.metadata) : {};
+        if (typeof meta?.description === "string") description = meta.description;
+        if (meta?.fields && typeof meta.fields === "object" && !Array.isArray(meta.fields)) {
+          fields = JSON.stringify(meta.fields);
+        }
+        if (Array.isArray(meta?.required)) {
+          const cleaned = meta.required.filter((x: unknown): x is string => typeof x === "string");
+          if (cleaned.length > 0) required = JSON.stringify(cleaned);
+        }
+      } catch {
+        // Malformed metadata — skip; the note is left alone.
+        continue;
+      }
+      insertSchema.run(name, description, fields, required, now, now);
+      copiedSchemas++;
+    }
+
+    // 2. Copy `_schema_defaults` note → schema_mappings.
+    const mappingNote = db.prepare(
+      "SELECT metadata FROM notes WHERE path = '_schema_defaults'",
+    ).get() as { metadata: string | null } | undefined;
+    if (mappingNote?.metadata) {
+      const insertMapping = db.prepare(
+        "INSERT OR IGNORE INTO schema_mappings (schema_name, match_kind, match_value) VALUES (?, ?, ?)",
+      );
+      const ensureSchemaRow = db.prepare(
+        "INSERT OR IGNORE INTO note_schemas (name, created_at, updated_at) VALUES (?, ?, ?)",
+      );
+      try {
+        const meta = JSON.parse(mappingNote.metadata);
+        const pathPrefixes = meta?.path_prefixes;
+        if (pathPrefixes && typeof pathPrefixes === "object" && !Array.isArray(pathPrefixes)) {
+          for (const [prefix, schema] of Object.entries(pathPrefixes as Record<string, unknown>)) {
+            if (typeof schema === "string" && schema.length > 0 && prefix.length > 0) {
+              // Foreign key requires the schema row to exist; create a stub
+              // if the user mapped to a name with no _schemas/<name> note.
+              ensureSchemaRow.run(schema, now, now);
+              insertMapping.run(schema, "path_prefix", prefix);
+              copiedMappings++;
+            }
+          }
+        }
+        const tags = meta?.tags;
+        if (tags && typeof tags === "object" && !Array.isArray(tags)) {
+          for (const [tag, schema] of Object.entries(tags as Record<string, unknown>)) {
+            if (typeof schema === "string" && schema.length > 0 && tag.length > 0) {
+              ensureSchemaRow.run(schema, now, now);
+              insertMapping.run(schema, "tag", tag);
+              copiedMappings++;
+            }
+          }
+        }
+      } catch {
+        // Malformed _schema_defaults — leave both note and table empty;
+        // user can fix and re-run.
+      }
+    }
+
+    db.exec("COMMIT");
+
+    if (copiedSchemas > 0 || copiedMappings > 0) {
+      console.log(
+        `[vault] migrated to schema v15: copied ${copiedSchemas} _schemas/* + ${copiedMappings} _schema_defaults mappings into note_schemas/schema_mappings`,
+      );
+    }
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+
+/**
+ * Migrate v15 → v16: per-vault token storage (vault#257).
+ *
+ * Adds `tokens.vault_name TEXT` (nullable). Existing rows stay NULL —
+ * "server-wide / legacy" semantic — and `authenticateVaultRequest`
+ * accepts NULL for any vault, so today's pvt_* tokens keep working
+ * unchanged. New mints via `/vault/<name>/tokens` write the column
+ * explicitly; cross-vault presentation rejects on the row's vault_name
+ * mismatch. The complementary index speeds the per-vault listTokens
+ * filter in the admin SPA.
+ *
+ * Wrapped in BEGIN IMMEDIATE / COMMIT (with try/catch ROLLBACK) per the
+ * v14/v15 wrap pattern from vault#251 — the column add and index create
+ * are individually idempotent (`hasColumn` / IF NOT EXISTS), but the
+ * transaction means a crash mid-migration leaves either pre-v16 or
+ * post-v16 state, never partial.
+ */
+function migrateToV16(db: Database): void {
+  if (!hasTable(db, "tokens")) return;
+
+  // Two responsibilities, separated so the index lands for both fresh
+  // vaults (SCHEMA_SQL already created the column) and upgrading v15
+  // vaults (column missing). Index creation lives outside the wrapped
+  // ALTER block so a fresh vault — where the column exists but the index
+  // doesn't — still gets it.
+  if (!hasColumn(db, "tokens", "vault_name")) {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      db.exec("ALTER TABLE tokens ADD COLUMN vault_name TEXT");
+      db.exec("CREATE INDEX IF NOT EXISTS idx_tokens_vault_name ON tokens(vault_name)");
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    }
+    return;
+  }
+
+  // Column exists (fresh vault from SCHEMA_SQL, or post-upgrade vault).
+  // Make sure the index exists too. IF NOT EXISTS makes this a no-op on
+  // the steady-state path.
+  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;