@wirecat/cli-core 0.419.0 → 0.420.0

package/dist/store/sqlite/files.js

@@ -0,0 +1,293 @@
+import { CliError } from "@wirecat/cli-base";
+import { fold } from "../normalize.js";
+import { write, writeBatch } from "./transaction.js";
+const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** A JSON column's object, or an object already parsed out of one. */
+const objectOf = (value) => {
+    if (isObject(value))
+        return value;
+    if (typeof value !== "string")
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return isObject(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const stringOf = (value) => (typeof value === "string" && value ? value : undefined);
+const timeOf = (value) => {
+    const text = stringOf(value);
+    const at = text === undefined ? Number.NaN : Date.parse(text);
+    return Number.isFinite(at) ? at : null;
+};
+const LOCAL = new Set(["local", "obsidian"]);
+/** Nested Drive folders deeper than this are cut at the root: a parent cycle must not recurse forever. */
+const MAX_DEPTH = 64;
+const nameOf = (path) => path.slice(path.lastIndexOf("/") + 1);
+/** A local folder's own row, and its parents', made when a file under it is first written. */
+const localFolder = (database, now, accountId, path) => {
+    if (!path)
+        return null;
+    const found = database
+        .prepare("SELECT id, path FROM files WHERE account_id = ? AND external_id = ? AND kind = 'folder'")
+        .get(accountId, path);
+    if (found)
+        return { id: Number(found.id), path: String(found.path) };
+    const slash = path.lastIndexOf("/");
+    const parent = localFolder(database, now, accountId, slash < 0 ? "" : path.slice(0, slash));
+    const row = database
+        .prepare("INSERT INTO files (account_id, external_id, kind, name, path, path_folded, parent_id, created_at, updated_at) " +
+        "VALUES (?, ?, 'folder', ?, ?, ?, ?, ?, ?) RETURNING id")
+        .get(accountId, path, nameOf(path), path, fold(path), parent?.id ?? null, now, now);
+    return { id: Number(row?.id), path };
+};
+/** A file's document is the one its writer saved it as (`import`); a change of it is logged as every link is. */
+export const logFileLink = (database, now, fileId, from, to, method = "import", author = "rules") => database
+    .prepare("INSERT INTO entity_link_events (linkable_type, linkable_id, entity_type, from_entity_id, to_entity_id, method, " +
+    "confidence, author, created_at) VALUES ('file', ?, 'document', ?, ?, ?, 1, ?, ?)")
+    .run(fileId, from == null ? null : Number(from), to, method, author, now);
+/** Moves the rows under a folder whose path changed, in one statement over the old prefix. */
+const movePaths = (database, accountId, from, to) => {
+    database
+        .prepare("UPDATE files SET path = ? || substr(path, ?), path_folded = NULL WHERE account_id = ? AND substr(path, 1, ?) = ?")
+        .run(to, from.length + 1, accountId, from.length + 1, `${from}/`);
+};
+/**
+ * Writes the `files` row of one document from the document as it is now: the document's source record. A Drive
+ * document (catalog metadata or Drive front matter) is keyed by its Drive file id and placed under its first parent;
+ * a local one by its path, under folder rows made from that path. `seen` marks a sync or import that returned it.
+ * `place` names a local file of the document other than the one its own columns name: a copy in another folder.
+ */
+export const syncFile = (database, now, documentId, { seen = true, depth = 0, place, method = "import", } = {}) => {
+    const doc = database.prepare("SELECT * FROM documents WHERE id = ?").get(documentId);
+    if (!doc)
+        return null;
+    const accountId = place?.accountId ?? Number(doc.account_id);
+    const front = place ? objectOf(place.frontMatter) : objectOf(doc.front_matter);
+    const catalog = place ? undefined : objectOf(objectOf(doc.metadata)?.catalog);
+    const provider = database.prepare("SELECT provider FROM accounts WHERE id = ?").get(accountId)?.provider;
+    // A vault file may carry an exported Drive file's front matter and still be a file on disk.
+    const remote = catalog !== undefined || (front?.source === "google-drive" && !LOCAL.has(String(provider)));
+    const externalId = (remote && stringOf(front?.fileId)) || (place?.path ?? String(doc.external_id));
+    const kind = doc.kind === "folder" ? "folder" : doc.kind === "page" ? "page" : "file";
+    let name;
+    let parent = null;
+    let metadata;
+    if (remote) {
+        name = stringOf(catalog?.name) ?? stringOf(doc.title) ?? externalId;
+        const parents = Array.isArray(catalog?.parents) ? catalog.parents.filter((one) => typeof one === "string") : [];
+        const first = parents[0];
+        if (first !== undefined && depth < MAX_DEPTH) {
+            const above = database
+                .prepare("SELECT id FROM documents WHERE account_id = ? AND external_id = ?")
+                .get(accountId, first);
+            if (above && Number(above.id) !== documentId)
+                parent = syncFile(database, now, Number(above.id), { seen: false, depth: depth + 1 });
+        }
+        const version = front?.sourceVersion;
+        metadata = {
+            ...(version === undefined || version === null ? {} : { version }),
+            ...(parents.length > 1 ? { parents } : {}),
+        };
+    }
+    else {
+        const path = place?.path ?? String(doc.external_id);
+        name = nameOf(path);
+        const slash = path.lastIndexOf("/");
+        parent = localFolder(database, now, accountId, slash < 0 ? "" : path.slice(0, slash));
+        metadata = front === undefined ? {} : { front_matter: front };
+    }
+    const path = remote ? (parent ? `${parent.path}/${name}` : name) : (place?.path ?? String(doc.external_id));
+    // The place first; then, for a Drive file first saved under its document's own key, that row (`<id>.md`).
+    const existing = (database
+        .prepare("SELECT * FROM files WHERE account_id = ? AND external_id = ?")
+        .get(accountId, place?.path ?? externalId) ??
+        (place
+            ? undefined
+            : database
+                .prepare("SELECT * FROM files WHERE document_id = ? AND account_id = ? AND external_id = ?")
+                .get(documentId, accountId, String(doc.external_id))));
+    const gone = place ? null : doc.deleted_at != null ? Number(doc.deleted_at) : catalog?.active === false ? now : null;
+    const values = {
+        account_id: accountId,
+        external_id: externalId,
+        kind,
+        name,
+        path,
+        path_folded: fold(path),
+        parent_id: parent?.id ?? null,
+        document_id: documentId,
+        mime: doc.mime ?? (remote ? (stringOf(front?.mime) ?? null) : null),
+        size: doc.size ?? (remote && Number.isSafeInteger(front?.size) ? front?.size : null),
+        content_hash: place ? place.contentHash : (doc.content_hash ?? null),
+        url: doc.url ?? (remote ? (stringOf(front?.sourceUrl) ?? null) : null),
+        external_created_at: doc.external_created_at ?? null,
+        external_updated_at: doc.external_updated_at ?? (remote ? timeOf(front?.modifiedAt) : null),
+        metadata: Object.keys(metadata).length ? JSON.stringify(metadata) : null,
+        seen_at: seen ? now : (existing?.seen_at ?? timeOf(catalog?.observedAt)),
+        deleted_at: gone === null ? null : existing?.deleted_at != null ? Number(existing.deleted_at) : gone,
+    };
+    if (!existing) {
+        const columns = Object.keys(values);
+        const row = database
+            .prepare(`INSERT INTO files (${columns.join(", ")}, created_at, updated_at) VALUES (${columns.map(() => "?").join(", ")}, ?, ?) RETURNING id`)
+            .get(...Object.values(values), Number(doc.created_at), now);
+        const placed = { id: Number(row?.id), path };
+        logFileLink(database, now, placed.id, null, documentId, method);
+        if (remote && kind === "folder")
+            placeChildren(database, now, accountId, String(doc.external_id), depth);
+        return placed;
+    }
+    const id = Number(existing.id);
+    if (existing.document_id !== documentId)
+        logFileLink(database, now, id, existing.document_id, documentId, method);
+    const changed = Object.entries(values).some(([key, value]) => key !== "seen_at" && existing[key] !== value);
+    if (changed || values.seen_at !== existing.seen_at) {
+        database
+            .prepare(`UPDATE files SET ${Object.keys(values)
+            .map((key) => `${key} = ?`)
+            .join(", ")}, updated_at = ? WHERE id = ?`)
+            .run(...Object.values(values), changed ? now : Number(existing.updated_at), id);
+        if (kind === "folder" && existing.path !== path)
+            movePaths(database, accountId, String(existing.path), path);
+    }
+    return { id, path };
+};
+/** A Drive item written before its folder sat at the root; the folder's first write puts it under it. */
+const placeChildren = (database, now, accountId, folder, depth) => {
+    const orphans = database
+        .prepare("SELECT d.id FROM documents d JOIN files f ON f.document_id = d.id WHERE d.account_id = ? AND f.parent_id IS NULL " +
+        "AND json_valid(d.metadata) AND json_extract(d.metadata, '$.catalog.parents[0]') = ?")
+        .all(accountId, folder);
+    for (const row of orphans)
+        syncFile(database, now, Number(row.id), { seen: false, depth: depth + 1 });
+};
+export const FILES_BACKFILL = "files_backfill_after";
+/**
+ * Writes the `files` row of every document stored before version 32, from the document after the cursor the
+ * migration left, in short writes: another process waits for one batch at most, and a stop resumes where it was.
+ */
+export const fillFiles = (database, now, { batch = 500 } = {}) => {
+    const cursor = database.prepare("SELECT value FROM store_settings WHERE key = ?").get(FILES_BACKFILL);
+    if (!cursor)
+        return 0;
+    let after = Number(cursor.value);
+    let filled = 0;
+    const next = database.prepare("SELECT id FROM documents WHERE id > ? ORDER BY id LIMIT ?");
+    for (;;) {
+        const ids = writeBatch(database, () => {
+            const page = next.all(after, batch).map((row) => Number(row.id));
+            const at = now();
+            for (const id of page)
+                syncFile(database, at, id, { seen: false });
+            if (page.length < batch)
+                database.prepare("DELETE FROM store_settings WHERE key = ?").run(FILES_BACKFILL);
+            else
+                database
+                    .prepare("UPDATE store_settings SET value = ?, at = ? WHERE key = ?")
+                    .run(String(page.at(-1)), at, FILES_BACKFILL);
+            return page;
+        });
+        filled += ids.length;
+        if (ids.length < batch)
+            return filled;
+        after = ids.at(-1);
+    }
+};
+const documentIdOf = (reference) => {
+    const id = /^(?:document:)?(\d+)$/u.exec(reference)?.[1];
+    if (id === undefined)
+        throw new CliError("validation_error", `${reference} is not a document reference`);
+    return Number(id);
+};
+const isoOrNull = (value) => (value == null ? null : new Date(Number(value)).toISOString());
+const idOrNull = (value) => (value == null ? null : String(value));
+export const fileOf = (row) => ({
+    id: String(row.id),
+    accountId: String(row.account_id),
+    externalId: String(row.external_id),
+    kind: row.kind,
+    name: String(row.name),
+    path: String(row.path),
+    parentId: idOrNull(row.parent_id),
+    document: row.document_id == null ? null : `document:${row.document_id}`,
+    mime: idOrNull(row.mime),
+    size: row.size == null ? null : Number(row.size),
+    contentHash: idOrNull(row.content_hash),
+    url: idOrNull(row.url),
+    externalCreatedAt: isoOrNull(row.external_created_at),
+    externalUpdatedAt: isoOrNull(row.external_updated_at),
+    metadata: objectOf(row.metadata) ?? null,
+    seenAt: isoOrNull(row.seen_at),
+    deletedAt: isoOrNull(row.deleted_at),
+});
+/**
+ * The file a document shows (requirements 3.3): live ones first, then the owner's pin, then the most recently changed.
+ * Read with the document's row joined as `d`.
+ */
+export const PREFERRED_FILE = "f.deleted_at IS NOT NULL, f.id IS NOT d.pinned_file_id, coalesce(f.external_updated_at, f.updated_at) DESC, f.id DESC";
+export const filesStoreOver = ({ database, now }) => {
+    const account = (id) => {
+        if (!/^\d+$/.test(id) || !database.prepare("SELECT 1 FROM accounts WHERE id = ?").get(Number(id)))
+            throw new CliError("not_found", `no account ${id} in the local store`);
+        return Number(id);
+    };
+    return {
+        list: async (accountId, query = {}) => {
+            const { limit = 100, offset = 0 } = query;
+            if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(offset) || offset < 0)
+                throw new CliError("validation_error", "limit takes 1–1000 and offset 0 or more");
+            const clauses = ["f.account_id = ?"];
+            const params = [account(accountId)];
+            if (!query.includeDeleted)
+                clauses.push("f.deleted_at IS NULL");
+            if (query.kind !== undefined) {
+                clauses.push("f.kind = ?");
+                params.push(query.kind);
+            }
+            if (query.under !== undefined) {
+                const prefix = fold(query.under.replace(/\/+$/u, ""));
+                // `/` sorts just before `0`, so the subtree is one range over the index.
+                clauses.push("(f.path_folded = ? OR (f.path_folded >= ? AND f.path_folded < ?))");
+                params.push(prefix, `${prefix}/`, `${prefix}0`);
+            }
+            if (query.pathContains !== undefined) {
+                clauses.push("instr(f.path_folded, ?) > 0");
+                params.push(fold(query.pathContains));
+            }
+            const rows = database
+                .prepare(`SELECT f.* FROM files f WHERE ${clauses.join(" AND ")} ORDER BY f.path_folded, f.id LIMIT ? OFFSET ?`)
+                .all(...params, limit + 1, offset);
+            return { items: rows.slice(0, limit).map(fileOf), hasMore: rows.length > limit };
+        },
+        byPath: async (accountId, path) => {
+            const row = database
+                .prepare("SELECT * FROM files WHERE account_id = ? AND path = ? ORDER BY deleted_at IS NOT NULL, id LIMIT 1")
+                .get(account(accountId), path);
+            return row ? fileOf(row) : undefined;
+        },
+        ofDocument: async (reference) => database
+            .prepare(`SELECT f.* FROM files f JOIN documents d ON d.id = f.document_id WHERE f.document_id = ? ORDER BY ${PREFERRED_FILE}`)
+            .all(documentIdOf(reference))
+            .map(fileOf),
+        pin: async (document, fileId) => write(database, () => {
+            const id = documentIdOf(document);
+            const file = /^\d+$/u.test(fileId)
+                ? database.prepare("SELECT id FROM files WHERE id = ? AND document_id = ?").get(Number(fileId), id)
+                : undefined;
+            if (!file)
+                throw new CliError("not_found", `file ${fileId} is not a file of ${document}`);
+            database
+                .prepare("UPDATE documents SET pinned_file_id = ?, updated_at = ? WHERE id = ?")
+                .run(Number(fileId), now(), id);
+        }),
+        unpin: async (document) => write(database, () => {
+            const id = documentIdOf(document);
+            if (!database.prepare("SELECT 1 FROM documents WHERE id = ?").get(id))
+                throw new CliError("not_found", `no ${document} in the local store`);
+            database.prepare("UPDATE documents SET pinned_file_id = NULL, updated_at = ? WHERE id = ?").run(now(), id);
+        }),
+    };
+};

package/dist/store/sqlite/folded.d.ts

@@ -15,6 +15,9 @@ export declare const FOLDED: readonly [{
 }, {
     readonly table: "meetings";
     readonly column: "title";
+}, {
+    readonly table: "files";
+    readonly column: "path";
 }];
 export declare const folded: (value: string | null | undefined) => string | null;
 /**

package/dist/store/sqlite/folded.js

@@ -7,6 +7,7 @@ export const FOLDED = [
     { table: "attachments", column: "name" },
     { table: "attachments", column: "local_path" },
     { table: "meetings", column: "title" },
+    { table: "files", column: "path" },
 ];
 export const folded = (value) => value === null || value === undefined ? null : fold(value);
 /**

package/dist/store/sqlite/imported-documents.js

@@ -32,7 +32,7 @@ export const importedDocumentWhere = (database, query) => {
     const columns = {
         tag: {
             where: (node) => ({
-                sql: "EXISTS (SELECT 1 FROM taggings g JOIN tags t ON t.id = g.tag_id " +
+                sql: "EXISTS (SELECT 1 FROM taggings g JOIN resolved_tags t ON t.id=g.tag_id " +
                     "WHERE g.taggable_type = 'document' AND g.taggable_id = d.id AND t.name = ?)",
                 params: [tag(node.value)],
             }),

package/dist/store/sqlite/join-keys.d.ts

@@ -0,0 +1,8 @@
+import type { CacheDatabase } from "../driver.js";
+/**
+ * Fills `meetings.join_key` where it is empty: meetings stored before version 33, and those a build of version 32
+ * writes, which does not know the column. On every open; a store with nothing to fill costs one index probe.
+ */
+export declare const fillJoinKeys: (database: CacheDatabase, { batch }?: {
+    batch?: number;
+}) => number;

package/dist/store/sqlite/join-keys.js

@@ -0,0 +1,27 @@
+import { joinKeyOf } from "../../meetings/index.js";
+import { writeBatch } from "./transaction.js";
+/**
+ * Fills `meetings.join_key` where it is empty: meetings stored before version 33, and those a build of version 32
+ * writes, which does not know the column. On every open; a store with nothing to fill costs one index probe.
+ */
+export const fillJoinKeys = (database, { batch = 2_000 } = {}) => {
+    const pending = database.prepare("SELECT id, join_url FROM meetings WHERE join_url IS NOT NULL AND join_key IS NULL AND id > ? ORDER BY id LIMIT ?");
+    if (pending.get(0, 1) === undefined)
+        return 0;
+    // A link that names no room keeps an empty key, so it is not read again on every open.
+    const fill = database.prepare("UPDATE meetings SET join_key = ? WHERE id = ?");
+    let filled = 0;
+    let after = 0;
+    for (;;) {
+        const rows = writeBatch(database, () => {
+            const page = pending.all(after, batch);
+            for (const row of page)
+                fill.run(joinKeyOf(String(row.join_url)) ?? "", Number(row.id));
+            return page;
+        });
+        filled += rows.length;
+        if (rows.length < batch)
+            return filled;
+        after = Number(rows.at(-1)?.id);
+    }
+};

package/dist/store/sqlite/knowledge.js

@@ -10,7 +10,7 @@ import { linkKind, RELATION_KINDS } from "./link-kinds.js";
 import { meetingProjectsStoreOver } from "./meeting-projects.js";
 import { insertLink, linkOf } from "./notes.js";
 import { queryFilter } from "./query-filter.js";
-import { addTags as addThingTags, canonicalTagNamed, createTag, labelsOf, removeTags as removeThingTags, setMainTopic, } from "./tags.js";
+import { addTags as addThingTags, canonicalTagNamed, createTag, labelsOf, liveTagging, removeTags as removeThingTags, setMainTopic, } from "./tags.js";
 import { TASK_KEY_PREFIXES } from "./task-keys.js";
 import { inboxKey, taskAccountOf, taskIdOf, taskRowOf } from "./tasks.js";
 import { referenceOfThing, stateOfThing, storedThing, thingOf } from "./things.js";
@@ -155,7 +155,7 @@ export const knowledgeStoreOver = (context) => {
         : null;
     /** A subfolder's labels: `labelled` links from the folder, anchored at the path, to each tag. */
     const subfolderLabels = (folder, path, tag) => database
-        .prepare("SELECT t.name FROM links l JOIN tags t ON t.id = l.to_id WHERE l.from_type = 'account' AND l.from_id = ? " +
+        .prepare("SELECT DISTINCT t.name FROM links l JOIN resolved_tags t ON t.id=l.to_id WHERE l.from_type = 'account' AND l.from_id = ? " +
         `AND l.kind = ${linkKind("labelled")} AND l.to_type = 'tag' AND l.anchor = ?${tag === undefined ? "" : " AND t.name = ?"} ORDER BY t.name`)
         .all(folder, path, ...(tag === undefined ? [] : [tag]))
         .map((row) => String(row.name));
@@ -373,7 +373,7 @@ export const knowledgeStoreOver = (context) => {
                 return write(database, () => removeThingTags(context, thing, tagsOf(tags)));
             return tagsOf(tags).filter((name) => database
                 .prepare(`DELETE FROM links WHERE from_type = 'account' AND from_id = ? AND kind = ${linkKind("labelled")} AND to_type = 'tag' AND anchor = ? ` +
-                "AND to_id IN (SELECT id FROM tags WHERE name = ?)")
+                "AND to_id IN (SELECT id FROM resolved_tags WHERE name = ?)")
                 .run(thing.id, path, name).changes > 0);
         },
         createTag: async (name, { kind = "tag", by = "owner", ...options } = {}) => write(database, () => createTag(context, canonicalTagName(name), kind, by, options)),
@@ -391,9 +391,9 @@ export const knowledgeStoreOver = (context) => {
             const subfolders = options.type === undefined || options.type === "folder";
             const rows = database
                 .prepare("SELECT * FROM (" +
-                "SELECT DISTINCT g.taggable_type AS type, g.taggable_id AS id, NULL AS path FROM taggings g JOIN tags t ON t.id = g.tag_id " +
-                `WHERE g.taggable_type IN (${types.map(() => "?").join(",") || "NULL"}) AND (? IS NULL OR t.name = ?) ` +
-                "UNION SELECT DISTINCT 'account' AS type, l.from_id AS id, l.anchor AS path FROM links l JOIN tags t ON t.id = l.to_id " +
+                "SELECT DISTINCT g.taggable_type AS type, g.taggable_id AS id, NULL AS path FROM taggings g JOIN resolved_tags t ON t.id=g.tag_id " +
+                `WHERE g.taggable_type IN (${types.map(() => "?").join(",") || "NULL"}) AND (? IS NULL OR t.name = ?) AND ${liveTagging("g")} ` +
+                "UNION SELECT DISTINCT 'account' AS type, l.from_id AS id, l.anchor AS path FROM links l JOIN resolved_tags t ON t.id=l.to_id " +
                 `WHERE ? = 1 AND l.from_type = 'account' AND l.kind = ${linkKind("labelled")} AND l.to_type = 'tag' AND (? IS NULL OR t.name = ?)` +
                 ") ORDER BY type = 'account', type, id, path LIMIT ? OFFSET ?")
                 .all(...types, tag, tag, subfolders ? 1 : 0, tag, tag, limit + 1, offset);

package/dist/store/sqlite/link-reviews.d.ts

@@ -0,0 +1,9 @@
+import type { CacheDatabase } from "../driver.js";
+/**
+ * Two or more equally good entities for one source record: one row on the owner's review list (requirements 3.6). A
+ * later sync updates the candidates of an open row and leaves a decided one as the owner left it.
+ */
+export declare const reviewLink: (database: CacheDatabase, linkable: {
+    type: string;
+    id: number;
+}, entity: string, candidates: number[], reason: string, now: number) => void;

package/dist/store/sqlite/link-reviews.js

@@ -0,0 +1,12 @@
+/**
+ * Two or more equally good entities for one source record: one row on the owner's review list (requirements 3.6). A
+ * later sync updates the candidates of an open row and leaves a decided one as the owner left it.
+ */
+export const reviewLink = (database, linkable, entity, candidates, reason, now) => {
+    database
+        .prepare(`INSERT INTO link_reviews (linkable_type, linkable_id, entity_type, candidates, reason, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, 'open', ?, ?)
+       ON CONFLICT (linkable_type, linkable_id, entity_type) DO UPDATE SET candidates = excluded.candidates,
+         reason = excluded.reason, updated_at = excluded.updated_at WHERE link_reviews.status = 'open'`)
+        .run(linkable.type, linkable.id, entity, JSON.stringify([...candidates].sort((a, b) => a - b)), reason, now, now);
+};

package/dist/store/sqlite/lucene-fields.js

@@ -12,6 +12,7 @@ import { STEM_SEPARATOR } from "../../search/stem.js";
 import { normalize } from "../normalize.js";
 import { linkMatch } from "./mention-links.js";
 import { valueMatch } from "./phone-countries.js";
+import { canonicalTagNamed } from "./tags.js";
 /**
  * A voice note's transcript is its attachment's text, whoever wrote it: speech recognition (`speech:<model>`) or an
  * agent, which writes the text of a voice attachment as `agent`. The voice attachment is the one
@@ -318,13 +319,14 @@ const found = ({ field, value }, scope) => {
         ? mentioned(scope, "mn.domain = ? AND mn.status <> 'dismissed'", [siteOf(value.toLowerCase())])
         : mentioned(scope, `mn.kind = ? AND ${match.sql} AND mn.status <> 'dismissed'`, [field, ...match.params]));
 };
-const tag = (node, { corpus }) => {
-    const name = tagOf(node.value);
-    if (name === undefined)
+const tag = (node, { corpus, database }) => {
+    const selected = tagOf(node.value);
+    if (selected === undefined)
         searchError("query.invalid-tag", node.span);
-    return always(bound(`m.id IN (SELECT tg.taggable_id FROM taggings tg JOIN tags t ON t.id=tg.tag_id WHERE t.name=? AND tg.taggable_type='${corpus.item}') OR ` +
-        `m.chat_id IN (SELECT tg.taggable_id FROM taggings tg JOIN tags t ON t.id=tg.tag_id WHERE t.name=? AND tg.taggable_type='${corpus.thread}') OR ` +
-        "m.sender_identity_id IN (SELECT tg.taggable_id FROM taggings tg JOIN tags t ON t.id=tg.tag_id WHERE t.name=? AND tg.taggable_type='identity')", name, name, name));
+    const name = canonicalTagNamed(database, selected)?.name ?? selected;
+    return always(bound(`m.id IN (SELECT tg.taggable_id FROM taggings tg JOIN resolved_tags t ON t.id=tg.tag_id WHERE t.name=? AND tg.taggable_type='${corpus.item}') OR ` +
+        `m.chat_id IN (SELECT tg.taggable_id FROM taggings tg JOIN resolved_tags t ON t.id=tg.tag_id WHERE t.name=? AND tg.taggable_type='${corpus.thread}') OR ` +
+        "m.sender_identity_id IN (SELECT tg.taggable_id FROM taggings tg JOIN resolved_tags t ON t.id=tg.tag_id WHERE t.name=? AND tg.taggable_type='identity')", name, name, name));
 };
 const messengerOnly = (compile) => (node, scope) => {
     if (scope.mail)

package/dist/store/sqlite/manifest.js

@@ -36,14 +36,25 @@ export const MANIFEST = [
     { name: "20261021224625_version-28-chat-state", version: 28, minCompatible: 1 },
     { name: "20261023105057_version-29-transcript-words", version: 29, minCompatible: 1 },
     { name: "20261023105101_version-29-transcript-words-triggers", version: 29, minCompatible: 1 },
+    { name: "20261025064253_version-30-reviewed-tag-consolidation", version: 30, minCompatible: 30 },
+    { name: "20261025064302_version-30-resolved-tag-view", version: 30, minCompatible: 30 },
+    { name: "20261025070402_version-31-drive-account", version: 31, minCompatible: 31 },
+    { name: "20261025071848_version-32-files", version: 32, minCompatible: 32 },
+    { name: "20261025071850_version-32-files-data", version: 32, minCompatible: 32 },
+    { name: "20261025072643_version-33-calendars", version: 33, minCompatible: 32 },
+    { name: "20261025072644_version-33-calendars-triggers", version: 33, minCompatible: 32 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];
     for (const entry of manifest) {
+        if (!Number.isSafeInteger(entry.minCompatible) || entry.minCompatible < 1 || entry.minCompatible > entry.version)
+            throw new Error("each migration requires an explicit valid minCompatible");
         const found = generated.find(({ name }) => name === entry.name);
         if (!found)
             throw new Error(`migration ${entry.name} is in the manifest and not in the bundle — run pnpm db:bundle`);
         const last = migrations.at(-1);
+        if (last && last.version !== entry.version && entry.minCompatible < last.minCompatible)
+            throw new Error("migration minCompatible cannot decrease");
         if (last?.version !== entry.version) {
             migrations.push({ version: entry.version, minCompatible: entry.minCompatible, statements: [...found.statements] });
         }

package/dist/store/sqlite/meeting-selection.js

@@ -35,7 +35,7 @@ export const meetingSelectionSql = (input) => {
         params.push(input.projectId);
     }
     if (input.tagId !== undefined) {
-        clauses.push("EXISTS (SELECT 1 FROM taggings g JOIN tags t ON t.id=g.tag_id WHERE g.taggable_type='meeting' AND g.taggable_id=m.id AND t.id=?)");
+        clauses.push("EXISTS (SELECT 1 FROM taggings g JOIN resolved_tags t ON t.id=g.tag_id WHERE g.taggable_type='meeting' AND g.taggable_id=m.id AND t.canonical_id=(SELECT canonical_id FROM resolved_tags WHERE id=?))");
         params.push(input.tagId);
     }
     return { clauses, params };

package/dist/store/sqlite/meetings.js

@@ -1,10 +1,11 @@
 import { CliError } from "@wirecat/cli-base";
-import { MeetingError } from "../../meetings/index.js";
+import { joinKeyOf, MeetingError } from "../../meetings/index.js";
 import { normalize } from "../normalize.js";
 import * as eventQueries from "./events.js";
 import { fromJson, int, page, str, toJson } from "./events.js";
 import { folded } from "./folded.js";
 import { meetingIdentityPk } from "./identities.js";
+import { reviewLink } from "./link-reviews.js";
 import { meetingChatLinesOver } from "./meeting-chat-lines.js";
 import { meetingContextLinksOver } from "./meeting-context-links.js";
 import { meetingHitIndexOver } from "./meeting-hit-index.js";
@@ -250,6 +251,7 @@ const save = (context, input) => {
         description: meeting.description,
         location: meeting.location,
         join_url: meeting.joinUrl,
+        join_key: meeting.joinUrl ? (joinKeyOf(meeting.joinUrl) ?? "") : null,
         started_at: meeting.startedAt,
         ended_at: meeting.endedAt,
         duration_ms: meeting.durationMs,
@@ -638,6 +640,9 @@ export const meetingStoreOver = (context) => {
         async linkMeeting(id, eventId, now, mode) {
             eventQueries.linkMeeting(database, id, eventId, now, mode);
         },
+        async reviewMeetingLink(meetingId, eventIds, now) {
+            write(database, () => reviewLink(database, { type: "meeting", id: meetingId }, "event", eventIds, "join-key", now));
+        },
         async cursor(accountId) {
             return str(database.prepare("SELECT value FROM sync_cursors WHERE account_id = ? AND key = ?").get(accountId, CURSOR_KEY)
                 ?.value);