@wirecat/cli-core 0.419.0 → 0.420.0

package/dist/store/sqlite/schema.js

@@ -1,4 +1,5 @@
 import { blob, desc, index, integer, primaryKey, real, sql, sqliteTable, text, unique, uniqueIndex, } from "./drizzle/core.js";
+import { canonicalTags } from "./schema/canonical-tags.js";
 /**
  * The store's base tables — what `drizzle-kit generate` diffs against. Every column is explained in
  * `docs/storage/schema.md`; the two must agree. A change here becomes a migration, under the rules at the
@@ -98,7 +99,11 @@ export const identities = sqliteTable("identities", {
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
     description: text("description"),
-}, (table) => [unique().on(table.provider, table.externalId)]);
+    email: text("email"),
+}, (table) => [
+    unique().on(table.provider, table.externalId),
+    index("identities_by_email").on(table.email).where(sql `email IS NOT NULL`),
+]);
 export const identityLinks = sqliteTable("identity_links", {
     identityId: integer("identity_id")
         .primaryKey()
@@ -751,7 +756,38 @@ export const documents = sqliteTable("documents", {
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
     deletedAt: integer("deleted_at"),
+    pinnedFileId: integer("pinned_file_id"),
 }, (table) => [unique().on(table.accountId, table.externalId)]);
+export const files = sqliteTable("files", {
+    id: integer("id").primaryKey(),
+    accountId: integer("account_id")
+        .notNull()
+        .references(() => accounts.id),
+    externalId: text("external_id").notNull(),
+    kind: text("kind").notNull(),
+    name: text("name").notNull(),
+    path: text("path").notNull(),
+    pathFolded: text("path_folded"),
+    parentId: integer("parent_id").references(() => files.id),
+    documentId: integer("document_id").references(() => documents.id),
+    mime: text("mime"),
+    size: integer("size"),
+    contentHash: text("content_hash"),
+    url: text("url"),
+    externalCreatedAt: integer("external_created_at"),
+    externalUpdatedAt: integer("external_updated_at"),
+    metadata: text("metadata"),
+    seenAt: integer("seen_at"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+    deletedAt: integer("deleted_at"),
+}, (table) => [
+    unique().on(table.accountId, table.externalId),
+    index("files_by_account_id_path_folded").on(table.accountId, table.pathFolded),
+    index("files_path_to_fold").on(table.id).where(sql `path_folded IS NULL`),
+    index("files_by_parent_id").on(table.parentId),
+    index("files_by_document_id").on(table.documentId),
+]);
 export const documentRevisions = sqliteTable("document_revisions", {
     id: integer("id").primaryKey(),
     documentId: integer("document_id")
@@ -817,6 +853,113 @@ export const memoryIndexPending = sqliteTable("memory_index_pending", {
     id: integer("id").notNull(),
     indexableType: text("indexable_type").notNull(),
 }, (table) => [primaryKey({ columns: [table.indexableType, table.id] })]);
+export const calendars = sqliteTable("calendars", {
+    id: integer("id").primaryKey(),
+    accountId: integer("account_id")
+        .notNull()
+        .references(() => accounts.id),
+    externalId: text("external_id").notNull(),
+    title: text("title"),
+    timezone: text("timezone"),
+    accessRole: text("access_role"),
+    primaryCalendar: integer("primary_calendar").notNull(),
+    synced: integer("synced").notNull(),
+    seenAt: integer("seen_at"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+    deletedAt: integer("deleted_at"),
+}, (table) => [unique().on(table.accountId, table.externalId)]);
+export const calendarEntries = sqliteTable("calendar_entries", {
+    id: integer("id").primaryKey(),
+    calendarId: integer("calendar_id")
+        .notNull()
+        .references(() => calendars.id),
+    kind: text("kind").notNull(),
+    seriesEntryId: integer("series_entry_id").references(() => calendarEntries.id),
+    eventId: integer("event_id").references(() => events.id),
+    eventSeriesId: integer("event_series_id").references(() => eventSeries.id),
+    externalId: text("external_id").notNull(),
+    icalUid: text("ical_uid"),
+    originalStartsAt: integer("original_starts_at"),
+    exception: integer("exception").notNull(),
+    status: text("status").notNull(),
+    title: text("title"),
+    description: text("description"),
+    location: text("location"),
+    startsAt: integer("starts_at"),
+    endsAt: integer("ends_at"),
+    allDay: integer("all_day").notNull(),
+    startDate: text("start_date"),
+    endDate: text("end_date"),
+    timezone: text("timezone"),
+    recurrence: text("recurrence"),
+    recurrenceEndsAt: integer("recurrence_ends_at"),
+    eventType: text("event_type"),
+    transparency: text("transparency"),
+    visibility: text("visibility"),
+    ownResponse: text("own_response"),
+    organizerIdentityId: integer("organizer_identity_id").references(() => identities.id),
+    joinUrl: text("join_url"),
+    joinKey: text("join_key"),
+    conference: text("conference"),
+    url: text("url"),
+    sequence: integer("sequence"),
+    etag: text("etag"),
+    externalUpdatedAt: integer("external_updated_at"),
+    metadata: text("metadata"),
+    seenAt: integer("seen_at"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+    deletedAt: integer("deleted_at"),
+}, (table) => [
+    unique().on(table.calendarId, table.externalId),
+    unique().on(table.seriesEntryId, table.originalStartsAt),
+    index("calendar_entries_by_calendar_id_starts_at").on(table.calendarId, table.startsAt),
+    index("calendar_entries_by_ical_uid").on(table.icalUid).where(sql `ical_uid IS NOT NULL`),
+    index("calendar_entries_by_join_key").on(table.joinKey).where(sql `join_key IS NOT NULL`),
+    index("calendar_entries_by_event_id").on(table.eventId),
+    index("calendar_entries_by_event_series_id").on(table.eventSeriesId),
+    index("calendar_entries_by_event_type_event_id").on(table.eventType, table.eventId),
+    index("calendar_entries_by_organizer_identity_id").on(table.organizerIdentityId),
+]);
+export const calendarEntryRevisions = sqliteTable("calendar_entry_revisions", {
+    id: integer("id").primaryKey(),
+    entryId: integer("entry_id")
+        .notNull()
+        .references(() => calendarEntries.id),
+    title: text("title"),
+    startsAt: integer("starts_at"),
+    endsAt: integer("ends_at"),
+    location: text("location"),
+    status: text("status"),
+    recurrence: text("recurrence"),
+    recurrenceEndsAt: integer("recurrence_ends_at"),
+    externalUpdatedAt: integer("external_updated_at"),
+    createdAt: integer("created_at").notNull(),
+}, (table) => [index("calendar_entry_revisions_by_entry_id_created_at").on(table.entryId, table.createdAt)]);
+export const calendarEntryParticipants = sqliteTable("calendar_entry_participants", {
+    id: integer("id").primaryKey(),
+    entryId: integer("entry_id")
+        .notNull()
+        .references(() => calendarEntries.id),
+    identityId: integer("identity_id").references(() => identities.id),
+    email: text("email").notNull(),
+    name: text("name"),
+    response: text("response"),
+    optional: integer("optional").notNull(),
+    organizer: integer("organizer").notNull(),
+    self: integer("self").notNull(),
+    resource: integer("resource").notNull(),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+}, (table) => [
+    unique().on(table.entryId, table.email),
+    index("calendar_entry_participants_by_identity_id").on(table.identityId),
+]);
+export const eventIndexPending = sqliteTable("event_index_pending", {
+    id: integer("id").notNull(),
+    indexableType: text("indexable_type").notNull(),
+}, (table) => [primaryKey({ columns: [table.indexableType, table.id] })]);
 export const eventSeries = sqliteTable("event_series", {
     id: integer("id").primaryKey(),
     title: text("title"),
@@ -838,6 +981,9 @@ export const events = sqliteTable("events", {
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
     deletedAt: integer("deleted_at"),
+    status: text("status"),
+    allDay: integer("all_day"),
+    sourceDeletedAt: integer("source_deleted_at"),
 }, (table) => [index("events_by_time").on(table.startsAt), index("events_by_event_series_id").on(table.eventSeriesId)]);
 export const meetingSeries = sqliteTable("meeting_series", {
     id: integer("id").primaryKey(),
@@ -883,10 +1029,12 @@ export const meetings = sqliteTable("meetings", {
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
     deletedAt: integer("deleted_at"),
-    /** `fold(title)`: SQLite's lower() folds ASCII only, so filters compare this. */
     titleFolded: text("title_folded"),
+    joinKey: text("join_key"),
 }, (table) => [
     unique().on(table.accountId, table.externalId),
+    index("meetings_by_join_key").on(table.joinKey).where(sql `join_key IS NOT NULL`),
+    index("meetings_join_key_to_fill").on(table.id).where(sql `join_url IS NOT NULL AND join_key IS NULL`),
     index("meetings_by_time").on(table.accountId, desc(table.startedAt)),
     index("meetings_by_account_id_title_folded").on(table.accountId, table.titleFolded),
     index("meetings_title_to_fold").on(table.id).where(sql `title IS NOT NULL AND title_folded IS NULL`),
@@ -1252,26 +1400,23 @@ export const agentActions = sqliteTable("agent_actions", {
     index("agent_actions_by_actor_type_actor_id").on(table.actorType, table.actorId),
     index("agent_actions_by_target_type_target_id").on(table.targetType, table.targetId),
 ]);
-export const tags = sqliteTable("tags", {
-    id: integer("id").primaryKey(),
-    name: text("name").notNull().unique(),
-    kind: text("kind").notNull().default("tag"),
-    createdAt: integer("created_at").notNull(),
-    updatedAt: integer("updated_at").notNull(),
-});
-export const autoTagClaims = sqliteTable("auto_tag_claims", {
+export { canonicalTags } from "./schema/canonical-tags.js";
+export const canonicalAutoTagClaims = sqliteTable("canonical_auto_tag_claims", {
     chatId: integer("chat_id")
         .notNull()
         .references(() => chats.id),
     tagId: integer("tag_id")
         .notNull()
-        .references(() => tags.id),
+        .references(() => canonicalTags.id),
     algorithm: text("algorithm").notNull(),
     score: real("score").notNull(),
     fields: text("fields").notNull(),
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
-}, (table) => [primaryKey({ columns: [table.chatId, table.tagId] }), index("auto_tag_claims_by_tag_id").on(table.tagId)]);
+}, (table) => [
+    primaryKey({ columns: [table.chatId, table.tagId] }),
+    index("canonical_auto_tag_claims_by_tag_id").on(table.tagId),
+]);
 export const links = sqliteTable("links", {
     id: integer("id").primaryKey(),
     fromType: text("from_type").notNull(),
@@ -1320,7 +1465,7 @@ export const taggings = sqliteTable("taggings", {
     id: integer("id").primaryKey(),
     tagId: integer("tag_id")
         .notNull()
-        .references(() => tags.id),
+        .references(() => canonicalTags.id),
     taggableType: text("taggable_type").notNull(),
     taggableId: integer("taggable_id").notNull(),
     main: integer("main").notNull().default(0),
@@ -1334,6 +1479,39 @@ export const taggings = sqliteTable("taggings", {
     uniqueIndex("taggings_main_topic").on(table.taggableType, table.taggableId).where(sql `main = 1`),
     index("taggings_by_author_type_author_id").on(table.authorType, table.authorId),
 ]);
+export { tagConsolidations, tagRedirects } from "./schema/tag-consolidations.js";
+export const entityLinkEvents = sqliteTable("entity_link_events", {
+    id: integer("id").primaryKey(),
+    linkableType: text("linkable_type").notNull(),
+    linkableId: integer("linkable_id").notNull(),
+    entityType: text("entity_type").notNull(),
+    fromEntityId: integer("from_entity_id"),
+    toEntityId: integer("to_entity_id"),
+    method: text("method").notNull(),
+    confidence: real("confidence"),
+    author: text("author").notNull(),
+    createdAt: integer("created_at").notNull(),
+}, (table) => [
+    index("entity_link_events_by_linkable_type_linkable_id").on(table.linkableType, table.linkableId),
+    index("entity_link_events_by_entity_type_to_entity_id").on(table.entityType, table.toEntityId),
+]);
+export const linkReviews = sqliteTable("link_reviews", {
+    id: integer("id").primaryKey(),
+    linkableType: text("linkable_type").notNull(),
+    linkableId: integer("linkable_id").notNull(),
+    entityType: text("entity_type").notNull(),
+    candidates: text("candidates").notNull(),
+    reason: text("reason").notNull(),
+    status: text("status").notNull(),
+    chosenId: integer("chosen_id"),
+    decidedBy: text("decided_by"),
+    decidedAt: integer("decided_at"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+}, (table) => [
+    unique().on(table.linkableType, table.linkableId, table.entityType),
+    index("link_reviews_by_status_created_at").on(table.status, table.createdAt),
+]);
 export const conversations = sqliteTable("conversations", {
     id: integer("id").primaryKey(),
     chatId: integer("chat_id")

package/dist/store/sqlite/tag-consolidation-apply.d.ts

@@ -0,0 +1,3 @@
+import type { TagConsolidationApplyOptions, TagConsolidationOptions, TagConsolidationPreview, TagConsolidationReceipt } from "../../domain/tag-consolidation.js";
+import type { StoreContext } from "./open.js";
+export declare const applyTagConsolidation: (context: StoreContext, preview: (options: TagConsolidationOptions) => TagConsolidationPreview, options: TagConsolidationApplyOptions) => TagConsolidationReceipt;

package/dist/store/sqlite/tag-consolidation-apply.js

@@ -0,0 +1,88 @@
+import { createHash } from "node:crypto";
+import { CliError } from "@wirecat/cli-base";
+import { createTagRedirectIndex } from "../../domain/tag-redirects.js";
+import { ownerPerson } from "./actors.js";
+import { consolidationApplyInput } from "./tag-consolidation-input.js";
+import { tagRedirectSnapshot } from "./tag-resolution.js";
+import { write } from "./transaction.js";
+const receiptOf = (row) => ({
+    id: String(row.id),
+    sourceId: String(row.source_id),
+    survivorId: String(row.survivor_id),
+    sourceMemberIds: JSON.parse(String(row.source_member_ids)),
+    survivorMemberIds: JSON.parse(String(row.survivor_member_ids)),
+    actor: { type: "person", id: String(row.actor_id) },
+    createdAt: new Date(Number(row.created_at)).toISOString(),
+    idempotencyKey: String(row.idempotency_key),
+    vocabularyFingerprint: String(row.vocabulary_fingerprint),
+    previewFingerprint: String(row.preview_fingerprint),
+    counts: JSON.parse(String(row.counts)),
+});
+export const applyTagConsolidation = (context, preview, options) => {
+    const { source, survivor, maxRows, maxReadBytes } = consolidationApplyInput(options);
+    const { database, now } = context;
+    const check = () => {
+        if (options.signal?.aborted)
+            throw new CliError("cancelled", "tag consolidation was cancelled");
+    };
+    check();
+    return write(database, () => {
+        const owner = ownerPerson(database);
+        const request = createHash("sha256")
+            .update(JSON.stringify([
+            source,
+            survivor,
+            owner.type,
+            owner.id,
+            options.expectedVocabularyFingerprint,
+            options.expectedPreviewFingerprint,
+        ]))
+            .digest("hex");
+        const held = database
+            .prepare("SELECT * FROM tag_consolidations WHERE idempotency_key=?")
+            .get(options.idempotencyKey);
+        if (held) {
+            if (held.request_fingerprint !== request)
+                throw new CliError("configuration_error", "idempotencyKey already records another reviewed tag consolidation");
+            return receiptOf(held);
+        }
+        const selected = preview({
+            sourceId: options.sourceId,
+            survivorId: options.survivorId,
+            expectedVocabularyFingerprint: options.expectedVocabularyFingerprint,
+            maxRows,
+            maxReadBytes,
+            sampleLimit: 1,
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        if (selected.previewFingerprint !== options.expectedPreviewFingerprint)
+            throw new CliError("configuration_error", "tag dependencies changed since the consolidation preview", {
+                reason: "vocabulary.stale",
+            });
+        const graph = tagRedirectSnapshot(database);
+        createTagRedirectIndex({
+            ...graph,
+            redirects: [
+                ...graph.redirects.map((row) => row.survivorId === String(source) ? { ...row, survivorId: String(survivor) } : row),
+                { sourceId: String(source), survivorId: String(survivor) },
+            ],
+        });
+        const at = now();
+        const counts = {
+            assignments: selected.assignments.source + selected.assignments.survivor,
+            aliases: selected.aliases.source + selected.aliases.survivor,
+            automaticClaims: selected.automaticClaims.source + selected.automaticClaims.survivor,
+            links: selected.links.total,
+        };
+        check();
+        database.prepare("UPDATE tag_redirects SET survivor_id=? WHERE survivor_id=?").run(survivor, source);
+        database
+            .prepare("INSERT INTO tag_redirects(source_id,survivor_id,created_at) VALUES(?,?,?)")
+            .run(source, survivor, at);
+        tagRedirectSnapshot(database);
+        const row = database
+            .prepare("INSERT INTO tag_consolidations(source_id,survivor_id,source_member_ids,survivor_member_ids,actor_type,actor_id,created_at,idempotency_key,vocabulary_fingerprint,preview_fingerprint,counts,request_fingerprint) VALUES(?,?,?,?,?,?,?,?,?,?,?,?) RETURNING *")
+            .get(source, survivor, JSON.stringify(selected.sourceMemberIds), JSON.stringify(selected.survivorMemberIds), owner.type, owner.id, at, options.idempotencyKey, selected.vocabularyFingerprint, selected.previewFingerprint, JSON.stringify(counts), request);
+        return receiptOf(row);
+    }, { beforeCommit: check });
+};

package/dist/store/sqlite/tag-consolidation-input.d.ts

@@ -0,0 +1,16 @@
+import type { TagConsolidationApplyOptions, TagConsolidationOptions } from "../../domain/tag-consolidation.js";
+export declare const consolidationId: (value: unknown, field: string) => number;
+export declare const consolidationInput: (options: TagConsolidationOptions, apply?: boolean) => {
+    source: number;
+    survivor: number;
+    maxRows: number;
+    maxReadBytes: number;
+    limit: number;
+};
+export declare const consolidationApplyInput: (options: TagConsolidationApplyOptions) => {
+    source: number;
+    survivor: number;
+    maxRows: number;
+    maxReadBytes: number;
+    limit: number;
+};

package/dist/store/sqlite/tag-consolidation-input.js

@@ -0,0 +1,52 @@
+import { CliError } from "@wirecat/cli-base";
+export const consolidationId = (value, field) => {
+    if (typeof value !== "string" || !/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value)))
+        throw new CliError("validation_error", `${field} must be a positive canonical tag id`);
+    return Number(value);
+};
+const bounded = (value, max, field) => {
+    if (!Number.isSafeInteger(value) || value < 1 || value > max)
+        throw new CliError("validation_error", `${field} must be an integer from 1 to ${max}`);
+    return value;
+};
+export const consolidationInput = (options, apply = false) => {
+    if (!options || typeof options !== "object" || Array.isArray(options))
+        throw new CliError("validation_error", "consolidation options are required");
+    const allowed = new Set([
+        "sourceId",
+        "survivorId",
+        "expectedVocabularyFingerprint",
+        "maxRows",
+        "maxReadBytes",
+        "signal",
+        ...(apply ? ["by", "expectedPreviewFingerprint", "idempotencyKey"] : ["sampleLimit"]),
+    ]);
+    for (const field of Object.keys(options))
+        if (!allowed.has(field))
+            throw new CliError("validation_error", `unknown consolidation field: ${field}`);
+    const source = consolidationId(options.sourceId, "sourceId");
+    const survivor = consolidationId(options.survivorId, "survivorId");
+    if (source === survivor)
+        throw new CliError("validation_error", "sourceId and survivorId must differ");
+    if (typeof options.expectedVocabularyFingerprint !== "string" ||
+        !/^v1:all:all:[a-f0-9]{64}$/.test(options.expectedVocabularyFingerprint))
+        throw new CliError("validation_error", "expectedVocabularyFingerprint must come from a complete unfiltered vocabulary preview");
+    return {
+        source,
+        survivor,
+        maxRows: bounded(options.maxRows ?? 5000, 20000, "maxRows"),
+        maxReadBytes: bounded(options.maxReadBytes ?? 1024 * 1024, 16 * 1024 * 1024, "maxReadBytes"),
+        limit: apply ? 1 : bounded(options.sampleLimit ?? 10, 100, "sampleLimit"),
+    };
+};
+export const consolidationApplyInput = (options) => {
+    const input = consolidationInput(options, true);
+    if (options.by !== "owner")
+        throw new CliError("permission_error", "only the owner applies a reviewed tag consolidation");
+    if (typeof options.expectedPreviewFingerprint !== "string" ||
+        !/^tag-preview-v1:[a-f0-9]{64}$/.test(options.expectedPreviewFingerprint))
+        throw new CliError("validation_error", "expectedPreviewFingerprint must come from a tag consolidation preview");
+    if (typeof options.idempotencyKey !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/.test(options.idempotencyKey))
+        throw new CliError("validation_error", "idempotencyKey must be 1–128 ASCII identifier characters");
+    return input;
+};

package/dist/store/sqlite/tag-consolidation.js

@@ -1,77 +1,59 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
+import { createTagRedirectIndex } from "../../domain/tag-redirects.js";
+import { applyTagConsolidation } from "./tag-consolidation-apply.js";
+import { consolidationInput } from "./tag-consolidation-input.js";
+import { tagCanonicalId, tagRedirectSnapshot } from "./tag-resolution.js";
 import { read } from "./transaction.js";
 const selections = [
-    ["taggings", "tag_id IN (?,?)"],
-    ["aliases", "aliasable_type='tag' AND aliasable_id IN (?,?)"],
-    ["auto_tag_claims", "tag_id IN (?,?)"],
-    ["links", "(from_type='tag' AND from_id IN (?,?)) OR (to_type='tag' AND to_id IN (?,?))"],
+    ["taggings", "tag_id IN (SELECT value FROM json_each(?))"],
+    ["aliases", "aliasable_type='tag' AND aliasable_id IN (SELECT value FROM json_each(?))"],
+    ["canonical_auto_tag_claims", "tag_id IN (SELECT value FROM json_each(?))"],
+    [
+        "links",
+        "(from_type='tag' AND from_id IN (SELECT value FROM json_each(?))) OR (to_type='tag' AND to_id IN (SELECT value FROM json_each(?)))",
+    ],
 ];
-const bounded = (value, max, field) => {
-    if (!Number.isSafeInteger(value) || value < 1 || value > max)
-        throw new CliError("validation_error", `${field} must be an integer from 1 to ${max}`);
-    return value;
-};
-const idOf = (value, field) => {
-    if (typeof value !== "string" || !/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value)))
-        throw new CliError("validation_error", `${field} must be a positive canonical tag id`);
-    return Number(value);
-};
 const cancelled = (options) => {
     if (options.signal?.aborted)
         throw new CliError("cancelled", "tag consolidation preview was cancelled");
 };
 export const tagConsolidationStoreOver = (context, catalog) => ({
-    previewTagConsolidation: async (options) => {
-        if (!options || typeof options !== "object")
-            throw new CliError("validation_error", "preview options are required");
-        const allowed = new Set([
-            "sourceId",
-            "survivorId",
-            "expectedVocabularyFingerprint",
-            "maxRows",
-            "maxReadBytes",
-            "sampleLimit",
-            "signal",
-        ]);
-        for (const field of Object.keys(options))
-            if (!allowed.has(field))
-                throw new CliError("validation_error", `unknown preview field: ${field}`);
-        const source = idOf(options.sourceId, "sourceId");
-        const survivor = idOf(options.survivorId, "survivorId");
-        if (source === survivor)
-            throw new CliError("validation_error", "sourceId and survivorId must differ");
-        if (typeof options.expectedVocabularyFingerprint !== "string" ||
-            !/^v1:all:all:[a-f0-9]{64}$/.test(options.expectedVocabularyFingerprint))
-            throw new CliError("validation_error", "expectedVocabularyFingerprint must come from a complete unfiltered vocabulary preview");
-        const maxRows = bounded(options.maxRows ?? 5000, 20000, "maxRows");
-        const maxReadBytes = bounded(options.maxReadBytes ?? 1024 * 1024, 16 * 1024 * 1024, "maxReadBytes");
-        const limit = bounded(options.sampleLimit ?? 10, 100, "sampleLimit");
-        cancelled(options);
-        // The catalog and dependency rows must describe one SQLite snapshot, including when called inside a write.
-        return read(context.database, () => {
-            const current = catalog();
-            if (current.fingerprint !== options.expectedVocabularyFingerprint)
-                throw new CliError("configuration_error", "vocabulary changed since the preview", {
-                    reason: "vocabulary.stale",
-                });
-            const selected = [source, survivor].map((id) => current.entries.find((entry) => entry.id === String(id) && entry.kind !== "project"));
-            if (selected.some((entry) => !entry))
-                throw new CliError("not_found", "a selected canonical tag is unavailable");
-            if (selected.some((entry) => entry?.kind !== "tag"))
-                throw new CliError("validation_error", "consolidation preview supports tags only");
-            return previewRows(context, options, source, survivor, maxRows, maxReadBytes, limit, current);
-        });
-    },
+    previewTagConsolidation: async (options) => previewTagConsolidation(context, catalog, options),
+    applyTagConsolidation: async (options) => applyTagConsolidation(context, (input) => previewTagConsolidation(context, catalog, input), options),
 });
+const previewTagConsolidation = (context, catalog, options) => {
+    const { source, survivor, maxRows, maxReadBytes, limit } = consolidationInput(options);
+    cancelled(options);
+    return read(context.database, () => {
+        const current = catalog();
+        if (current.fingerprint !== options.expectedVocabularyFingerprint)
+            throw new CliError("configuration_error", "vocabulary changed since the preview", { reason: "vocabulary.stale" });
+        if (tagCanonicalId(context.database, source) === tagCanonicalId(context.database, survivor))
+            throw new CliError("validation_error", "sourceId and survivorId already resolve to the same canonical tag");
+        const selected = [source, survivor].map((id) => current.entries.find((entry) => entry.id === String(id) && entry.kind !== "project"));
+        if (selected.some((entry) => !entry))
+            throw new CliError("not_found", "a selected canonical tag is unavailable");
+        if (selected.some((entry) => entry?.kind !== "tag"))
+            throw new CliError("validation_error", "consolidation preview supports tags only");
+        return previewRows(context, options, source, survivor, maxRows, maxReadBytes, limit, current);
+    });
+};
 const previewRows = (context, options, source, survivor, maxRows, maxReadBytes, limit, catalog) => {
     const rows = new Map();
     let count = 0;
-    let readBytes = 0;
-    const hash = createHash("sha256").update(JSON.stringify([source, survivor, catalog.fingerprint]));
+    const graph = tagRedirectSnapshot(context.database);
+    const index = createTagRedirectIndex(graph);
+    const sourceMemberIds = index.resolve(String(source)).memberIds;
+    const survivorMemberIds = index.resolve(String(survivor)).memberIds;
+    const sourceMembers = new Set(sourceMemberIds.map(Number));
+    const memberIds = JSON.stringify([...sourceMemberIds, ...survivorMemberIds].map(Number));
+    const captured = JSON.stringify(graph);
+    let readBytes = Buffer.byteLength(captured);
+    const hash = createHash("sha256").update(JSON.stringify([source, survivor, catalog.fingerprint, graph]));
     for (const [table, where] of selections) {
         cancelled(options);
-        const parameters = table === "links" ? [source, survivor, source, survivor] : [source, survivor];
+        const parameters = table === "links" ? [memberIds, memberIds] : [memberIds];
         const columns = context.database
             .prepare(`PRAGMA table_info(${table})`)
             .all()
@@ -87,7 +69,7 @@ const previewRows = (context, options, source, survivor, maxRows, maxReadBytes,
         if (count + size > maxRows || Number(totals?.bytes ?? 0) + readBytes > maxReadBytes)
             throw new CliError("validation_error", "tag dependencies exceed the preview budget; no partial preview was produced", { reason: "vocabulary.consolidation-over-budget", table });
         const values = context.database
-            .prepare(`SELECT * FROM ${table} WHERE ${where} ORDER BY ${table === "auto_tag_claims" ? "chat_id,tag_id" : "id"} LIMIT ?`)
+            .prepare(`SELECT * FROM ${table} WHERE ${where} ORDER BY ${table === "canonical_auto_tag_claims" ? "chat_id,tag_id" : "id"} LIMIT ?`)
             .all(...parameters, maxRows + 1);
         const serialized = JSON.stringify(values);
         readBytes += Buffer.byteLength(serialized);
@@ -103,25 +85,26 @@ const previewRows = (context, options, source, survivor, maxRows, maxReadBytes,
     cancelled(options);
     const assignments = rows.get("taggings") ?? [];
     const aliases = rows.get("aliases") ?? [];
-    const claims = rows.get("auto_tag_claims") ?? [];
+    const claims = rows.get("canonical_auto_tag_claims") ?? [];
     const links = rows.get("links") ?? [];
     const byTargetType = new Map();
     for (const row of assignments) {
         const type = String(row.taggable_type);
         const totals = byTargetType.get(type) ?? { type, source: 0, survivor: 0 };
-        if (Number(row.tag_id) === source)
+        if (sourceMembers.has(Number(row.tag_id)))
             totals.source++;
         else
             totals.survivor++;
         byTargetType.set(type, totals);
     }
     const counts = (values, field) => ({
-        source: values.filter((row) => Number(row[field]) === source).length,
-        survivor: values.filter((row) => Number(row[field]) === survivor).length,
+        source: values.filter((row) => sourceMembers.has(Number(row[field]))).length,
+        survivor: values.filter((row) => !sourceMembers.has(Number(row[field]))).length,
     });
     const overlaps = (values, key) => {
-        const targets = new Set(values.filter((row) => Number(row.tag_id) === source).map(key));
-        return values.filter((row) => Number(row.tag_id) === survivor && targets.has(key(row))).length;
+        const targets = new Set(values.filter((row) => sourceMembers.has(Number(row.tag_id))).map(key));
+        return new Set(values.filter((row) => !sourceMembers.has(Number(row.tag_id)) && targets.has(key(row))).map(key))
+            .size;
     };
     const target = (id) => {
         const entry = catalog.entries.find((row) => row.kind === "tag" && row.id === String(id));
@@ -130,6 +113,8 @@ const previewRows = (context, options, source, survivor, maxRows, maxReadBytes,
     return {
         source: target(source),
         survivor: target(survivor),
+        sourceMemberIds,
+        survivorMemberIds,
         vocabularyFingerprint: catalog.fingerprint,
         previewFingerprint: `tag-preview-v1:${hash.digest("hex")}`,
         assignments: {
@@ -171,7 +156,7 @@ const previewRows = (context, options, source, survivor, maxRows, maxReadBytes,
             rows: count,
             readBytes,
             samplesComplete: [assignments, aliases, links].every((values) => values.length <= limit),
-            applySupported: false,
+            applySupported: true,
         },
     };
 };