@wirecat/zoom-cli 0.55.0 → 0.57.0

package/dist/bundle/chunk-RRRBMQ2E.js

@@ -0,0 +1,844 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  organization,
+  project,
+  reminder
+} from "./chunk-YB4DMKYX.js";
+import {
+  MIGRATIONS,
+  SnapshotBudget,
+  assertReadCompatible,
+  botNamed,
+  canonicalTagNamed,
+  decodeProjectAnnotationSnapshot,
+  migrate,
+  openSqlite,
+  openStoreContext,
+  ownerPerson,
+  previewAnnotationSnapshot,
+  projectAnnotationBindingSources,
+  projectAnnotationSnapshot,
+  projectAnnotationSnapshotFingerprint,
+  read,
+  referenceOfThing,
+  stateOfThing,
+  storedThing,
+  syncFile,
+  tagMemberIds,
+  thingOf,
+  write
+} from "./chunk-WJHK5D7Z.js";
+import {
+  filesAccountSql,
+  folderProviderOf,
+  folderProviderSql,
+  isDocumentAccountProvider
+} from "./chunk-GARCOIB6.js";
+import {
+  queryFieldsOf
+} from "./chunk-LSVI3A5X.js";
+import {
+  CliError
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/document-transfer/index.js
+import { realpathSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/sqlite/document-transfer/people.js
+var planPeople = /* @__PURE__ */ __name((database, snapshot, mappings, bindings, conflicts) => {
+  const creatable = /* @__PURE__ */ new Set();
+  let people = 0, identities = 0;
+  for (const external of snapshot.external) {
+    if (!external.person)
+      continue;
+    const matched = external.person.identities.flatMap((identity) => {
+      const row = database.prepare("SELECT i.id,l.person_id FROM identities i LEFT JOIN identity_links l ON l.identity_id=i.id WHERE i.provider=? AND i.external_id=?").get(String(identity.provider), String(identity.external_id));
+      if (row && row.person_id == null)
+        conflicts.add(`a destination identity has no person for ${external.reference}`);
+      if (!row) {
+        identities++;
+        creatable.add(`identity:${String(identity.id)}`);
+        return [];
+      }
+      mappings.set(`identity:${String(identity.id)}`, { type: "identity", id: Number(row.id) });
+      return row.person_id == null ? [] : [Number(row.person_id)];
+    });
+    let selected = mappings.get(external.key);
+    const binding = bindings[external.reference];
+    if (binding !== void 0)
+      selected = thingOf(database, binding);
+    else if (external.owner)
+      selected = ownerPerson(database);
+    else if (new Set(matched).size === 1)
+      selected = { type: "person", id: matched[0] };
+    if (selected && (selected.type !== "person" || stateOfThing(database, selected) !== "available"))
+      selected = void 0;
+    if (new Set(matched).size > 1 || selected && matched.some((id) => id !== selected.id))
+      conflicts.add(`source identities disagree with the destination person for ${external.reference}`);
+    if (selected)
+      mappings.set(external.key, selected);
+    else if (binding === void 0) {
+      creatable.add(external.key);
+      people++;
+    }
+  }
+  return { creatable, people, identities };
+}, "planPeople");
+var copyPeople = /* @__PURE__ */ __name((database, snapshot, mappings, now) => {
+  for (const external of snapshot.external) {
+    if (!external.person)
+      continue;
+    let person = mappings.get(external.key);
+    if (!person) {
+      const row = database.prepare("INSERT INTO persons (name,owner,created_at,updated_at) VALUES (?,0,?,?) RETURNING id").get(external.person.name, now(), now());
+      person = { type: "person", id: Number(row?.id) };
+      mappings.set(external.key, person);
+    }
+    for (const identity of external.person.identities) {
+      let row = database.prepare("SELECT i.id,l.person_id FROM identities i LEFT JOIN identity_links l ON l.identity_id=i.id WHERE i.provider=? AND i.external_id=?").get(String(identity.provider), String(identity.external_id));
+      if (row && Number(row.person_id) !== person.id)
+        throw new CliError("configuration_error", "an identity belongs to another destination person; the transfer was rolled back");
+      if (!row)
+        row = database.prepare("INSERT INTO identities (provider,external_id,name,username,bot,created_at,updated_at) VALUES (?,?,?,?,?,?,?) RETURNING id").get(String(identity.provider), String(identity.external_id), identity.name ?? null, identity.username ?? null, identity.bot ?? null, identity.created_at ?? now(), identity.updated_at ?? now());
+      if (!database.prepare("SELECT identity_id FROM identity_links WHERE identity_id=?").get(Number(row?.id)))
+        database.prepare("INSERT INTO identity_links (identity_id,person_id,method,confidence,author,source,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?)").run(Number(row?.id), person.id, identity.link_method ?? "transfer", identity.link_confidence ?? 1, identity.link_author ?? "owner", identity.link_source ?? null, identity.link_created_at ?? now(), identity.link_updated_at ?? now());
+      mappings.set(`identity:${String(identity.id)}`, { type: "identity", id: Number(row?.id) });
+    }
+  }
+}, "copyPeople");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/document-transfer/digest.js
+import { createHash } from "node:crypto";
+var digest = /* @__PURE__ */ __name((value) => createHash("sha256").update(JSON.stringify(value)).digest("hex"), "digest");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/sqlite/document-transfer/collection.js
+var documentsKeyOf = /* @__PURE__ */ __name((collection) => {
+  const colon = collection.indexOf(":");
+  const provider = collection.slice(0, colon);
+  return colon > 0 && isDocumentAccountProvider(provider) ? { provider, account: collection.slice(colon + 1) } : void 0;
+}, "documentsKeyOf");
+var collectionNameOf = /* @__PURE__ */ __name((row) => isDocumentAccountProvider(String(row.provider)) ? `${String(row.provider)}:${String(row.external_id)}` : String(row.name), "collectionNameOf");
+var collectionAccounts = /* @__PURE__ */ __name((database, collection) => {
+  const key = documentsKeyOf(collection);
+  return key ? database.prepare(`SELECT * FROM accounts WHERE (provider=? AND external_id=?) OR (${folderProviderSql()} AND name=?) ORDER BY id LIMIT 2`).all(key.provider, key.account, collection) : database.prepare(`SELECT * FROM accounts WHERE ${folderProviderSql()} AND name=? ORDER BY id LIMIT 2`).all(collection);
+}, "collectionAccounts");
+var movedFromOf = /* @__PURE__ */ __name((row) => {
+  if (typeof row?.settings !== "string")
+    return void 0;
+  try {
+    const moved = JSON.parse(row.settings).movedFrom;
+    return typeof moved === "object" && moved !== null ? moved : void 0;
+  } catch {
+    return void 0;
+  }
+}, "movedFromOf");
+var currentCollection = /* @__PURE__ */ __name((row) => {
+  const key = isDocumentAccountProvider(String(row.provider)) ? void 0 : documentsKeyOf(String(row.name));
+  if (!key)
+    return row;
+  const settings = (() => {
+    try {
+      return typeof row.settings === "string" ? JSON.parse(row.settings) : {};
+    } catch {
+      return {};
+    }
+  })();
+  return {
+    ...row,
+    provider: key.provider,
+    external_id: key.account,
+    name: "Google Drive",
+    settings: JSON.stringify({
+      ...settings,
+      movedFrom: { id: row.id, external_id: row.external_id, name: row.name }
+    })
+  };
+}, "currentCollection");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/sqlite/document-transfer/plan.js
+var planTransfer = /* @__PURE__ */ __name((database, snapshot, sourceKey, bindings) => {
+  const mappings = /* @__PURE__ */ new Map();
+  const missing = /* @__PURE__ */ new Set(), conflicts = /* @__PURE__ */ new Set();
+  const snapshotHash = digest(snapshot);
+  const bindingsHash = digest(Object.entries(bindings).sort(([a], [b]) => a.localeCompare(b)));
+  const collection = String(snapshot.collection.external_id);
+  const targets = collectionAccounts(database, collectionNameOf(snapshot.collection));
+  if (targets.length > 1)
+    conflicts.add("the destination has duplicate document collection identities");
+  const target = targets[0];
+  if (!target && database.prepare(`SELECT id FROM accounts WHERE ${folderProviderSql()} AND external_id=?`).get(collection))
+    conflicts.add("source collection identity is held by another destination collection");
+  const hasReceipts = database.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='document_annotation_transfers'").get();
+  const receipt = hasReceipts && database.prepare("SELECT * FROM document_annotation_transfers WHERE source_key=? AND collection IN (?,?,?) LIMIT 1").get(sourceKey, collection, String(movedFromOf(snapshot.collection)?.external_id ?? collection), String(movedFromOf(target)?.external_id ?? collection));
+  if (receipt && (receipt.snapshot_hash !== snapshotHash || receipt.bindings_hash !== bindingsHash))
+    conflicts.add("the source or binding decisions changed after a completed transfer; keep the original store selected");
+  if (target && target.scope !== snapshot.collection.scope)
+    conflicts.add("the destination collection has a different scope or an organization binding");
+  for (const entity of snapshot.entities) {
+    if (entity.kind !== "document" || !target)
+      continue;
+    const existing = database.prepare("SELECT * FROM documents WHERE account_id=? AND external_id=?").get(Number(target.id), String(entity.values.external_id));
+    if (!existing)
+      continue;
+    mappings.set(entity.key, { type: "document", id: Number(existing.id) });
+    for (const field of ["body", "content_hash", "deleted_at", "revision"])
+      if (existing[field] !== entity.values[field])
+        conflicts.add(`destination content differs for ${entity.key}`);
+    for (const revision of entity.revisions) {
+      const row = database.prepare("SELECT body FROM document_revisions WHERE document_id=? AND revision=?").get(Number(existing.id), Number(revision.revision));
+      if (row && row.body !== revision.body)
+        conflicts.add(`destination revision differs for ${entity.key}`);
+    }
+  }
+  if (receipt && receipt.snapshot_hash === snapshotHash && receipt.bindings_hash === bindingsHash)
+    for (const [key, value] of Object.entries(JSON.parse(String(receipt.reference_map))))
+      mappings.set(key, value);
+  const personPlan = planPeople(database, snapshot, mappings, bindings, conflicts);
+  const knownBindings = new Set(snapshot.external.map((item) => item.reference));
+  for (const key of Object.keys(bindings))
+    if (!knownBindings.has(key))
+      throw new CliError("validation_error", "a transfer binding names a reference outside the source annotation graph");
+  for (const external of snapshot.external) {
+    let found = mappings.get(external.key);
+    if (personPlan.creatable.has(external.key) && bindings[external.reference] === void 0)
+      continue;
+    if (external.key === `account:${String(snapshot.collection.id)}` && bindings[external.reference] === void 0) {
+      if (target)
+        mappings.set(external.key, { type: "account", id: Number(target.id) });
+      continue;
+    }
+    const binding = bindings[external.reference];
+    if (binding !== void 0)
+      found = thingOf(database, binding);
+    else if (external.owner)
+      found = ownerPerson(database);
+    else if (external.bot) {
+      const bot = database.prepare("SELECT id,kind FROM bots WHERE name=?").get(external.bot.name);
+      if (bot && bot.kind !== external.bot.kind)
+        conflicts.add(`destination bot kind differs for ${external.reference}`);
+      if (bot)
+        found = { type: "bot", id: Number(bot.id) };
+      else
+        continue;
+    } else if (external.collection && external.external_id) {
+      const holders = JSON.stringify(collectionAccounts(database, external.collection).map(({ id }) => Number(id)));
+      const row = database.prepare("SELECT id FROM documents WHERE account_id IN (SELECT value FROM json_each(?)) AND external_id=? AND deleted_at IS NULL ORDER BY id LIMIT 1").get(holders, external.external_id);
+      if (row)
+        found = { type: "document", id: Number(row.id) };
+    } else if (["message", "chat", "identity", "email", "email_thread"].includes(external.kind))
+      found = thingOf(database, external.reference);
+    if (found?.type === "document" && external.document_fingerprint) {
+      const content = database.prepare("SELECT body,content_hash,deleted_at FROM documents WHERE id=?").get(found.id);
+      if (!content || digest(content) !== external.document_fingerprint)
+        conflicts.add(`destination evidence content differs for ${external.reference}`);
+    }
+    if (found && found.type === external.kind && stateOfThing(database, found) === "available")
+      mappings.set(external.key, found);
+    else
+      missing.add(external.reference);
+  }
+  const organization2 = snapshot.collection.organization_id == null ? null : mappings.get(`organization:${String(snapshot.collection.organization_id)}`)?.id;
+  if (target && target.organization_id !== organization2)
+    conflicts.add("the destination collection has a different organization binding");
+  for (const tagging of snapshot.taggings) {
+    if (Number(tagging.tag_group_size ?? 1) > 1)
+      conflicts.add(`source tag ${String(tagging.tag_id)} belongs to a consolidated group; annotation transfer cannot preserve that group yet`);
+    const tag = canonicalTagNamed(database, String(tagging.tag_name));
+    if (tag && tagMemberIds(database, tag.id).length > 1)
+      conflicts.add(`destination tag ${String(tag.id)} belongs to a consolidated group; annotation transfer cannot preserve independent contributions yet`);
+    if (tag && tag.name !== tagging.tag_name)
+      conflicts.add(`destination vocabulary resolves source tag ${String(tagging.tag_id)} to another canonical label`);
+    if (tag && tag.kind !== tagging.tag_kind)
+      conflicts.add(`destination tag kind differs for source tag ${String(tagging.tag_id)}`);
+    const subject = mappings.get(`${String(tagging.taggable_type)}:${String(tagging.taggable_id)}`);
+    if (!subject)
+      continue;
+    const existing = tag && database.prepare("SELECT source,main FROM taggings WHERE tag_id=? AND taggable_type=? AND taggable_id=?").get(Number(tag.id), subject.type, subject.id);
+    if (existing && (existing.source !== tagging.source || existing.main !== tagging.main))
+      conflicts.add(`destination tag assignment differs for ${subject.type}:${subject.id}`);
+    if (tagging.main === 1) {
+      const main = database.prepare("SELECT tag_id FROM taggings WHERE taggable_type=? AND taggable_id=? AND main=1").get(subject.type, subject.id);
+      if (main && Number(main.tag_id) !== Number(tag?.id))
+        conflicts.add(`destination primary topic differs for ${subject.type}:${subject.id}`);
+    }
+  }
+  for (const alias of snapshot.aliases) {
+    const sourceTag = snapshot.taggings.find((tagging) => tagging.tag_id === alias.aliasable_id);
+    const named = canonicalTagNamed(database, String(alias.name));
+    const targetTag = sourceTag && canonicalTagNamed(database, String(sourceTag.tag_name));
+    if (named && named.id !== targetTag?.id)
+      conflicts.add(`destination alias conflicts with source tag ${String(alias.aliasable_id)}`);
+    if (targetTag && alias.display === 1) {
+      const displayed = database.prepare("SELECT name_folded FROM aliases WHERE aliasable_type='tag' AND aliasable_id=? AND account_id IS NULL AND display=1").get(targetTag.id);
+      if (displayed && displayed.name_folded !== alias.name_folded)
+        conflicts.add(`destination display alias conflicts with source tag ${String(alias.aliasable_id)}`);
+    }
+  }
+  const counts = {
+    documents: snapshot.entities.filter((item) => item.kind === "document").length,
+    notes: snapshot.entities.filter((item) => item.kind === "note").length,
+    memories: snapshot.entities.filter((item) => item.kind === "memory").length,
+    facts: snapshot.entities.filter((item) => item.kind === "fact").length,
+    tags: snapshot.taggings.length,
+    links: snapshot.links.length,
+    people: personPlan.people,
+    identities: personPlan.identities,
+    authors: snapshot.external.filter((item) => item.bot && !mappings.has(item.key)).length,
+    aliases: snapshot.aliases.length
+  };
+  if (receipt && conflicts.size === 0) {
+    for (const [key, value] of Object.entries(JSON.parse(String(receipt.reference_map)))) {
+      if (stateOfThing(database, value) === "unavailable")
+        conflicts.add("a transferred destination record is missing");
+      mappings.set(key, value);
+    }
+  }
+  const fingerprint = digest({
+    sourceKey,
+    snapshotHash,
+    bindingsHash,
+    collection: target?.id ?? null,
+    mappings: [...mappings.entries()].sort(([a], [b]) => a.localeCompare(b)),
+    conflicts: [...conflicts],
+    missing: [...missing]
+  });
+  return {
+    preview: {
+      fingerprint,
+      source_documents: snapshot.entities.filter((entity) => entity.kind === "document").map((entity) => ({
+        external_id: String(entity.values.external_id),
+        content_hash: entity.values.content_hash == null ? null : String(entity.values.content_hash)
+      })).sort((a, b) => a.external_id.localeCompare(b.external_id)),
+      counts,
+      missing_bindings: [...missing].sort(),
+      conflicts: [...conflicts].sort(),
+      already_transferred: Boolean(receipt) && conflicts.size === 0 && missing.size === 0,
+      ready: conflicts.size === 0 && missing.size === 0
+    },
+    mappings,
+    snapshotHash,
+    bindingsHash,
+    ...target ? { collectionId: Number(target.id) } : {}
+  };
+}, "planTransfer");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/sqlite/document-transfer/snapshot.js
+var TRANSFER_TABLES = { document: "documents", note: "notes", memory: "memories", fact: "facts" };
+var MAX_ENTITIES = 1e3;
+var MAX_AUXILIARY = 1e4;
+var MAX_BYTES = 16 * 1024 * 1024;
+var keyOf = /* @__PURE__ */ __name((type, id) => `${String(type)}:${String(id)}`, "keyOf");
+var isAnnotation = /* @__PURE__ */ __name((type) => type === "note" || type === "memory" || type === "fact", "isAnnotation");
+var valuesOf = /* @__PURE__ */ __name((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => {
+  if (value !== null && typeof value !== "string" && typeof value !== "number")
+    throw new CliError("configuration_error", "the source contains an unsupported annotation value");
+  return [key, value];
+})), "valuesOf");
+var transferSnapshot = /* @__PURE__ */ __name((database, collection) => read(database, () => {
+  const accounts = collectionAccounts(database, collection);
+  if (accounts.length > 1)
+    throw new CliError("configuration_error", "the source has duplicate document collection identities; select a repaired copy before transferring");
+  const account = accounts[0];
+  if (!account)
+    throw new CliError("not_found", "the source store does not hold the requested document collection");
+  if (!database.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='facts'").get())
+    throw new CliError("configuration_error", "the source store needs schema 2 or newer; upgrade a separate copy before transferring");
+  let bytes = 0;
+  const bounded = /* @__PURE__ */ __name((row) => {
+    const values = valuesOf(row);
+    bytes += Buffer.byteLength(JSON.stringify(values));
+    if (bytes > MAX_BYTES)
+      throw new CliError("validation_error", "annotation transfer exceeds its 16 MiB snapshot limit");
+    return values;
+  }, "bounded");
+  const entities = /* @__PURE__ */ new Map();
+  const links = /* @__PURE__ */ new Map();
+  const taggings = /* @__PURE__ */ new Map();
+  const canonicalTags = Boolean(database.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='canonical_tags'").get());
+  const tagTable = canonicalTags ? "canonical_tags" : "tags";
+  const resolution = canonicalTags ? "r.canonical_id AS tag_canonical_id,(SELECT count(*) FROM resolved_tags members WHERE members.canonical_id=r.canonical_id) AS tag_group_size" : "t.id AS tag_canonical_id,1 AS tag_group_size";
+  const dependencies = /* @__PURE__ */ new Map();
+  const depend = /* @__PURE__ */ __name((type, id) => {
+    if (type != null && id != null)
+      dependencies.set(keyOf(type, id), { type: String(type), id: Number(id) });
+  }, "depend");
+  const add = /* @__PURE__ */ __name((kind, row) => {
+    const key = keyOf(kind, row.id);
+    if (entities.has(key))
+      return;
+    if (entities.size >= MAX_ENTITIES)
+      throw new CliError("validation_error", "annotation transfer exceeds 1000 document and annotation records");
+    const values = bounded(row);
+    entities.set(key, { key, kind, values, revisions: [] });
+  }, "add");
+  for (const row of database.prepare("SELECT * FROM documents WHERE account_id=? ORDER BY id LIMIT 1001").all(Number(account.id)))
+    add("document", row);
+  for (const entity of entities.values()) {
+    const { kind, values } = entity;
+    for (const [child, subject] of [
+      ["note", "notable"],
+      ["memory", "subject"],
+      ["fact", "subject"]
+    ]) {
+      for (const row of database.prepare(`SELECT * FROM ${TRANSFER_TABLES[child]} WHERE ${subject}_type=? AND ${subject}_id=? ORDER BY id LIMIT 1001`).all(kind, Number(values.id)))
+        add(child, row);
+    }
+    for (const row of database.prepare("SELECT * FROM links WHERE (from_type=? AND from_id=?) OR (to_type=? AND to_id=?) ORDER BY id LIMIT 10001").all(kind, Number(values.id), kind, Number(values.id))) {
+      if (links.has(String(row.id)))
+        continue;
+      if (links.size >= MAX_AUXILIARY)
+        throw new CliError("validation_error", "annotation transfer exceeds 10000 relationships");
+      links.set(String(row.id), bounded(row));
+      for (const side of ["from", "to"]) {
+        const type = row[`${side}_type`], id = row[`${side}_id`];
+        depend(type, id);
+        if (isAnnotation(type)) {
+          const related = database.prepare(`SELECT * FROM ${TRANSFER_TABLES[type]} WHERE id=?`).get(Number(id));
+          if (related)
+            add(type, related);
+        }
+      }
+    }
+    for (const row of database.prepare(`SELECT g.*,t.name AS tag_name,t.kind AS tag_kind,${resolution} FROM taggings g JOIN ${tagTable} t ON t.id=g.tag_id ${canonicalTags ? "JOIN resolved_tags r ON r.id=t.id" : ""} WHERE g.taggable_type=? AND g.taggable_id=? ORDER BY g.id LIMIT 10001`).all(kind, Number(values.id))) {
+      if (taggings.size >= MAX_AUXILIARY)
+        throw new CliError("validation_error", "annotation transfer exceeds 10000 tag assignments");
+      taggings.set(String(row.id), bounded(row));
+      depend(row.author_type, row.author_id);
+    }
+    for (const prefix of ["notable", "subject", "author", "confirmed_by"])
+      depend(values[`${prefix}_type`], values[`${prefix}_id`]);
+    if (values.project_id != null)
+      depend("project", values.project_id);
+    if (kind === "memory" || kind === "fact")
+      for (const next of database.prepare(`SELECT * FROM ${TRANSFER_TABLES[kind]} WHERE supersedes_id=? ORDER BY id LIMIT 1001`).all(Number(values.id)))
+        add(kind, next);
+    if (values.supersedes_id != null) {
+      depend(kind, values.supersedes_id);
+      const previous = database.prepare(`SELECT * FROM ${TRANSFER_TABLES[kind]} WHERE id=?`).get(values.supersedes_id);
+      if (previous)
+        add(kind, previous);
+    }
+    if (kind === "document" || kind === "note") {
+      const table = kind === "document" ? "document_revisions" : "note_revisions";
+      const rows = database.prepare(`SELECT * FROM ${table} WHERE ${kind}_id=? ORDER BY id LIMIT 10001`).all(Number(values.id));
+      if (rows.length > MAX_AUXILIARY)
+        throw new CliError("validation_error", "annotation transfer exceeds 10000 revisions on one record");
+      entity.revisions = rows.map(bounded);
+    }
+  }
+  if (account.organization_id != null)
+    depend("organization", account.organization_id);
+  const external = [];
+  const aliases = [];
+  for (const tag of new Set([...taggings.values()].map((item) => Number(item.tag_id))))
+    for (const alias of database.prepare("SELECT * FROM aliases WHERE aliasable_type='tag' AND aliasable_id=? AND account_id IS NULL ORDER BY id LIMIT 10001").all(tag)) {
+      if (aliases.length >= MAX_AUXILIARY)
+        throw new CliError("validation_error", "annotation transfer exceeds 10000 label aliases");
+      aliases.push(bounded(alias));
+    }
+  for (const [key, thing] of dependencies) {
+    if (entities.has(key))
+      continue;
+    const reference = referenceOfThing(database, storedThing(thing.type, thing.id)) ?? key;
+    const item = { key, reference, kind: thing.type };
+    if (thing.type === "person") {
+      const person = database.prepare("SELECT name,owner FROM persons WHERE id=?").get(thing.id);
+      if (person) {
+        item.owner = person.owner === 1;
+        item.person = {
+          name: person.name == null ? null : String(person.name),
+          identities: database.prepare("SELECT i.id,i.provider,i.external_id,i.name,i.username,i.bot,i.created_at,i.updated_at,l.method AS link_method,l.confidence AS link_confidence,l.author AS link_author,l.source AS link_source,l.created_at AS link_created_at,l.updated_at AS link_updated_at FROM identities i JOIN identity_links l ON l.identity_id=i.id WHERE l.person_id=? ORDER BY i.id LIMIT 10001").all(thing.id).map(bounded)
+        };
+        if (item.person.identities.length > MAX_AUXILIARY)
+          throw new CliError("validation_error", "annotation transfer exceeds 10000 identities for one person");
+      }
+    }
+    if (thing.type === "identity") {
+      const identity = database.prepare("SELECT person_id FROM identity_links WHERE identity_id=?").get(thing.id);
+      if (identity?.person_id != null)
+        depend("person", identity.person_id);
+    }
+    if (thing.type === "bot") {
+      const bot = database.prepare("SELECT name,kind FROM bots WHERE id=?").get(thing.id);
+      if (bot)
+        item.bot = { name: String(bot.name), kind: String(bot.kind) };
+    }
+    if (thing.type === "document") {
+      const doc = database.prepare(`SELECT a.provider,a.external_id AS account,a.name,d.external_id,d.body,d.content_hash,d.deleted_at FROM documents d JOIN accounts a ON a.id=d.account_id WHERE d.id=? AND ${filesAccountSql("a.provider")}`).get(thing.id);
+      if (doc) {
+        item.collection = collectionNameOf({ provider: doc.provider, external_id: doc.account, name: doc.name });
+        item.external_id = String(doc.external_id);
+        const content = bounded({ body: doc.body, content_hash: doc.content_hash, deleted_at: doc.deleted_at });
+        item.document_fingerprint = digest(content);
+      }
+    }
+    external.push(item);
+  }
+  return {
+    collection: bounded(currentCollection(account)),
+    entities: [...entities.values()].sort((a, b) => a.key.localeCompare(b.key)),
+    links: [...links.values()].sort((a, b) => Number(a.id) - Number(b.id)),
+    taggings: [...taggings.values()].sort((a, b) => Number(a.id) - Number(b.id)),
+    external: external.sort((a, b) => a.key.localeCompare(b.key)),
+    aliases
+  };
+}), "transferSnapshot");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/sqlite/document-transfer/apply.js
+var providerHere = /* @__PURE__ */ __name(({ provider, name, settings }) => {
+  if (provider !== "folder" || String(name ?? "").startsWith("google-drive:"))
+    return provider ?? null;
+  return folderProviderOf(formatOf(settings) === "markdown" ? "markdown" : "obsidian");
+}, "providerHere");
+var formatOf = /* @__PURE__ */ __name((settings) => {
+  try {
+    return JSON.parse(String(settings))?.format;
+  } catch {
+    return void 0;
+  }
+}, "formatOf");
+var COLUMNS = {
+  document: "account_id external_id kind title location file_name extension url storage local_path mime size content_hash front_matter body normalized_text extraction extraction_error language revision export_path external_created_at external_updated_at metadata created_at updated_at deleted_at",
+  note: "notable_type notable_id title body author_type author_id revision created_at updated_at deleted_at",
+  memory: "kind body subject_type subject_id author_type author_id model confidence status last_verified_at supersedes_id scope created_at updated_at deleted_at",
+  fact: "type statement status project_id subject_type subject_id occurred_at supersedes_id author_type author_id model confirmed_by_type confirmed_by_id scope source metadata created_at updated_at deleted_at"
+};
+var LINK_COLUMNS = "from_type from_id to_type to_id kind anchor source target_text target_folded role evidence metadata confirmed created_at author updated_at";
+var TAGGING_COLUMNS = "tag_id taggable_type taggable_id main source author_type author_id created_at updated_at";
+var insert = /* @__PURE__ */ __name((database, table, columns, values) => {
+  const fields = columns.split(" ");
+  const row = database.prepare(`INSERT INTO ${table} (${fields.join(",")}) VALUES (${fields.map(() => "?").join(",")}) RETURNING id`).get(...fields.map((field) => values[field] ?? null));
+  return Number(row?.id);
+}, "insert");
+var mapped = /* @__PURE__ */ __name((mappings, type, id) => {
+  if (type == null && id == null)
+    return void 0;
+  const result = mappings.get(`${String(type)}:${String(id)}`);
+  if (!result)
+    throw new CliError("configuration_error", "an annotation reference was not resolved; the transfer was rolled back");
+  return result;
+}, "mapped");
+var applyTransfer = /* @__PURE__ */ __name((database, snapshot, sourceKey, bindings, expectedFingerprint, now) => write(database, () => {
+  const plan = planTransfer(database, snapshot, sourceKey, bindings);
+  if (plan.preview.fingerprint !== expectedFingerprint)
+    throw new CliError("validation_error", "the transfer preview changed; preview it again before applying");
+  if (!plan.preview.ready)
+    throw new CliError("configuration_error", "the transfer has unresolved references or conflicts; preview it before applying");
+  const mappings = plan.mappings;
+  const references = /* @__PURE__ */ __name(() => Object.fromEntries([...mappings].map(([key, value]) => [key, referenceOfThing(database, value) ?? `${value.type}:${value.id}`])), "references");
+  const documents = /* @__PURE__ */ __name((refs2) => Object.fromEntries(snapshot.entities.filter((entity) => entity.kind === "document").map((entity) => [String(entity.values.external_id), refs2[entity.key]])), "documents");
+  if (plan.preview.already_transferred) {
+    const refs2 = references();
+    return { ...plan.preview, references: refs2, documents: documents(refs2) };
+  }
+  copyPeople(database, snapshot, mappings, now);
+  const owner = ownerPerson(database);
+  for (const external of snapshot.external)
+    if (external.bot && !mappings.has(external.key))
+      mappings.set(external.key, botNamed(database, external.bot.name, now(), external.bot.kind));
+  let collectionId = plan.collectionId;
+  if (collectionId === void 0) {
+    const organization2 = snapshot.collection.organization_id == null ? void 0 : mapped(mappings, "organization", snapshot.collection.organization_id);
+    collectionId = insert(database, "accounts", "provider external_id name created_at settings updated_at scope organization_id", {
+      ...snapshot.collection,
+      provider: providerHere(snapshot.collection),
+      organization_id: organization2?.id ?? null
+    });
+  }
+  mappings.set(`account:${String(snapshot.collection.id)}`, { type: "account", id: collectionId });
+  const inserted = /* @__PURE__ */ new Set();
+  const ordered = [...snapshot.entities].sort((a, b) => Number(a.kind !== "document") - Number(b.kind !== "document"));
+  for (const entity of ordered) {
+    if (mappings.has(entity.key))
+      continue;
+    const values = { ...entity.values };
+    if (entity.kind === "document")
+      values.account_id = collectionId;
+    else {
+      for (const prefix of ["notable", "subject", "author", "confirmed_by"]) {
+        if (!Object.hasOwn(values, `${prefix}_type`))
+          continue;
+        const required = prefix === "notable" || prefix === "author" && entity.kind !== "note";
+        values[`${prefix}_type`] = required ? owner.type : null;
+        values[`${prefix}_id`] = required ? owner.id : null;
+      }
+      if (Object.hasOwn(values, "supersedes_id"))
+        values.supersedes_id = null;
+      if (Object.hasOwn(values, "project_id"))
+        values.project_id = null;
+    }
+    const id = insert(database, TRANSFER_TABLES[entity.kind], COLUMNS[entity.kind], values);
+    if (entity.kind === "document")
+      syncFile(database, now(), id, { seen: false });
+    mappings.set(entity.key, { type: entity.kind, id });
+    inserted.add(entity.key);
+  }
+  for (const entity of ordered) {
+    const destination = mappings.get(entity.key);
+    if (inserted.has(entity.key))
+      remapEntity(database, entity, destination.id, mappings);
+    if (entity.kind === "document" || entity.kind === "note") {
+      const table = entity.kind === "document" ? "document_revisions" : "note_revisions";
+      for (const revision of entity.revisions) {
+        const existing = database.prepare(`SELECT body FROM ${table} WHERE ${entity.kind}_id=? AND revision=?`).get(destination.id, Number(revision.revision));
+        if (existing)
+          continue;
+        insert(database, table, `${entity.kind}_id body revision created_at`, {
+          ...revision,
+          [`${entity.kind}_id`]: destination.id
+        });
+      }
+    }
+  }
+  for (const tagging of snapshot.taggings) {
+    const tag = canonicalTagNamed(database, String(tagging.tag_name));
+    const tagId = tag ? Number(tag.id) : insert(database, "canonical_tags", "name kind created_at updated_at", {
+      name: tagging.tag_name ?? null,
+      kind: tagging.tag_kind ?? null,
+      created_at: tagging.created_at ?? null,
+      updated_at: tagging.updated_at ?? null
+    });
+    const subject = mapped(mappings, tagging.taggable_type, tagging.taggable_id);
+    const author = mapped(mappings, tagging.author_type, tagging.author_id);
+    if (database.prepare("SELECT id FROM taggings WHERE tag_id=? AND taggable_type=? AND taggable_id=?").get(tagId, subject.type, subject.id))
+      continue;
+    insert(database, "taggings", TAGGING_COLUMNS, {
+      ...tagging,
+      tag_id: tagId,
+      taggable_type: subject.type,
+      taggable_id: subject.id,
+      author_type: author?.type ?? null,
+      author_id: author?.id ?? null
+    });
+  }
+  for (const alias of snapshot.aliases) {
+    const sourceTag = snapshot.taggings.find((tagging) => tagging.tag_id === alias.aliasable_id);
+    const targetTag = canonicalTagNamed(database, String(sourceTag?.tag_name));
+    if (!targetTag)
+      throw new CliError("configuration_error", "an imported label alias has no canonical tag; the transfer was rolled back");
+    const existing = database.prepare("SELECT id FROM aliases WHERE aliasable_type='tag' AND aliasable_id=? AND account_id IS NULL AND name_folded=?").get(targetTag.id, String(alias.name_folded));
+    if (!existing)
+      insert(database, "aliases", "aliasable_type aliasable_id account_id name name_folded display source created_at updated_at", { ...alias, aliasable_id: targetTag.id });
+  }
+  for (const link of snapshot.links) {
+    const from = mapped(mappings, link.from_type, link.from_id);
+    const to = mapped(mappings, link.to_type, link.to_id);
+    insert(database, "links", LINK_COLUMNS, {
+      ...link,
+      from_type: from.type,
+      from_id: from.id,
+      to_type: to?.type ?? null,
+      to_id: to?.id ?? null
+    });
+  }
+  database.prepare("INSERT INTO document_annotation_transfers (source_key,collection,snapshot_hash,bindings_hash,reference_map,created_at) VALUES (?,?,?,?,?,?)").run(sourceKey, String(snapshot.collection.external_id), plan.snapshotHash, plan.bindingsHash, JSON.stringify(Object.fromEntries(mappings)), now());
+  const refs = references();
+  return { ...plan.preview, references: refs, documents: documents(refs) };
+}), "applyTransfer");
+var remapEntity = /* @__PURE__ */ __name((database, entity, id, mappings) => {
+  const columns = [], values = [];
+  for (const prefix of ["notable", "subject", "author", "confirmed_by"]) {
+    if (!Object.hasOwn(entity.values, `${prefix}_type`))
+      continue;
+    const target = mapped(mappings, entity.values[`${prefix}_type`], entity.values[`${prefix}_id`]);
+    columns.push(`${prefix}_type=?`, `${prefix}_id=?`);
+    values.push(target?.type ?? null, target?.id ?? null);
+  }
+  if (Object.hasOwn(entity.values, "supersedes_id")) {
+    columns.push("supersedes_id=?");
+    values.push(entity.values.supersedes_id == null ? null : mapped(mappings, entity.kind, entity.values.supersedes_id).id);
+  }
+  if (Object.hasOwn(entity.values, "project_id")) {
+    columns.push("project_id=?");
+    values.push(entity.values.project_id == null ? null : mapped(mappings, "project", entity.values.project_id).id);
+  }
+  if (columns.length)
+    database.prepare(`UPDATE ${TRANSFER_TABLES[entity.kind]} SET ${columns.join(",")} WHERE id=?`).run(...values, id);
+}, "remapEntity");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/document-transfer/index.js
+var locations = /* @__PURE__ */ __name((options) => {
+  for (const value of [options.source, options.destination, options.collection])
+    if (typeof value !== "string" || !value.trim())
+      throw new CliError("validation_error", "transfer source, destination and collection are required");
+  if (!statSync(options.source, { throwIfNoEntry: false })?.isFile())
+    throw new CliError("not_found", "the source store does not exist as a file");
+  const source = realpathSync(options.source), destination = resolve(options.destination);
+  const left = statSync(source), right = statSync(destination, { throwIfNoEntry: false });
+  if (right && (!right.isFile() || left.dev === right.dev && left.ino === right.ino))
+    throw new CliError("validation_error", "the source and destination must be different ordinary store files");
+  const bindings = options.bindings ?? {};
+  if (!bindings || typeof bindings !== "object" || Array.isArray(bindings) || Object.values(bindings).some((value) => typeof value !== "string" || !value.trim()))
+    throw new CliError("validation_error", "transfer bindings must map source references to destination references");
+  return { source, destination, sourceKey: digest([left.dev, left.ino, left.birthtimeMs]), bindings };
+}, "locations");
+var openSource = /* @__PURE__ */ __name(async (path) => {
+  const opened = await openSqlite(path, { readOnly: true });
+  try {
+    const row = opened.database.prepare("SELECT version,min_compatible FROM schema_migrations ORDER BY version DESC LIMIT 1").get();
+    const version = Number(row?.version), minimum = Number(row?.min_compatible);
+    if (!Number.isSafeInteger(version) || version < 2 || version > (MIGRATIONS.at(-1)?.version ?? 0) || !Number.isSafeInteger(minimum) || minimum < 1 || minimum > version || minimum > (MIGRATIONS.at(-1)?.version ?? 0))
+      throw new CliError("configuration_error", "the store schema is not compatible with document annotation transfer; upgrade a separate copy first");
+    return opened;
+  } catch (error) {
+    opened.database.close();
+    if (error instanceof CliError)
+      throw error;
+    throw new CliError("configuration_error", "the store has no readable annotation schema; it was not changed");
+  }
+}, "openSource");
+var openPreviewTarget = /* @__PURE__ */ __name(async (path) => {
+  if (statSync(path, { throwIfNoEntry: false })) {
+    const opened = await openSource(path);
+    try {
+      assertReadCompatible(opened.database);
+      return opened;
+    } catch (error) {
+      opened.database.close();
+      throw error;
+    }
+  }
+  const target = await openSqlite(":memory:");
+  try {
+    migrate(target.database);
+    return target;
+  } catch (error) {
+    target.database.close();
+    throw error;
+  }
+}, "openPreviewTarget");
+var previewDocumentTransfer = /* @__PURE__ */ __name(async (options) => {
+  const location = locations(options);
+  const source = await openSource(location.source);
+  try {
+    const target = await openPreviewTarget(location.destination);
+    try {
+      return planTransfer(target.database, transferSnapshot(source.database, options.collection), location.sourceKey, location.bindings).preview;
+    } finally {
+      target.database.close();
+    }
+  } finally {
+    source.database.close();
+  }
+}, "previewDocumentTransfer");
+var applyDocumentTransfer = /* @__PURE__ */ __name(async (options) => {
+  if (!/^[a-f0-9]{64}$/.test(options.expected_fingerprint))
+    throw new CliError("validation_error", "apply requires the fingerprint returned by a transfer preview");
+  const location = locations(options);
+  const source = await openSource(location.source);
+  try {
+    const snapshot = transferSnapshot(source.database, options.collection);
+    const check = await openPreviewTarget(location.destination);
+    try {
+      const preview = planTransfer(check.database, snapshot, location.sourceKey, location.bindings).preview;
+      if (preview.fingerprint !== options.expected_fingerprint)
+        throw new CliError("validation_error", "the transfer preview changed; preview it again before applying");
+      if (!preview.ready)
+        throw new CliError("configuration_error", "the transfer has unresolved references or conflicts; preview it before applying");
+    } finally {
+      check.database.close();
+    }
+    const target = await openStoreContext({ path: location.destination, env: options.env });
+    try {
+      const receipt = applyTransfer(target.database, snapshot, location.sourceKey, location.bindings, options.expected_fingerprint, target.now);
+      if (digest(transferSnapshot(source.database, options.collection)) !== digest(snapshot))
+        throw new CliError("configuration_error", "source annotations changed during the transfer; the source and copied snapshot were retained, keep the original store selected");
+      return receipt;
+    } finally {
+      target.database.close();
+    }
+  } finally {
+    source.database.close();
+  }
+}, "applyDocumentTransfer");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/knowledge-query.js
+var ORGANIZATIONS_QUERY = {
+  entity: "organization",
+  backend: "sql",
+  fields: queryFieldsOf(organization, {
+    native: ["id", "kind", "scope", "created_at"],
+    examples: { id: "id:1", kind: "kind:company", scope: "scope:work", created_at: "created_at>=2026-01-01" }
+  })
+};
+var PROJECTS_QUERY = {
+  entity: "project",
+  backend: "sql",
+  fields: queryFieldsOf(project, {
+    native: ["id", "key", "type", "organization_id", "scope", "created_at"],
+    examples: {
+      id: "id:1",
+      key: "key:SMP",
+      type: "type:work",
+      organization_id: "organization_id:1",
+      scope: "scope:work",
+      created_at: "created_at>=2026-01-01"
+    }
+  })
+};
+var REMINDERS_QUERY = {
+  entity: "reminder",
+  backend: "sql",
+  fields: queryFieldsOf(reminder, {
+    native: ["id", "state", "due_at", "revision"],
+    examples: { id: "id:1", state: "state:pending", due_at: "due_at>=2026-01-01", revision: "revision>1" }
+  })
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/project-transfer/preview.js
+var previewProjectAnnotationSnapshot = /* @__PURE__ */ __name(async (options) => {
+  if (!options || typeof options !== "object" || Array.isArray(options))
+    throw new CliError("validation_error", "project preview options are required");
+  for (const field of Object.keys(options))
+    if (!["snapshot", "target", "project", "bindings", "maxReadBytes", "env"].includes(field))
+      throw new CliError("validation_error", `unknown project preview field ${field}`);
+  const snapshot = decodeProjectAnnotationSnapshot(options.snapshot);
+  projectAnnotationBindingSources(snapshot, options.bindings);
+  if (typeof options.target !== "string" || !options.target.trim() || options.target.length > 4096)
+    throw new CliError("validation_error", "project preview target is an explicit existing store path");
+  if (typeof options.project !== "string" || !/^project:[1-9]\d*$/.test(options.project) || !Number.isSafeInteger(Number(options.project.slice(8))))
+    throw new CliError("validation_error", "project preview project is a project:<safe integer id> reference");
+  const budget = new SnapshotBudget(options.maxReadBytes ?? 4 * 1024 * 1024);
+  const context = await openStoreContext({ path: options.target, env: options.env, readOnly: true });
+  try {
+    return previewAnnotationSnapshot(context.database, Number(options.project.slice(8)), snapshot, options.bindings, budget);
+  } finally {
+    context.database.close();
+  }
+}, "previewProjectAnnotationSnapshot");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/project-transfer/snapshot.js
+var snapshotProjectAnnotations = /* @__PURE__ */ __name(async (options) => {
+  if (!options || typeof options !== "object" || Array.isArray(options))
+    throw new CliError("validation_error", "snapshot options are required");
+  for (const field of Object.keys(options))
+    if (!["source", "project", "env", "maxReadBytes"].includes(field))
+      throw new CliError("validation_error", `unknown snapshot field ${field}`);
+  if (typeof options.source !== "string" || !options.source.trim() || options.source.length > 4096)
+    throw new CliError("validation_error", "snapshot source is an explicit existing store path");
+  if (typeof options.project !== "string" || !/^project:[1-9]\d*$/.test(options.project) || !Number.isSafeInteger(Number(options.project.slice(8))))
+    throw new CliError("validation_error", "snapshot project is a project:<safe integer id> reference");
+  const budget = new SnapshotBudget(options.maxReadBytes ?? 4 * 1024 * 1024);
+  const context = await openStoreContext({ path: options.source, env: options.env, readOnly: true });
+  try {
+    const result = projectAnnotationSnapshot(context.database, Number(options.project.slice(8)), budget);
+    return { ...result, fingerprint: projectAnnotationSnapshotFingerprint(JSON.stringify(result.snapshot)) };
+  } finally {
+    context.database.close();
+  }
+}, "snapshotProjectAnnotations");
+
+export {
+  previewDocumentTransfer,
+  applyDocumentTransfer,
+  ORGANIZATIONS_QUERY,
+  PROJECTS_QUERY,
+  REMINDERS_QUERY,
+  previewProjectAnnotationSnapshot,
+  snapshotProjectAnnotations
+};