dsh-data-domain-knowledge 0.1.0-alpha.9 → 0.1.1-alpha.2

package/src/settings-schema.ts

@@ -24,7 +24,7 @@
  * **注册命名空间**那一步就抛异常（`register` 先 `resolve` 再登记）：
  *
  * - 命名空间从未注册 → 面板上整个知识库设置显示「设置服务不可用」；
- * - `swap()` 永远不被调用 → `migrateLegacyResources` 从不执行（家当一直留在旧位置）；
+ * - `swap()` 永远不被调用 → 资源路径不会被运行时自动改写；
  * - `settings.yaml` 里存的值一个都不生效。
  *
  * 而且是**全量**失效，不是只有这三个字段 —— 所以这三个字段只约束「是字符串」，
@@ -42,15 +42,18 @@ import { DIAGNOSIS_ENTITY_TYPES } from './diagnosis/schema.js'
 /** 设置命名空间。命名规则是 `^[a-z][a-z0-9-]*$`（dsh-settings 的 `parseSettingsNamespace`）。 */
 export const SETTINGS_NAMESPACE = 'tita-data-agent-knowledge'
 
-export const KNOWLEDGE_SETTINGS_SCHEMA = z.object(volatileFields({
+export const KNOWLEDGE_SETTINGS_SCHEMA = z.object({
   /**
-   * **用户唯一要设的路径**（0029）。四段布局由它推出来，见 `layout.ts`。
+   * **固定的 Agent 根路径**。它不标记为 volatile，因此不会出现在设置弹层里；旧配置
+   * 仍保留在 schema 中，供旧配置平滑解析；运行时只使用新的默认根路径。
    */
   agentRoot: z.string().min(1).default(defaultAgentRoot()),
+  /** 固定多路径融合。保留旧路线值以平滑读取旧配置，但不标成可编辑设置。 */
+  recallMode: z.union(['fts', 'vector', 'hybrid'] as const).default(DEFAULT_KNOWLEDGE_CONFIG.recallMode),
+  ...volatileFields({
   /**
-   * @deprecated 0029：旧布局的知识树根。**只作为一次性迁移的来源**保留 ——
-   * 它不再出现在设置面板里，也不再决定任何路径。留一个宽松的字符串默认值，
-   * 是为了让老用户的 settings JSON 还能被解析出来，从而知道旧树在哪。
+   * @deprecated 0029：旧布局的知识树根。仅保留字段形状以兼容旧配置；
+   * 新逻辑忽略它，也不会读取或迁移旧树。
    */
   rootDir: z.string().default(''),
   schemaTypes: z.array(z.union(['concept', 'metric', 'table', 'event', 'playbook', 'case', ...DIAGNOSIS_ENTITY_TYPES] as const)).default(DEFAULT_KNOWLEDGE_CONFIG.schemaTypes),
@@ -76,7 +79,6 @@ export const KNOWLEDGE_SETTINGS_SCHEMA = z.object(volatileFields({
   // 0031：候选池与最终条数彻底分开。上限 200 是因为再深也只是把噪声往后排，
   // 而重排的代价随候选数线性增长。
   recallCandidatePool: z.number().step(1).min(1).max(200).default(DEFAULT_KNOWLEDGE_CONFIG.recallCandidatePool),
-  recallMode: z.union(['fts', 'vector', 'hybrid'] as const).default(DEFAULT_KNOWLEDGE_CONFIG.recallMode),
   // 阈值区间都开满：初值取 WeKnora 的出厂值，但校准要能自由调。
   // 关键词是归一化 BM25（0..1，相对），向量是原始余弦（−1..1，绝对）。
   keywordThreshold: z.number().min(0).max(1).default(DEFAULT_KNOWLEDGE_CONFIG.keywordThreshold),
@@ -91,4 +93,5 @@ export const KNOWLEDGE_SETTINGS_SCHEMA = z.object(volatileFields({
   rerankProvider: z.union(['bert-python', 'none'] as const).default(DEFAULT_KNOWLEDGE_CONFIG.rerankProvider),
   rerankModel: z.string().default(DEFAULT_KNOWLEDGE_CONFIG.rerankModel),
   rerankTimeoutMs: z.number().step(1).min(1000).max(600000).default(DEFAULT_KNOWLEDGE_CONFIG.rerankTimeoutMs),
-}))
+  }),
+})

package/src/settings-volatile.ts

@@ -24,14 +24,14 @@
  * if (form === void 0) return [];        // ← 一个字段都投影不出来，整条 entry 不会进 describe()
  * ```
  *
- * 我们的字段全是普通的 `.default(...)`，既不是 object 也不是 volatile，于是全部落到
+ * 可编辑业务字段如果只用普通的 `.default(...)`，既不是 object 也不是 volatile，就会落到
  * 出口 ③，整条 entry 被丢掉，客户端就只剩下 `unavailable`。核心插件的写法都带
  * `.volatile()`（`z.string().volatile()`、`z.number().default(10).volatile()`），
  * 这就是那条约定。
  *
  * ## 为什么这里统一标，而不是逐个手写
  *
- * 三个设置 schema 一共 40 多个字段；逐个加 `.volatile()` 既啰嗦，又会漏 —— 而**漏一个
+ * 可编辑设置字段有 40 多个；逐个加 `.volatile()` 既啰嗦，又会漏 —— 而**漏一个
  * 字段的后果是那个设置项在界面上直接消失**，属于沉默的失败。统一包一层让「新增字段
  * 默认可见」成为默认行为，想让它不可见才需要显式说明。
  *
@@ -66,7 +66,7 @@ export function volatileFields<T extends Record<string, Schemastery>>(fields: T)
 /**
  * volatile 字段解包。
  *
- * 0.1.7 的设置字段**全部标了 `.volatile()`**（理由见 `settings-volatile.ts`），而
+ * 0.1.7 起可编辑的业务设置字段标为 `.volatile()`；固定配置字段不标。
  * schemastery 对 volatile 字段解析出来的**不是值，是一个引用** —— `{ get(), set() }`。
  * 核心插件也是这么用的：`dsh-agent-default-model` 读的是 `this.config.provider.get()`。
  *
@@ -90,7 +90,7 @@ export function unwrapVolatile<T>(value: unknown): T | undefined {
  * ## 为什么需要两层
  *
  * entry config 的形状是固定的 `{ 组名: { 字段: 引用 } }`（见 `config-schema.ts` 的
- * `knowledge` / `intent` / `convert` 三组），而只解一层的结果是「组本身还是原始对象、
+ * `knowledge` / `convert` / `behaviorRules` 三组），而只解一层的结果是「组本身还是原始对象、
  * 组里的字段还是引用」。
  *
  * 0029 实测到的故障就是这样来的：`intent` 组被原样交给 `applyIntent`，于是

package/src/source-evidence.ts

@@ -0,0 +1,37 @@
+import type { Knowledge, KnowledgeSource } from './knowledge.js'
+import type { KnowledgeDb } from './store/knowledge-db.js'
+
+/** Checking an evidence anchor does not establish whether a claim is true. */
+/**
+ * `bodies` 是可选的**来源正文预读**（documentId → 当前版本与正文）。批量路径（物化快照）
+ * 一次读完全部来源再传进来，于是每条知识不再各自 join 一次 blob、各做一次整份文档的
+ * flatten 与子串匹配 —— 那是 O(知识条数 × 文档大小)。不传时退回按需读取（单条判定）。
+ */
+export function assessKnowledgeEvidence(knowledge: Knowledge, db: KnowledgeDb, bodies?: ReadonlyMap<string, { version: number; content: string }>): Knowledge {
+  return {
+    ...knowledge,
+    sources: knowledge.sources.map(source => assessSource(source, db, bodies)),
+  }
+}
+
+function assessSource(source: KnowledgeSource, db: KnowledgeDb, bodies?: ReadonlyMap<string, { version: number; content: string }>): KnowledgeSource {
+  if (source.withdrawn) return { ...source, evidenceStatus: 'historical', quoteInCurrentVersion: false }
+  if (!source.documentId) return { ...source, evidenceStatus: 'human' }
+  const head = bodies?.get(source.documentId) ?? db.source(source.documentId)
+  if (!head) return { ...source, evidenceStatus: 'missing', quoteInCurrentVersion: false }
+  const content = 'record' in head ? head.record.content : head.content
+  const flatten = (text: string): string => text.replace(/\s+/g, '')
+  const quote = flatten(source.quote)
+  return {
+    ...source,
+    currentVersion: head.version,
+    evidenceStatus: source.toVersion === undefined ? 'unversioned'
+      : source.toVersion === head.version ? 'current' : 'historical',
+    quoteInCurrentVersion: quote !== '' && flatten(content).includes(quote),
+  }
+}
+
+export function hasCurrentSupport(knowledge: Knowledge): boolean {
+  return knowledge.sources.some(source => source.evidenceStatus === 'human'
+    || (source.evidenceStatus === 'current' && source.quoteInCurrentVersion === true))
+}

package/src/store/axis-references.ts

@@ -0,0 +1,96 @@
+import { createHash } from 'node:crypto'
+import type { AxisKind } from '../axis-registry.js'
+import { compositeEventIdentity, eventEntityFromRecords, stripEventReferenceSection, type EventEntity } from '../events.js'
+import { cardCoordinateKey, type CardCoordinate } from '../types.js'
+import type { KnowledgeDb, CardKnowledgeRow } from './knowledge-db.js'
+
+/** Runs inside the axis merge transaction on the same validated connection. */
+export function redirectAxisReferences(db: KnowledgeDb, kind: AxisKind, fromId: string, intoId: string): void {
+  const column = { object: 'object_id', action: 'action_id', scene: 'scene_id' }[kind]
+  const field = { object: 'objectId', action: 'actionId', scene: 'sceneId' }[kind] as keyof CardCoordinate
+  const redirect = (coordinate: CardCoordinate): CardCoordinate => ({
+    ...coordinate, [field]: coordinate[field] === fromId ? intoId : coordinate[field],
+  })
+  const hasKnowledge = db.raw("SELECT 1 FROM sqlite_master WHERE name = 'knowledge'").get()
+  if (hasKnowledge) db.raw(`UPDATE knowledge SET ${column} = ?, updated_at = ? WHERE ${column} = ?`).run(intoId, new Date().toISOString(), fromId)
+  const placements = db.placements()
+  const cards = db.cards()
+  const byCoordinate = new Map(cards.filter(row => row.card.coordinate).map(row => [cardCoordinateKey(row.card.coordinate!), row]))
+  db.transact({ opId: `axis-merge:${fromId}:${intoId}:${Date.now()}`, actor: 'user', summary: '合并轴实体并迁移知识、卡片与事件引用' }, tx => {
+    for (const row of cards) {
+      const coordinate = row.card.coordinate
+      if (!coordinate || coordinate[field] !== fromId) continue
+      const next = redirect(coordinate)
+      const key = cardCoordinateKey(next)
+      const target = byCoordinate.get(key)
+      const base = target && target.card.entityId !== row.card.entityId ? target : row
+      const merged = base !== row
+      const eventRefs = [...new Set([...db.cardEventIds(base.card.entityId), ...db.cardEventIds(row.card.entityId)])]
+      const card = {
+        ...base.card, coordinate: next,
+        content: stripEventReferenceSection(merged ? `${base.card.content}\n\n${row.card.content}` : row.card.content),
+        sourceRefs: [...new Set([...base.card.sourceRefs, ...row.card.sourceRefs])],
+        annotations: [...new Map([...(base.card.annotations ?? []), ...(row.card.annotations ?? [])].map(annotation => [annotation.id, annotation])).values()],
+        metadata: { ...base.card.metadata, layout: undefined, citations: undefined,
+          aliases: [...new Set([...(Array.isArray(base.card.metadata.aliases) ? base.card.metadata.aliases : []), ...(Array.isArray(row.card.metadata.aliases) ? row.card.metadata.aliases : []), base.card.title, row.card.title])],
+          ...(eventRefs.length ? { event_refs: JSON.stringify(eventRefs) } : {}) },
+      }
+      const rows = [...(placements.get(base.card.entityId) ?? []), ...(merged ? placements.get(row.card.entityId) ?? [] : [])]
+      const combined: CardKnowledgeRow[] = [...new Map(rows.map(placement => [placement.knowledgeId, placement])).values()]
+      if (merged) tx.removeEntity('card', row.card.entityId)
+      const frontmatter = { ...base.frontmatter, coordinate: { object: next.objectId, action: next.actionId, scene: next.sceneId }, source_refs: card.sourceRefs, metadata: card.metadata, annotations: card.annotations }
+      tx.putCard(card, frontmatter, { actor: 'user', kind: 'named', summary: '轴合并后的卡片引用' }, combined, true)
+      db.setCardEvents(card.entityId, eventRefs)
+      byCoordinate.delete(cardCoordinateKey(coordinate))
+      byCoordinate.set(key, { ...base, card, frontmatter })
+      placements.set(card.entityId, combined)
+    }
+    const changed = new Set<string>()
+    const events = db.events().map(event => {
+      if (event.coordinateIds[field] !== fromId && !event.records.some(record => record.coordinateIds[field] === fromId)) return event
+      changed.add(event.id)
+      return { ...event, coordinateIds: redirect(event.coordinateIds), records: event.records.map(record => ({ ...record, coordinateIds: redirect(record.coordinateIds) })), updatedAt: new Date().toISOString() }
+    })
+    const externalBases = new Map(events.filter(event => event.identityType === 'external_id' && !event.identityKey.includes(':coordinate:')).map(event => [event.identityKey, event]))
+    const groups = new Map<string, EventEntity[]>()
+    for (const event of events) {
+      let key = event.identityKey
+      if (changed.has(event.id) && event.identityType === 'composite') key = compositeEventIdentity(event.occurredAt, event.coordinateIds, event.symptom)
+      if (event.identityType === 'external_id' && key.includes(':coordinate:')) {
+        const baseKey = key.slice(0, key.indexOf(':coordinate:'))
+        const base = externalBases.get(baseKey)
+        if (base && cardCoordinateKey(base.coordinateIds) === cardCoordinateKey(event.coordinateIds)) key = baseKey
+        else if (changed.has(event.id)) key = baseKey + ':coordinate:' + createHash('sha256').update(JSON.stringify(event.coordinateIds)).digest('hex').slice(0, 24)
+      }
+      const group = groups.get(key) ?? []
+      group.push(event)
+      groups.set(key, group)
+    }
+    const redirects = new Map<string, string>()
+    const affectedCards = new Set<string>()
+    for (const [key, group] of groups) {
+      if (group.length === 1 && !changed.has(group[0]!.id) && key === group[0]!.identityKey) continue
+      const target = group.find(event => event.identityKey === key) ?? group[0]!
+      const records = [...new Map(group.flatMap(event => event.records).map(record => [`${record.sourceId}\u0001${record.localId}`, record])).values()]
+      for (const event of group) {
+        if (event.id === target.id) continue
+        redirects.set(event.id, target.id)
+        for (const row of db.raw('SELECT card_id FROM card_event WHERE event_id = ?').all(event.id) as Array<{ card_id: string }>) affectedCards.add(row.card_id)
+        db.raw(`INSERT OR IGNORE INTO card_event(card_id, event_id, ordinal)
+          SELECT card_id, ?, ordinal FROM card_event WHERE event_id = ?`).run(target.id, event.id)
+        db.removeEvent(event.id)
+      }
+      db.writeEvent(group.length === 1 ? { ...target, identityKey: key } : eventEntityFromRecords({ ...target, identityKey: key, records }))
+    }
+    if (redirects.size) {
+      for (const row of db.cards()) {
+        let content = stripEventReferenceSection(row.card.content)
+        for (const [from, into] of redirects) content = content.replaceAll(from, into)
+        if (content === row.card.content && !affectedCards.has(row.card.entityId)) continue
+        const metadata = { ...row.card.metadata, event_refs: JSON.stringify(db.cardEventIds(row.card.entityId)) }
+        const frontmatter = { ...row.frontmatter, metadata }
+        tx.putCard({ ...row.card, content, metadata }, frontmatter, { actor: 'user', kind: 'named', summary: '轴合并后的 Event 引用' })
+      }
+    }
+  })
+}

package/src/store/derived.ts

@@ -76,6 +76,12 @@ export interface FtsDocument {
   content: string
 }
 
+export interface DerivedPublication {
+  artifacts: Map<string, string>
+  fts?: FtsDocument[]
+  vectors?: { manifest: unknown; binary: Buffer; int8: Buffer } | null
+}
+
 export type DerivedOpenResult =
   | { ok: true; db: DerivedDb; /** 这次开库是否把旧结构整体重建了。 */ rebuilt: boolean }
   | { ok: false; code: 'NOT_A_DERIVED_DB' | 'OPEN_FAILED'; message: string }
@@ -150,19 +156,37 @@ export class DerivedDb {
       return { ok: false, code: 'OPEN_FAILED', message: `打开失败：${cause instanceof Error ? cause.message : String(cause)}` }
     }
     try {
-      db.exec('PRAGMA journal_mode = WAL')
       const owner = readPragma(db, 'application_id')
       const version = readPragma(db, 'user_version')
-      if (userTableCount(db) === 0) {
+      /**
+       * 属主标记为 0 = 这份文件从来没有被我们的初始化**写完过**。两种来源都要按「无主」处理：
+       *
+       * 1. 全新/空的文件（一张表都没有）；
+       * 2. `schemaSql()` 已经建好表、`PRAGMA application_id` 还没写就被杀掉的那一次
+       *    （崩溃、kill、磁盘满）。第二种原来会落到下面的「属主不对」分支，返回
+       *    `NOT_A_DERIVED_DB` —— 而 `derivedHandle()` 会把这个结论缓存住，于是编译与召回
+       *    **永久**失败，尽管这个文件按定义是可重建的。
+       *
+       * 但不能因此误伤别人的库：只有「文件里所有表都是我们自己建的」才认领重建，
+       * 出现陌生表就仍然拒绝打开（认错库比打不开糟）。
+       */
+      const tables = userTables(db)
+      const foreign = tables.filter(name => !['artifact', 'vector_index', 'fts'].includes(name))
+      if (owner === 0 && foreign.length === 0) {
+        db.exec('DROP TABLE IF EXISTS fts')
+        db.exec('DROP TABLE IF EXISTS artifact')
+        db.exec('DROP TABLE IF EXISTS vector_index')
+        db.exec('PRAGMA journal_mode = WAL')
         db.exec(schemaSql())
         db.exec(`PRAGMA application_id = ${DERIVED_DB_APPLICATION_ID}`)
         db.exec(`PRAGMA user_version = ${DERIVED_DB_SCHEMA}`)
-        return { ok: true, db: new DerivedDb(db, file), rebuilt: false }
+        return { ok: true, db: new DerivedDb(db, file), rebuilt: tables.length > 0 }
       }
       if (owner !== DERIVED_DB_APPLICATION_ID) {
         db.close()
         return { ok: false, code: 'NOT_A_DERIVED_DB', message: `这个文件不是知识库的派生库（属主标记 ${owner}）：${file}` }
       }
+      db.exec('PRAGMA journal_mode = WAL')
       if (version !== DERIVED_DB_SCHEMA) {
         // 整体重建。**没有迁移分支是刻意的**（见模块头）。
         db.exec('DROP TABLE IF EXISTS fts')
@@ -207,6 +231,24 @@ export class DerivedDb {
       .run(name, body, hashOf(body), Buffer.byteLength(body, 'utf8'), new Date().toISOString())
   }
 
+  /** Model calls finish before this short transaction starts. */
+  publish(publication: DerivedPublication): void {
+    this.db.exec('BEGIN IMMEDIATE')
+    try {
+      for (const [name, body] of publication.artifacts) this.putArtifact(name, body)
+      if (publication.fts !== undefined) this.rebuildFts(publication.fts)
+      if (publication.vectors === null) this.raw('DELETE FROM vector_index').run()
+      else if (publication.vectors !== undefined) {
+        const { manifest, binary, int8 } = publication.vectors
+        this.putVectorIndex(manifest, binary, int8)
+      }
+      this.db.exec('COMMIT')
+    } catch (cause) {
+      try { this.db.exec('ROLLBACK') } catch { /* preserve the original failure */ }
+      throw cause
+    }
+  }
+
   removeArtifact(name: string): void {
     this.raw('DELETE FROM artifact WHERE name = ?').run(name)
   }
@@ -239,14 +281,14 @@ export class DerivedDb {
    */
   rebuildFts(documents: FtsDocument[]): void {
     /*
-     * `BEGIN` 在 DDL **之前**：SQLite 的 DDL 是事务性的（实测 `CREATE VIRTUAL TABLE` 与它
+     * `SAVEPOINT` 在 DDL **之前**：SQLite 的 DDL 是事务性的（实测 `CREATE VIRTUAL TABLE` 与它
      * 的 shadow 表一起回滚），而放在事务外就变成自动提交 —— 于是构建中途失败会留下一张
      * **空的** `fts` 表，`hasFts()` 还说它在，查询却一条也回不来。
      *
      * 放进同一个事务之后的实际行为：**上一版索引原样留着**（还能查），或者（本来就还没有
      * 索引时）仍然没有索引。两种都比「空表」好 —— 空表是一种既不报错也不可用的状态。
      */
-    this.db.exec('BEGIN')
+    this.db.exec('SAVEPOINT rebuild_fts')
     try {
       this.db.exec('DROP TABLE IF EXISTS fts')
       this.db.exec(ftsSql())
@@ -256,9 +298,9 @@ export class DerivedDb {
         const tokens = [...segment(document.title), ...segment(document.title), ...segment(document.content)]
         insert.run(document.unitId, tokens.join(' '))
       }
-      this.db.exec('COMMIT')
+      this.db.exec('RELEASE rebuild_fts')
     } catch (cause) {
-      try { this.db.exec('ROLLBACK') } catch { /* rollback of a dead tx */ }
+      try { this.db.exec('ROLLBACK TO rebuild_fts; RELEASE rebuild_fts') } catch { /* rollback of a dead tx */ }
       throw cause
     }
     // `optimize` 在事务外：它是一次纯内部整理，失败不该把已经建好的索引回滚掉。
@@ -277,11 +319,19 @@ export class DerivedDb {
    * 查询语法错误或索引损坏时**返回空数组而不抛**：关键词路是三条召回路线之一，
    * 它挂了不该把整次召回带走 —— 调用方在诊断里如实说明这一路没结果。
    */
-  searchFts(query: string, limit: number): FtsHit[] {
+  searchFts(query: string, limit: number, eligible?: ReadonlySet<string>): FtsHit[] {
     const expression = matchExpression(query)
     if (expression === null || !this.hasFts()) return []
     try {
-      const rows = this.raw('SELECT unit_id, bm25(fts) AS rank FROM fts WHERE fts MATCH ? ORDER BY rank LIMIT ?').all(expression, limit) as Array<{ unit_id?: unknown; rank?: unknown }>
+      /*
+       * `eligible` 必须进 SQL。先 LIMIT 再在 JS 里过滤，会让已删除/停用卡片的死
+       * unitId 占满候选窗口（索引只在编译时重建，删除不会立刻反映到 fts 表）。
+       * 用 `json_each` 传一个 JSON 数组而不是拼参数列表：一个绑定参数，不受
+       * SQLITE_MAX_VARIABLE_NUMBER 限制。
+       */
+      const rows = (eligible === undefined
+        ? this.raw('SELECT unit_id, bm25(fts) AS rank FROM fts WHERE fts MATCH ? ORDER BY rank LIMIT ?').all(expression, limit)
+        : this.raw('SELECT unit_id, bm25(fts) AS rank FROM fts WHERE fts MATCH ? AND unit_id IN (SELECT value FROM json_each(?)) ORDER BY rank LIMIT ?').all(expression, JSON.stringify([...eligible]), limit)) as Array<{ unit_id?: unknown; rank?: unknown }>
       const parsed = rows
         .map(row => ({ unitId: String(row.unit_id ?? ''), raw: Number(row.rank ?? 0) }))
         .filter(row => row.unitId !== '' && Number.isFinite(row.raw))
@@ -291,6 +341,14 @@ export class DerivedDb {
       const scale = best > 0 ? best : 1
       return parsed.map(row => ({ ...row, score: Math.max(0, Math.min(1, -row.raw / scale)) }))
     } catch {
+      /**
+       * `json_each` 不可用（SQLite 没编 JSON）或索引损坏时，**不能直接返回空**。
+       *
+       * 空数组会被上游读成「这一路没命中」，而实际是「这一路坏了」—— 正是这次要消灭的
+       * 那种静默降级。退回不带资格过滤的两参数查询：结果仍然正确（调用方还会过滤一遍），
+       * 只是候选窗口可能被已删除的条目占掉。真的连那条也失败，才认「没有结果」。
+       */
+      if (eligible !== undefined) return this.searchFts(query, limit)
       return []
     }
   }
@@ -310,7 +368,7 @@ function readPragma(db: SqliteDatabase, name: string): number {
   return typeof first === 'number' ? first : Number(first ?? 0)
 }
 
-function userTableCount(db: SqliteDatabase): number {
-  const rows = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").all() as Array<{ name?: unknown }>
-  return rows.length
+/** 文件里现有的表名。用来判断「这份文件是不是我们建的」。 */
+function userTables(db: SqliteDatabase): string[] {
+  return (db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").all() as Array<{ name?: unknown }>).map(row => String(row.name ?? ''))
 }