@fortemi/core 2026.5.2 → 2026.5.4

package/dist/index.js

@@ -667,13 +667,134 @@ var migration0005 = {
   `
 };
 
+// src/migrations/0006_embedding_set_metadata.ts
+var migration0006 = {
+  version: 6,
+  name: "0006_embedding_set_metadata",
+  sql: `
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS name TEXT NOT NULL DEFAULT 'Full content';
+
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS purpose TEXT;
+  `
+};
+
+// src/migrations/0007_virtual_embedding_sets.ts
+var migration0007 = {
+  version: 7,
+  name: "0007_virtual_embedding_sets",
+  sql: `
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS kind TEXT NOT NULL DEFAULT 'physical';
+
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS mode TEXT;
+
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS truncate_dimension INTEGER;
+
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS criteria_json JSONB;
+
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS source_json JSONB;
+
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS compatibility_json JSONB;
+
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS materialization_json JSONB;
+
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS freshness_json JSONB;
+
+    ALTER TABLE embedding_set
+      ADD COLUMN IF NOT EXISTS updated_at TIMESTAMPTZ NOT NULL DEFAULT now();
+  `
+};
+
+// src/migrations/0008_graph_community_artifacts.ts
+var migration0008 = {
+  version: 8,
+  name: "0008_graph_community_artifacts",
+  sql: `
+    CREATE TABLE IF NOT EXISTS graph_source (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      source_table TEXT,
+      embedding_set_id TEXT,
+      virtual_set_id TEXT,
+      model TEXT,
+      dimension INTEGER,
+      truncate_dimension INTEGER,
+      metric TEXT,
+      algorithm TEXT,
+      parameters_json JSONB,
+      input_hash TEXT NOT NULL,
+      freshness_json JSONB NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+    );
+
+    CREATE TABLE IF NOT EXISTS graph_edge_artifact (
+      graph_source_id TEXT NOT NULL REFERENCES graph_source(id) ON DELETE CASCADE,
+      from_note_id TEXT NOT NULL REFERENCES note(id),
+      to_note_id TEXT NOT NULL REFERENCES note(id),
+      weight DOUBLE PRECISION NOT NULL,
+      kind TEXT NOT NULL,
+      rank INTEGER,
+      metadata_json JSONB,
+      PRIMARY KEY (graph_source_id, from_note_id, to_note_id, kind)
+    );
+
+    CREATE TABLE IF NOT EXISTS community_set (
+      id TEXT PRIMARY KEY,
+      graph_source_id TEXT NOT NULL REFERENCES graph_source(id) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      source_type TEXT NOT NULL,
+      algorithm TEXT,
+      parameters_json JSONB,
+      input_hash TEXT NOT NULL,
+      freshness_json JSONB NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+    );
+
+    CREATE TABLE IF NOT EXISTS community (
+      id TEXT NOT NULL,
+      community_set_id TEXT NOT NULL REFERENCES community_set(id) ON DELETE CASCADE,
+      label TEXT,
+      rank INTEGER,
+      size INTEGER,
+      confidence DOUBLE PRECISION,
+      representative_note_ids TEXT[],
+      metadata_json JSONB,
+      PRIMARY KEY (community_set_id, id)
+    );
+
+    CREATE TABLE IF NOT EXISTS community_assignment (
+      community_set_id TEXT NOT NULL REFERENCES community_set(id) ON DELETE CASCADE,
+      community_id TEXT NOT NULL,
+      note_id TEXT NOT NULL REFERENCES note(id),
+      confidence DOUBLE PRECISION,
+      source_type TEXT NOT NULL,
+      metadata_json JSONB,
+      PRIMARY KEY (community_set_id, note_id),
+      FOREIGN KEY (community_set_id, community_id) REFERENCES community(community_set_id, id) ON DELETE CASCADE
+    );
+  `
+};
+
 // src/migrations/index.ts
 var allMigrations = [
   migration0001,
   migration0002,
   migration0003,
   migration0004,
-  migration0005
+  migration0005,
+  migration0006,
+  migration0007,
+  migration0008
 ];
 
 // src/archive-manager.ts
@@ -1547,26 +1668,410 @@ function buildNoteConditions(options, startIdx, includeDeleted = false) {
   return { conditions, params, nextIdx: idx };
 }
 
+// src/repositories/embedding-sets-repository.ts
+var DEFAULT_COMPATIBILITY = {
+  model: "require-same",
+  dimension: "require-same",
+  duplicateVectors: "prefer-set-order",
+  missingVectors: "omit"
+};
+function jsonParam(value) {
+  return value == null ? null : JSON.stringify(value);
+}
+function asObject(value) {
+  if (value == null) return null;
+  if (typeof value === "string") return JSON.parse(value);
+  return value;
+}
+function dateString(value) {
+  if (!value) return void 0;
+  return value instanceof Date ? value.toISOString() : value;
+}
+function dateMillis(value) {
+  return value instanceof Date ? value.getTime() : new Date(value).getTime();
+}
+var EmbeddingSetsRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async create(input) {
+    const id = input.id ?? generateId();
+    await this.db.query(
+      `INSERT INTO embedding_set (
+         id, name, purpose, model_name, dimensions, kind, mode,
+         truncate_dimension, criteria_json
+       ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::jsonb)`,
+      [
+        id,
+        input.name,
+        input.purpose ?? null,
+        input.model_name ?? "all-MiniLM-L6-v2",
+        input.dimensions ?? 384,
+        input.kind ?? "physical",
+        input.mode ?? null,
+        input.truncate_dimension ?? null,
+        jsonParam(input.criteria ?? null)
+      ]
+    );
+    return this.get(id);
+  }
+  async createVirtualDefinition(input) {
+    const id = input.id ?? generateId();
+    await this.db.query(
+      `INSERT INTO embedding_set (
+         id, name, purpose, model_name, dimensions, kind, mode,
+         source_json, compatibility_json, materialization_json, freshness_json, created_at, updated_at
+       ) VALUES ($1, $2, $3, $4, $5, 'virtual', 'auto', $6::jsonb, $7::jsonb, $8::jsonb, $9::jsonb,
+                 COALESCE($10::timestamptz, now()), COALESCE($11::timestamptz, now()))`,
+      [
+        id,
+        input.name,
+        input.purpose ?? null,
+        this.inferDefinitionModel(input) ?? "virtual",
+        this.inferDefinitionDimension(input) ?? 0,
+        jsonParam(input.source),
+        jsonParam(input.compatibility),
+        jsonParam(input.materialization ?? null),
+        jsonParam({ status: input.materialization?.freshness ?? "unknown" }),
+        input.createdAt ?? null,
+        input.updatedAt ?? null
+      ]
+    );
+    return this.get(id);
+  }
+  async ensureDefault() {
+    const existing = await this.db.query(
+      `SELECT * FROM embedding_set WHERE name = $1 AND model_name = $2 AND kind = 'physical' ORDER BY created_at LIMIT 1`,
+      ["Full content", "all-MiniLM-L6-v2"]
+    );
+    if (existing.rows.length > 0) return existing.rows[0];
+    return this.create({
+      name: "Full content",
+      purpose: "Semantic search over full revised note content",
+      model_name: "all-MiniLM-L6-v2",
+      dimensions: 384,
+      kind: "physical"
+    });
+  }
+  async get(id) {
+    const result = await this.db.query(
+      `SELECT * FROM embedding_set WHERE id = $1`,
+      [id]
+    );
+    if (result.rows.length === 0) throw new Error(`Embedding set not found: ${id}`);
+    return result.rows[0];
+  }
+  async list() {
+    const result = await this.db.query(
+      `SELECT * FROM embedding_set ORDER BY created_at, name`
+    );
+    return result.rows;
+  }
+  async listDescriptors() {
+    const rows = await this.list();
+    return rows.map((row) => this.toDescriptor(row));
+  }
+  toDescriptor(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      purpose: row.purpose,
+      kind: row.kind,
+      mode: row.mode ?? void 0,
+      model: row.model_name,
+      dimension: row.dimensions,
+      truncateDimension: row.truncate_dimension,
+      criteria: asObject(row.criteria_json),
+      createdAt: dateString(row.created_at),
+      updatedAt: dateString(row.updated_at),
+      freshness: asObject(row.freshness_json) ?? { status: "fresh" }
+    };
+  }
+  async putEmbedding(input) {
+    const set = await this.get(input.embedding_set_id);
+    if (set.kind === "virtual") {
+      throw new Error(`Cannot store vectors directly in virtual embedding set: ${set.id}`);
+    }
+    if (input.vector.length !== set.dimensions) {
+      throw new Error(
+        `Embedding vector has ${input.vector.length} dimensions; set ${set.id} expects ${set.dimensions}`
+      );
+    }
+    await this.db.query(
+      `DELETE FROM embedding_set_member WHERE note_id = $1 AND embedding_set_id = $2`,
+      [input.note_id, input.embedding_set_id]
+    );
+    await this.db.query(
+      `DELETE FROM embedding WHERE note_id = $1 AND embedding_set_id = $2`,
+      [input.note_id, input.embedding_set_id]
+    );
+    const embeddingId = input.id ?? generateId();
+    const vector2 = `[${input.vector.join(",")}]`;
+    await this.db.query(
+      `INSERT INTO embedding (id, note_id, embedding_set_id, vector)
+       VALUES ($1, $2, $3, $4::vector)`,
+      [embeddingId, input.note_id, input.embedding_set_id, vector2]
+    );
+    await this.db.query(
+      `INSERT INTO embedding_set_member (embedding_set_id, note_id, embedding_id)
+       VALUES ($1, $2, $3)`,
+      [input.embedding_set_id, input.note_id, embeddingId]
+    );
+    return { id: embeddingId };
+  }
+  async resolveSelector(selector) {
+    if (selector.kind === "default") {
+      const set = await this.ensureDefault();
+      return this.resolvePhysicalSet({ kind: "embedding-set", embeddingSetId: set.id }, set.id);
+    }
+    if (selector.kind === "embedding-set") {
+      if (!selector.embeddingSetId) throw new Error("embedding-set selector requires embeddingSetId");
+      const set = await this.get(selector.embeddingSetId);
+      if (set.kind === "virtual") {
+        const definition = this.definitionFromRow(set);
+        return this.resolveDefinition({ kind: "embedding-set", embeddingSetId: set.id }, definition);
+      }
+      return this.resolvePhysicalSet(selector, set.id);
+    }
+    if (!selector.definition) throw new Error("virtual-definition selector requires definition");
+    return this.resolveDefinition(selector, selector.definition);
+  }
+  async resolveDefinition(selector, definition) {
+    let rows;
+    const errors = [];
+    switch (definition.source.type) {
+      case "criteria":
+        rows = await this.resolveCriteriaSource(definition.source);
+        break;
+      case "set-operation":
+        rows = await this.resolveSetOperationSource(definition.source, definition.compatibility, errors);
+        break;
+      case "fallback":
+        rows = await this.resolveFallbackSource(definition.source.preferredSetIds, definition.compatibility, errors);
+        break;
+      case "latest-compatible":
+        rows = await this.resolveLatestCompatibleSource(definition.source, definition.compatibility, errors);
+        break;
+      case "snapshot":
+        rows = await this.resolvePhysicalRows(definition.source.snapshotId);
+        break;
+      default:
+        rows = [];
+    }
+    return this.finalizeResolution(selector, rows, errors, definition.compatibility, definition.materialization?.freshness ?? "unknown");
+  }
+  async resolvePhysicalSet(selector, setId) {
+    return this.finalizeResolution(selector, await this.resolvePhysicalRows(setId), [], DEFAULT_COMPATIBILITY, "fresh");
+  }
+  async resolvePhysicalRows(setId) {
+    const result = await this.db.query(
+      `SELECT note_id, embedding_set_id, id as embedding_id, vector::text as vector, created_at
+       FROM embedding
+       WHERE embedding_set_id = $1
+       ORDER BY note_id, created_at DESC`,
+      [setId]
+    );
+    return result.rows;
+  }
+  async resolveCriteriaSource(source) {
+    const criteria = source.criteria;
+    if (criteria.conceptIds && criteria.conceptIds.length > 0) {
+      throw new Error("Unsupported virtual embedding-set criteria field: conceptIds");
+    }
+    const conditions = ["e.embedding_set_id = $1"];
+    const params = [source.baseSetId];
+    let idx = 2;
+    if (criteria.noteIds?.length) {
+      conditions.push(`n.id = ANY($${idx++})`);
+      params.push(criteria.noteIds);
+    }
+    if (criteria.tags?.length) {
+      conditions.push(`EXISTS (SELECT 1 FROM note_tag nt WHERE nt.note_id = n.id AND nt.tag = ANY($${idx++}))`);
+      params.push(criteria.tags);
+    }
+    if (criteria.collectionIds?.length) {
+      conditions.push(`EXISTS (SELECT 1 FROM collection_note cn WHERE cn.note_id = n.id AND cn.collection_id = ANY($${idx++}))`);
+      params.push(criteria.collectionIds);
+    }
+    if (criteria.updatedAfter) {
+      conditions.push(`n.updated_at >= $${idx++}`);
+      params.push(criteria.updatedAfter);
+    }
+    if (criteria.updatedBefore) {
+      conditions.push(`n.updated_at <= $${idx++}`);
+      params.push(criteria.updatedBefore);
+    }
+    if (criteria.query?.trim()) {
+      conditions.push(`(n.tsv @@ plainto_tsquery('english', $${idx}) OR to_tsvector('english', coalesce(c.content, '')) @@ plainto_tsquery('english', $${idx}))`);
+      params.push(criteria.query);
+    }
+    const result = await this.db.query(
+      `SELECT e.note_id, e.embedding_set_id, e.id as embedding_id, e.vector::text as vector, e.created_at
+       FROM embedding e
+       JOIN note n ON n.id = e.note_id
+       LEFT JOIN note_revised_current c ON c.note_id = n.id
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY e.note_id, e.created_at DESC`,
+      params
+    );
+    return result.rows;
+  }
+  async resolveSetOperationSource(source, compatibility, errors) {
+    const bySet = /* @__PURE__ */ new Map();
+    for (const setId of source.setIds) bySet.set(setId, await this.resolvePhysicalRows(setId));
+    await this.validateCompatibility(source.setIds, compatibility, errors);
+    const noteSets = source.setIds.map((setId) => new Set((bySet.get(setId) ?? []).map((row) => row.note_id)));
+    const firstRows = bySet.get(source.setIds[0]) ?? [];
+    if (source.operation === "difference") {
+      const excluded = new Set(noteSets.slice(1).flatMap((set) => Array.from(set)));
+      return firstRows.filter((row) => !excluded.has(row.note_id));
+    }
+    if (source.operation === "intersection") {
+      return firstRows.filter((row) => noteSets.every((set) => set.has(row.note_id)));
+    }
+    return this.resolveDuplicateRows(source.setIds.flatMap((setId) => bySet.get(setId) ?? []), compatibility, errors);
+  }
+  async resolveFallbackSource(setIds, compatibility, errors) {
+    await this.validateCompatibility(setIds, compatibility, errors);
+    const selected = /* @__PURE__ */ new Map();
+    for (const setId of setIds) {
+      for (const row of await this.resolvePhysicalRows(setId)) {
+        if (!selected.has(row.note_id)) selected.set(row.note_id, row);
+      }
+    }
+    return Array.from(selected.values()).sort((a, b) => a.note_id.localeCompare(b.note_id));
+  }
+  async resolveLatestCompatibleSource(source, compatibility, errors) {
+    const sets = [];
+    for (const setId of source.candidateSetIds) {
+      const set = await this.get(setId);
+      if (source.model && set.model_name !== source.model) continue;
+      if (source.dimension && set.dimensions !== source.dimension) continue;
+      sets.push(set);
+    }
+    sets.sort((a, b) => dateMillis(b.updated_at) - dateMillis(a.updated_at) || dateMillis(b.created_at) - dateMillis(a.created_at));
+    return this.resolveFallbackSource(sets.map((set) => set.id), compatibility, errors);
+  }
+  async validateCompatibility(setIds, compatibility, errors) {
+    const sets = [];
+    for (const setId of setIds) sets.push(await this.get(setId));
+    if (compatibility.model === "require-same" && new Set(sets.map((set) => set.model_name)).size > 1) {
+      errors.push({ code: "mixed-models", setIds });
+    }
+    if (compatibility.dimension === "require-same" && new Set(sets.map((set) => set.dimensions)).size > 1) {
+      errors.push({ code: "mixed-dimensions", setIds });
+    }
+  }
+  resolveDuplicateRows(rows, compatibility, errors) {
+    const byNote = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const existing = byNote.get(row.note_id) ?? [];
+      existing.push(row);
+      byNote.set(row.note_id, existing);
+    }
+    const resolved = [];
+    for (const [noteId, noteRows] of byNote) {
+      if (noteRows.length > 1 && compatibility.duplicateVectors === "error") {
+        errors.push({ code: "duplicate-vector", noteId, setIds: noteRows.map((row) => row.embedding_set_id) });
+        continue;
+      }
+      const ordered = [...noteRows];
+      if (compatibility.duplicateVectors === "prefer-latest") {
+        ordered.sort((a, b) => dateMillis(b.created_at) - dateMillis(a.created_at));
+      }
+      resolved.push(ordered[0]);
+    }
+    return resolved.sort((a, b) => a.note_id.localeCompare(b.note_id));
+  }
+  finalizeResolution(selector, rows, errors, compatibility, freshness) {
+    const deduped = this.resolveDuplicateRows(rows, compatibility, errors);
+    return {
+      selector,
+      rows: deduped,
+      noteIds: deduped.map((row) => row.note_id),
+      embeddingIds: deduped.map((row) => row.embedding_id),
+      errors,
+      freshness: { status: freshness }
+    };
+  }
+  definitionFromRow(row) {
+    const source = asObject(row.source_json);
+    if (!source) throw new Error(`Virtual embedding set has no source definition: ${row.id}`);
+    return {
+      id: row.id,
+      name: row.name,
+      purpose: row.purpose,
+      source,
+      compatibility: asObject(row.compatibility_json) ?? DEFAULT_COMPATIBILITY,
+      materialization: asObject(row.materialization_json) ?? void 0,
+      createdAt: dateString(row.created_at),
+      updatedAt: dateString(row.updated_at)
+    };
+  }
+  inferDefinitionModel(input) {
+    if (input.source.type === "latest-compatible") return input.source.model ?? null;
+    return null;
+  }
+  inferDefinitionDimension(input) {
+    if (input.source.type === "latest-compatible") return input.source.dimension ?? null;
+    return null;
+  }
+};
+
 // src/repositories/search-repository.ts
 var SearchRepository = class {
   constructor(db, semanticAvailable = false) {
     this.db = db;
     this.semanticAvailable = semanticAvailable;
   }
-  /** Select tsquery function based on whether query contains quoted phrases */
   tsqueryFn(query) {
     return query.includes('"') ? "phraseto_tsquery" : "plainto_tsquery";
   }
-  /** Returns a Set of note IDs that have an embedding record */
-  async fetchEmbeddingSet(noteIds) {
+  async fetchEmbeddingSet(noteIds, embeddingSetId) {
     if (noteIds.length === 0) return /* @__PURE__ */ new Set();
+    const params = [noteIds];
+    const setFilter = embeddingSetId ? " AND embedding_set_id = $2" : "";
+    if (embeddingSetId) params.push(embeddingSetId);
     const result = await this.db.query(
-      `SELECT note_id FROM embedding WHERE note_id = ANY($1)`,
-      [noteIds]
+      "SELECT note_id FROM embedding WHERE note_id = ANY($1)" + setFilter,
+      params
     );
     return new Set(result.rows.map((r) => r.note_id));
   }
-  /** Attach has_embedding to each SearchResult using the provided embedding set */
+  selectorFromOptions(options) {
+    if (options.embeddingSetSelector) return options.embeddingSetSelector;
+    if (options.embeddingSetId) return { kind: "embedding-set", embeddingSetId: options.embeddingSetId };
+    return null;
+  }
+  async resolveEmbeddingSet(options) {
+    const selector = this.selectorFromOptions(options);
+    if (!selector) return null;
+    return new EmbeddingSetsRepository(this.db).resolveSelector(selector);
+  }
+  scopeToResolvedEmbeddingSet(conditions, params, paramIdx, resolved) {
+    if (!resolved) return paramIdx;
+    if (resolved.noteIds.length === 0) {
+      conditions.push("FALSE");
+      return paramIdx;
+    }
+    conditions.push("n.id = ANY($" + paramIdx + ")");
+    params.push(resolved.noteIds);
+    return paramIdx + 1;
+  }
+  scopeToResolvedEmbeddingRows(conditions, params, paramIdx, resolved) {
+    if (!resolved) return paramIdx;
+    if (resolved.embeddingIds.length === 0) {
+      conditions.push("FALSE");
+      return paramIdx;
+    }
+    conditions.push("e.id = ANY($" + paramIdx + ")");
+    params.push(resolved.embeddingIds);
+    return paramIdx + 1;
+  }
+  async fetchEmbeddingStatus(noteIds, resolved, embeddingSetId) {
+    if (resolved) return new Set(noteIds.filter((id) => resolved.noteIds.includes(id)));
+    return this.fetchEmbeddingSet(noteIds, embeddingSetId);
+  }
   attachEmbeddingStatus(results, embeddingSet) {
     return results.map((r) => ({ ...r, has_embedding: embeddingSet.has(r.id) }));
   }
@@ -1574,9 +2079,7 @@ var SearchRepository = class {
     const { limit = 20, offset = 0 } = options;
     const mode = options.mode ?? "auto";
     if (mode === "text") {
-      if (!query.trim()) {
-        return this.recentNotes(options);
-      }
+      if (!query.trim()) return this.recentNotes(options);
     } else if (mode === "semantic") {
       if (!queryEmbedding || queryEmbedding.length === 0) {
         throw new Error("mode=semantic requires a query embedding");
@@ -1589,26 +2092,21 @@ var SearchRepository = class {
       return this.hybridSearch(query, queryEmbedding, options);
     } else {
       if (queryEmbedding && queryEmbedding.length > 0) {
-        if (query.trim()) {
-          return this.hybridSearch(query, queryEmbedding, options);
-        }
+        if (query.trim()) return this.hybridSearch(query, queryEmbedding, options);
         return this.semanticSearch(queryEmbedding, options);
       }
-      if (!query.trim()) {
-        return this.recentNotes(options);
-      }
-    }
-    if (!query.trim()) {
-      return this.recentNotes(options);
+      if (!query.trim()) return this.recentNotes(options);
     }
+    if (!query.trim()) return this.recentNotes(options);
+    const resolvedEmbeddingSet = await this.resolveEmbeddingSet(options);
     const tsqFn = this.tsqueryFn(query);
     const { conditions, params, nextIdx } = buildNoteConditions(options, 2);
     conditions.unshift(
       `(n.tsv @@ ${tsqFn}('english', $1) OR
         to_tsvector('english', coalesce(c.content, '')) @@ ${tsqFn}('english', $1))`
     );
+    let paramIdx = this.scopeToResolvedEmbeddingSet(conditions, params, nextIdx, resolvedEmbeddingSet);
     const allParams = [query, ...params];
-    let paramIdx = nextIdx;
     const where = conditions.join(" AND ");
     const countResult = await this.db.query(
       `SELECT COUNT(*) as count
@@ -1641,7 +2139,7 @@ var SearchRepository = class {
     const resultIds = result.rows.map((r) => r.id);
     const [tagMap, embeddingSet] = await Promise.all([
       this.fetchTagMap(resultIds),
-      this.fetchEmbeddingSet(resultIds)
+      this.fetchEmbeddingStatus(resultIds, resolvedEmbeddingSet, options.embeddingSetId)
     ]);
     let facets;
     if (options.include_facets) {
@@ -1673,15 +2171,12 @@ var SearchRepository = class {
       facets
     };
   }
-  /**
-   * Semantic search using pgvector cosine distance.
-   * Returns notes ranked by vector similarity to the query embedding.
-   */
   async semanticSearch(queryEmbedding, options = {}) {
     const { limit = 20, offset = 0 } = options;
     const vectorStr = `[${queryEmbedding.join(",")}]`;
+    const resolvedEmbeddingSet = await this.resolveEmbeddingSet(options);
     const { conditions, params, nextIdx } = buildNoteConditions(options, 1);
-    let paramIdx = nextIdx;
+    let paramIdx = this.scopeToResolvedEmbeddingRows(conditions, params, nextIdx, resolvedEmbeddingSet);
     const where = conditions.join(" AND ");
     const countResult = await this.db.query(
       `SELECT COUNT(*) as count
@@ -1707,26 +2202,20 @@ var SearchRepository = class {
       [...params, vectorStr, limit, offset]
     );
     const tagMap = await this.fetchTagMap(result.rows.map((r) => r.id));
-    let facets;
-    if (options.include_facets) {
-      const idsResult = await this.db.query(
-        `SELECT n.id FROM embedding e JOIN note n ON n.id = e.note_id WHERE ${where}`,
-        params
-      );
-      facets = await this.fetchFacets(idsResult.rows.map((r) => r.id));
-    }
+    const facets = options.include_facets ? await this.fetchFacets((await this.db.query(
+      `SELECT n.id FROM embedding e JOIN note n ON n.id = e.note_id WHERE ${where}`,
+      params
+    )).rows.map((r) => r.id)) : void 0;
     return {
       results: result.rows.map((r) => ({
         id: r.id,
         title: r.title,
         snippet: r.snippet ?? "",
         rank: 1 - r.distance,
-        // Convert distance to similarity score
         created_at: r.created_at,
         updated_at: r.updated_at,
         tags: tagMap.get(r.id) ?? [],
         has_embedding: true
-        // Semantic results always have embeddings (JOIN on embedding table)
       })),
       total,
       query: "",
@@ -1737,21 +2226,19 @@ var SearchRepository = class {
       facets
     };
   }
-  /**
-   * Hybrid search combining BM25 (full-text) and vector similarity using
-   * Reciprocal Rank Fusion (RRF, k=60).
-   */
   async hybridSearch(query, queryEmbedding, options = {}) {
     const { limit = 20, offset = 0 } = options;
     const vectorStr = `[${queryEmbedding.join(",")}]`;
     const k = 60;
     const tsqFn = this.tsqueryFn(query);
+    const resolvedEmbeddingSet = await this.resolveEmbeddingSet(options);
     const textCond = buildNoteConditions(options, 2);
     const textConditions = [
       ...textCond.conditions,
       `(n.tsv @@ ${tsqFn}('english', $1) OR
         to_tsvector('english', coalesce(c.content, '')) @@ ${tsqFn}('english', $1))`
     ];
+    this.scopeToResolvedEmbeddingSet(textConditions, textCond.params, textCond.nextIdx, resolvedEmbeddingSet);
     const textWhere = textConditions.join(" AND ");
     const textParams = [query, ...textCond.params];
     const textResult = await this.db.query(
@@ -1768,6 +2255,7 @@ var SearchRepository = class {
       textParams
     );
     const vecCond = buildNoteConditions(options, 1);
+    vecCond.nextIdx = this.scopeToResolvedEmbeddingRows(vecCond.conditions, vecCond.params, vecCond.nextIdx, resolvedEmbeddingSet);
     const vecWhere = vecCond.conditions.join(" AND ");
     const vecVecIdx = vecCond.nextIdx;
     const vectorResult = await this.db.query(
@@ -1781,26 +2269,16 @@ var SearchRepository = class {
     );
     const rrfScores = /* @__PURE__ */ new Map();
     textResult.rows.forEach((row, idx) => {
-      const score = 1 / (k + idx + 1);
-      rrfScores.set(row.id, (rrfScores.get(row.id) ?? 0) + score);
+      rrfScores.set(row.id, (rrfScores.get(row.id) ?? 0) + 1 / (k + idx + 1));
     });
     vectorResult.rows.forEach((row, idx) => {
-      const score = 1 / (k + idx + 1);
-      rrfScores.set(row.id, (rrfScores.get(row.id) ?? 0) + score);
+      rrfScores.set(row.id, (rrfScores.get(row.id) ?? 0) + 1 / (k + idx + 1));
     });
     const sortedIds = Array.from(rrfScores.entries()).sort((a, b) => b[1] - a[1]).map(([id]) => id);
     const total = sortedIds.length;
     const pageIds = sortedIds.slice(offset, offset + limit);
     if (pageIds.length === 0) {
-      return {
-        results: [],
-        total,
-        query,
-        mode: "hybrid",
-        semantic_available: this.semanticAvailable,
-        limit,
-        offset
-      };
+      return { results: [], total, query, mode: "hybrid", semantic_available: this.semanticAvailable, limit, offset };
     }
     const noteResult = await this.db.query(
       `SELECT n.id, n.title, n.created_at, n.updated_at,
@@ -1813,7 +2291,7 @@ var SearchRepository = class {
     const noteMap = new Map(noteResult.rows.map((r) => [r.id, r]));
     const [tagMap, embeddingSet] = await Promise.all([
       this.fetchTagMap(pageIds),
-      this.fetchEmbeddingSet(pageIds)
+      this.fetchEmbeddingStatus(pageIds, resolvedEmbeddingSet, options.embeddingSetId)
     ]);
     const facets = options.include_facets ? await this.fetchFacets(sortedIds) : void 0;
     return {
@@ -1842,8 +2320,9 @@ var SearchRepository = class {
   }
   async recentNotes(options = {}) {
     const { limit = 20, offset = 0 } = options;
+    const resolvedEmbeddingSet = await this.resolveEmbeddingSet(options);
     const { conditions, params, nextIdx } = buildNoteConditions(options, 1);
-    let paramIdx = nextIdx;
+    let paramIdx = this.scopeToResolvedEmbeddingSet(conditions, params, nextIdx, resolvedEmbeddingSet);
     const where = conditions.join(" AND ");
     const countResult = await this.db.query(
       `SELECT COUNT(*) as count FROM note n WHERE ${where}`,
@@ -1862,7 +2341,7 @@ var SearchRepository = class {
       listParams
     );
     const resultIds = result.rows.map((r) => r.id);
-    const embeddingSet = await this.fetchEmbeddingSet(resultIds);
+    const embeddingSet = await this.fetchEmbeddingStatus(resultIds, resolvedEmbeddingSet, options.embeddingSetId);
     return {
       results: result.rows.map((r) => ({
         id: r.id,
@@ -1882,14 +2361,8 @@ var SearchRepository = class {
       offset
     };
   }
-  /**
-   * Fetch faceted aggregate counts for tags and collections across all matching note IDs.
-   * Uses the full (unpaginated) result set for accurate counts.
-   */
   async fetchFacets(noteIds) {
-    if (noteIds.length === 0) {
-      return { tags: [], collections: [] };
-    }
+    if (noteIds.length === 0) return { tags: [], collections: [] };
     const [tagResult, collResult] = await Promise.all([
       this.db.query(
         `SELECT nt.tag, COUNT(*) as count FROM note_tag nt
@@ -1924,6 +2397,430 @@ var SearchRepository = class {
   }
 };
 
+// src/repositories/graph-repository.ts
+var SIMILARITY_GRAPH_ALGORITHM = "knn-v1";
+function hashJson(value) {
+  return computeHash(new TextEncoder().encode(JSON.stringify(value)));
+}
+function sourceIdFor(inputHash) {
+  return `similarity-${inputHash.replace(/^sha256:/, "").slice(0, 24)}`;
+}
+function jsonObject(value) {
+  if (value == null) return null;
+  if (typeof value === "string") return JSON.parse(value);
+  return value;
+}
+function detectCommunities(edges, nodes = [], options = {}) {
+  const nodeIds = new Set(nodes.map((n) => n.id));
+  for (const edge of edges) {
+    nodeIds.add(edge.source);
+    nodeIds.add(edge.target);
+  }
+  const labels = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    labels.set(id, id);
+    adjacency.set(id, []);
+  }
+  for (const edge of edges) {
+    adjacency.get(edge.source)?.push({ node: edge.target, weight: edge.weight });
+    adjacency.get(edge.target)?.push({ node: edge.source, weight: edge.weight });
+  }
+  const orderedNodes = Array.from(nodeIds).sort();
+  const maxIterations = options.maxIterations ?? 20;
+  for (let i = 0; i < maxIterations; i++) {
+    let changed = false;
+    for (const node of orderedNodes) {
+      const scores = /* @__PURE__ */ new Map();
+      for (const neighbor of adjacency.get(node) ?? []) {
+        const label = labels.get(neighbor.node) ?? neighbor.node;
+        scores.set(label, (scores.get(label) ?? 0) + neighbor.weight);
+      }
+      if (scores.size === 0) continue;
+      const nextLabel = Array.from(scores.entries()).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0][0];
+      if (nextLabel !== labels.get(node)) {
+        labels.set(node, nextLabel);
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const node of orderedNodes) {
+    const label = labels.get(node) ?? node;
+    const members = byLabel.get(label) ?? [];
+    members.push(node);
+    byLabel.set(label, members);
+  }
+  return Array.from(byLabel.values()).sort((a, b) => b.length - a.length || a[0].localeCompare(b[0])).map((members, index) => ({ id: `community-${index + 1}`, nodes: members }));
+}
+var GraphRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  normalizeSimilarityRequest(request) {
+    if (request.minSimilarity !== void 0 && request.threshold !== void 0 && request.minSimilarity !== request.threshold) {
+      throw new Error("conflicting-threshold");
+    }
+    return {
+      selector: request.selector,
+      k: request.k ?? 5,
+      minSimilarity: request.minSimilarity ?? request.threshold ?? -1,
+      metric: request.metric ?? "cosine",
+      source: request.source ?? "cache-preferred"
+    };
+  }
+  async buildSimilarityGraph(embeddingSet, options = {}) {
+    const selector = typeof embeddingSet === "string" ? { kind: "embedding-set", embeddingSetId: embeddingSet } : embeddingSet;
+    return this.buildSimilarityGraphFromResolved(
+      await new EmbeddingSetsRepository(this.db).resolveSelector(selector),
+      options
+    );
+  }
+  async buildSimilarityGraphLive(request) {
+    const normalized = this.normalizeSimilarityRequest({ ...request, source: "live-only" });
+    const resolved = await new EmbeddingSetsRepository(this.db).resolveSelector(normalized.selector);
+    return this.buildSimilarityGraphFromResolved(resolved, normalized);
+  }
+  async getCachedSimilarityGraph(request) {
+    const normalized = this.normalizeSimilarityRequest(request);
+    const resolved = await new EmbeddingSetsRepository(this.db).resolveSelector(normalized.selector);
+    const cacheKey = await this.computeSimilarityGraphCacheKey(normalized, resolved);
+    const inputHash = hashJson(cacheKey);
+    const source = await this.findGraphSource(inputHash);
+    if (!source) return null;
+    const graph = await this.graphFromArtifact(source.id, resolved.noteIds);
+    return {
+      graph,
+      graphSource: { id: source.id, name: source.name, input_hash: source.input_hash, freshness: source.freshness },
+      cache: "hit",
+      freshness: source.freshness
+    };
+  }
+  async buildOrLoadSimilarityGraph(request) {
+    const normalized = this.normalizeSimilarityRequest(request);
+    const resolved = await new EmbeddingSetsRepository(this.db).resolveSelector(normalized.selector);
+    const cacheKey = await this.computeSimilarityGraphCacheKey(normalized, resolved);
+    const inputHash = hashJson(cacheKey);
+    if (normalized.source !== "live-only") {
+      const cached = await this.findGraphSource(inputHash);
+      if (cached?.freshness === "fresh") {
+        const graph3 = await this.graphFromArtifact(cached.id, resolved.noteIds);
+        return {
+          graph: graph3,
+          graphSource: { id: cached.id, name: cached.name, input_hash: cached.input_hash, freshness: cached.freshness },
+          cache: "hit",
+          freshness: "fresh"
+        };
+      }
+      if (normalized.source === "cache-only") {
+        throw new Error(cached ? "similarity graph cache stale" : "similarity graph cache miss");
+      }
+      const graph2 = await this.buildSimilarityGraphFromResolved(resolved, normalized);
+      const graphSource = await this.saveSimilarityGraphArtifact({ graph: graph2, request: normalized, resolved, cacheKey, freshness: "fresh" });
+      return {
+        graph: graph2,
+        graphSource,
+        cache: cached ? "stale-live-built" : "miss-live-built",
+        freshness: cached ? cached.freshness : "fresh"
+      };
+    }
+    const graph = await this.buildSimilarityGraphFromResolved(resolved, normalized);
+    return {
+      graph,
+      graphSource: { id: sourceIdFor(inputHash), name: "Live similarity graph", input_hash: inputHash, freshness: "unknown" },
+      cache: "live-only",
+      freshness: "unknown"
+    };
+  }
+  async saveSimilarityGraphArtifact(input) {
+    const inputHash = hashJson(input.cacheKey);
+    const id = sourceIdFor(inputHash);
+    const parameters = {
+      k: input.request.k,
+      minSimilarity: input.request.minSimilarity,
+      metric: input.request.metric,
+      algorithm: SIMILARITY_GRAPH_ALGORITHM,
+      selectorHash: input.cacheKey.selectorHash,
+      parameterHash: input.cacheKey.parameterHash
+    };
+    await this.db.query(
+      `INSERT INTO graph_source (id, name, kind, source_table, embedding_set_id, virtual_set_id, model, dimension, metric, algorithm, parameters_json, input_hash, freshness_json)
+       VALUES ($1, $2, 'similarity', 'embedding', $3, $4, $5, $6, $7, $8, $9::jsonb, $10, $11::jsonb)
+       ON CONFLICT (id) DO UPDATE SET parameters_json = $9::jsonb, input_hash = $10, freshness_json = $11::jsonb`,
+      [
+        id,
+        "Cached similarity graph",
+        input.request.selector.kind === "embedding-set" ? input.request.selector.embeddingSetId ?? null : null,
+        input.request.selector.kind !== "embedding-set" ? input.request.selector.definition?.id ?? null : null,
+        input.cacheKey.model,
+        input.cacheKey.dimension,
+        input.request.metric,
+        SIMILARITY_GRAPH_ALGORITHM,
+        JSON.stringify(parameters),
+        inputHash,
+        JSON.stringify({ status: input.freshness ?? "fresh" })
+      ]
+    );
+    await this.db.query(`DELETE FROM graph_edge_artifact WHERE graph_source_id = $1`, [id]);
+    let rank = 1;
+    for (const edge of input.graph.edges) {
+      await this.db.query(
+        `INSERT INTO graph_edge_artifact (graph_source_id, from_note_id, to_note_id, weight, kind, rank)
+         VALUES ($1, $2, $3, $4, 'similarity', $5)`,
+        [id, edge.source, edge.target, edge.weight, rank++]
+      );
+    }
+    return { id, name: "Cached similarity graph", input_hash: inputHash, freshness: input.freshness ?? "fresh" };
+  }
+  async markSimilarityGraphStale(graphSourceId, reason) {
+    await this.db.query(
+      `UPDATE graph_source SET freshness_json = $2::jsonb WHERE id = $1`,
+      [graphSourceId, JSON.stringify({ status: "stale", stale_reason: reason, checked_at: (/* @__PURE__ */ new Date()).toISOString() })]
+    );
+  }
+  async loadGraphArtifact(graphSourceId, noteIds = []) {
+    return this.graphFromArtifact(graphSourceId, noteIds);
+  }
+  async buildSimilarityGraphFromResolved(resolved, options) {
+    const k = options.k ?? 5;
+    const minSimilarity = options.minSimilarity ?? options.threshold ?? -1;
+    const embeddings = resolved.rows;
+    const nodes = embeddings.map((row) => ({ id: row.note_id }));
+    const edgeMap = /* @__PURE__ */ new Map();
+    for (const row of embeddings) {
+      const neighbors = await this.db.query(
+        `SELECT note_id, 1 - (vector <=> $2::vector) as similarity
+         FROM embedding
+         WHERE id = ANY($1) AND note_id != $3
+         ORDER BY vector <=> $2::vector ASC
+         LIMIT $4`,
+        [resolved.embeddingIds, row.vector, row.note_id, k]
+      );
+      for (const neighbor of neighbors.rows) {
+        if (neighbor.similarity < minSimilarity) continue;
+        const [source, target] = [row.note_id, neighbor.note_id].sort();
+        const id = `${source}\0${target}`;
+        const existing = edgeMap.get(id);
+        if (!existing || neighbor.similarity > existing.weight) {
+          edgeMap.set(id, { source, target, weight: neighbor.similarity, kind: "similarity" });
+        }
+      }
+    }
+    const edges = Array.from(edgeMap.values()).sort(
+      (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target)
+    );
+    return { nodes, edges, communities: detectCommunities(edges, nodes) };
+  }
+  async computeSimilarityGraphCacheKey(request, resolved) {
+    const firstSetId = resolved.rows[0]?.embedding_set_id;
+    const set = firstSetId ? await new EmbeddingSetsRepository(this.db).get(firstSetId) : null;
+    return {
+      selectorHash: hashJson(request.selector),
+      resolvedEmbeddingSetId: request.selector.kind === "embedding-set" ? request.selector.embeddingSetId : void 0,
+      virtualSetId: request.selector.kind === "virtual-definition" ? request.selector.definition?.id : void 0,
+      k: request.k,
+      minSimilarity: request.minSimilarity,
+      metric: request.metric,
+      model: set?.model_name ?? "unknown",
+      dimension: set?.dimensions ?? 0,
+      truncateDimension: set?.truncate_dimension ?? null,
+      memberHash: hashJson(resolved.rows.map((row) => [row.note_id, row.embedding_set_id, row.embedding_id])),
+      vectorHash: hashJson(resolved.rows.map((row) => [row.embedding_id, row.vector])),
+      parameterHash: hashJson({ k: request.k, minSimilarity: request.minSimilarity, metric: request.metric, algorithm: SIMILARITY_GRAPH_ALGORITHM })
+    };
+  }
+  async findGraphSource(inputHash) {
+    const result = await this.db.query(
+      `SELECT id, name, input_hash, freshness_json FROM graph_source WHERE kind = 'similarity' AND input_hash = $1 LIMIT 1`,
+      [inputHash]
+    );
+    if (result.rows.length === 0) return null;
+    const row = result.rows[0];
+    const freshness = jsonObject(row.freshness_json);
+    return { id: row.id, name: row.name, input_hash: row.input_hash, freshness: freshness?.status ?? "unknown" };
+  }
+  async graphFromArtifact(graphSourceId, noteIds) {
+    const result = await this.db.query(
+      `SELECT from_note_id as source, to_note_id as target, weight, kind
+       FROM graph_edge_artifact
+       WHERE graph_source_id = $1
+       ORDER BY from_note_id, to_note_id`,
+      [graphSourceId]
+    );
+    const nodes = Array.from(/* @__PURE__ */ new Set([...noteIds, ...result.rows.flatMap((edge) => [edge.source, edge.target])])).sort().map((id) => ({ id }));
+    return { nodes, edges: result.rows, communities: detectCommunities(result.rows, nodes) };
+  }
+  async buildLinkGraph(linkType) {
+    const params = [];
+    const typeFilter = linkType ? " AND link_type = $1" : "";
+    if (linkType) params.push(linkType);
+    const result = await this.db.query(
+      `SELECT source_note_id as source, target_note_id as target,
+              COALESCE(confidence, 1.0) as weight, link_type as kind
+       FROM link
+       WHERE deleted_at IS NULL${typeFilter}
+       ORDER BY source_note_id, target_note_id`,
+      params
+    );
+    const nodes = Array.from(new Set(result.rows.flatMap((edge) => [edge.source, edge.target]))).sort().map((id) => ({ id }));
+    return { nodes, edges: result.rows, communities: detectCommunities(result.rows, nodes) };
+  }
+};
+
+// src/repositories/communities-repository.ts
+function json(value) {
+  return value == null ? null : JSON.stringify(value);
+}
+function parseObject(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") return JSON.parse(value);
+  return value;
+}
+function iso(value) {
+  if (!value) return void 0;
+  return value instanceof Date ? value.toISOString() : value;
+}
+var CommunitiesRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async previewDynamicCommunity(filters) {
+    const noteIds = await this.resolveFilterNoteIds(filters);
+    return noteIds.map((noteId) => ({
+      communitySourceId: "dynamic-preview",
+      communityId: "dynamic-preview",
+      noteId,
+      label: "Dynamic preview",
+      confidence: null,
+      sourceType: "dynamic"
+    }));
+  }
+  async saveCommunity(input) {
+    const sourceId = generateId();
+    const communitySetId = generateId();
+    const communityId = generateId();
+    const noteIds = input.noteIds ?? (input.filters ? await this.resolveFilterNoteIds(input.filters) : []);
+    const sourceKind = input.sourceType === "dynamic-snapshot" ? "search" : "manual";
+    const freshness = input.sourceType === "dynamic-snapshot" ? "fresh" : "unknown";
+    await this.db.query(
+      `INSERT INTO graph_source (id, name, kind, source_table, parameters_json, input_hash, freshness_json)
+       VALUES ($1, $2, $3, 'manual', $4::jsonb, $5, $6::jsonb)`,
+      [sourceId, input.name, sourceKind, json({ filters: input.filters ?? null }), `community:${sourceId}`, json({ status: freshness })]
+    );
+    await this.db.query(
+      `INSERT INTO community_set (id, graph_source_id, name, source_type, parameters_json, input_hash, freshness_json)
+       VALUES ($1, $2, $3, $4, $5::jsonb, $6, $7::jsonb)`,
+      [communitySetId, sourceId, input.name, input.sourceType, json({ filters: input.filters ?? null }), `community:${communitySetId}`, json({ status: freshness })]
+    );
+    await this.db.query(
+      `INSERT INTO community (community_set_id, id, label, rank, size, representative_note_ids)
+       VALUES ($1, $2, $3, 1, $4, $5)`,
+      [communitySetId, communityId, input.label ?? input.name, noteIds.length, input.representativeNoteIds ?? []]
+    );
+    for (const noteId of noteIds) {
+      await this.db.query(
+        `INSERT INTO community_assignment (community_set_id, community_id, note_id, confidence, source_type)
+         VALUES ($1, $2, $3, NULL, $4)`,
+        [communitySetId, communityId, noteId, input.sourceType]
+      );
+    }
+    return {
+      id: communitySetId,
+      name: input.name,
+      sourceType: input.sourceType,
+      graphSourceId: sourceId,
+      searchQuery: input.filters?.query,
+      filters: input.filters,
+      freshness
+    };
+  }
+  async rerunDynamicCommunity(sourceId) {
+    const result = await this.db.query(
+      `SELECT parameters_json, source_type FROM community_set WHERE id = $1`,
+      [sourceId]
+    );
+    if (result.rows.length === 0) throw new Error(`Community source not found: ${sourceId}`);
+    const parameters = parseObject(result.rows[0].parameters_json);
+    if (!parameters?.filters) return this.getCommunityAssignments(sourceId);
+    const preview = await this.previewDynamicCommunity(parameters.filters);
+    return preview.map((assignment) => ({ ...assignment, communitySourceId: sourceId, sourceType: "dynamic" }));
+  }
+  async listCommunitySources() {
+    const result = await this.db.query(`SELECT * FROM community_set ORDER BY created_at, name`);
+    return result.rows.map((row) => {
+      const parameters = parseObject(row.parameters_json);
+      const freshness = parseObject(row.freshness_json);
+      return {
+        id: row.id,
+        name: row.name,
+        sourceType: row.source_type,
+        graphSourceId: row.graph_source_id,
+        searchQuery: parameters?.filters?.query,
+        filters: parameters?.filters ?? void 0,
+        createdAt: iso(row.created_at),
+        freshness: freshness?.status ?? "unknown"
+      };
+    });
+  }
+  async getCommunityAssignments(sourceId) {
+    const result = await this.db.query(
+      `SELECT ca.community_set_id, ca.community_id, ca.note_id, c.label, ca.confidence, ca.source_type
+       FROM community_assignment ca
+       LEFT JOIN community c ON c.community_set_id = ca.community_set_id AND c.id = ca.community_id
+       WHERE ca.community_set_id = $1
+       ORDER BY ca.community_id, ca.note_id`,
+      [sourceId]
+    );
+    return result.rows.map((row) => ({
+      communitySourceId: row.community_set_id,
+      communityId: row.community_id,
+      noteId: row.note_id,
+      label: row.label,
+      confidence: row.confidence,
+      sourceType: row.source_type
+    }));
+  }
+  async listCommunitySummaries(sourceId) {
+    const result = await this.db.query(
+      `SELECT c.id, c.label, cs.source_type, c.size, c.confidence, c.representative_note_ids, cs.freshness_json
+       FROM community c
+       JOIN community_set cs ON cs.id = c.community_set_id
+       WHERE c.community_set_id = $1
+       ORDER BY c.rank NULLS LAST, c.id`,
+      [sourceId]
+    );
+    return result.rows.map((row) => {
+      const freshness = parseObject(row.freshness_json);
+      return {
+        id: row.id,
+        label: row.label ?? row.id,
+        sourceType: row.source_type,
+        size: row.size ?? 0,
+        confidence: row.confidence,
+        representativeNoteIds: row.representative_note_ids ?? [],
+        freshness: freshness?.status ?? "unknown"
+      };
+    });
+  }
+  async resolveFilterNoteIds(filters) {
+    if (filters.conceptIds?.length) {
+      throw new Error("Community concept filters are not supported locally yet");
+    }
+    if (filters.noteIds?.length && !filters.query && !filters.tags?.length && !filters.collectionIds?.length && !filters.embeddingSetSelector) {
+      return [...filters.noteIds].sort();
+    }
+    const result = await new SearchRepository(this.db, true).search(filters.query ?? "", {
+      limit: 1e3,
+      tags: filters.tags,
+      collection_id: filters.collectionIds?.[0],
+      embeddingSetSelector: filters.embeddingSetSelector
+    });
+    const ids = result.results.map((row) => row.id);
+    return filters.noteIds?.length ? ids.filter((id) => filters.noteIds?.includes(id)) : ids;
+  }
+};
+
 // src/capabilities/llm-handler.ts
 var llmFn = null;
 function setLlmFunction(fn) {
@@ -2740,7 +3637,7 @@ function resolvePropertySchema(value) {
 }
 var TOOL_DEFINITIONS = [
   {
-    id: "mnemos.capture_knowledge",
+    id: "fortemi.capture_knowledge",
     name: "Capture Knowledge",
     description: "WHEN you have text, ideas, or information to save. WHAT creates one or more notes in Fortemi. HOW accepts content, optional title/tags, supports create/bulk_create/from_template. OUT returns the created note(s) with full metadata.",
     category: "capture",
@@ -2749,7 +3646,7 @@ var TOOL_DEFINITIONS = [
     sideEffects: true
   },
   {
-    id: "mnemos.manage_note",
+    id: "fortemi.manage_note",
     name: "Manage Note",
     description: "WHEN you need to modify an existing note. WHAT updates, deletes, restores, archives, or stars a note. HOW accepts note_id and action (update/delete/restore/archive/star). OUT returns the updated note.",
     category: "manage",
@@ -2758,7 +3655,7 @@ var TOOL_DEFINITIONS = [
     sideEffects: true
   },
   {
-    id: "mnemos.search",
+    id: "fortemi.search",
     name: "Search Notes",
     description: "WHEN you need to find notes by content or metadata. WHAT performs full-text search across all notes. HOW accepts query string with optional tag/collection filters. OUT returns ranked results with highlighted snippets.",
     category: "search",
@@ -2767,7 +3664,7 @@ var TOOL_DEFINITIONS = [
     sideEffects: false
   },
   {
-    id: "mnemos.get_note",
+    id: "fortemi.get_note",
     name: "Get Note",
     description: "WHEN you need the full content of a specific note. WHAT retrieves a single note by ID. HOW accepts note_id. OUT returns complete note with content, metadata, tags, and revision info.",
     category: "manage",
@@ -2776,7 +3673,7 @@ var TOOL_DEFINITIONS = [
     sideEffects: false
   },
   {
-    id: "mnemos.list_notes",
+    id: "fortemi.list_notes",
     name: "List Notes",
     description: "WHEN you need to browse or filter notes. WHAT lists notes with pagination and filtering. HOW accepts optional filters (starred, archived, tags, collection). OUT returns paginated note summaries.",
     category: "manage",
@@ -2794,7 +3691,7 @@ var TOOL_DEFINITIONS = [
     sideEffects: false
   },
   {
-    id: "mnemos.manage_tags",
+    id: "fortemi.manage_tags",
     name: "Manage Tags",
     description: "WHEN you need to organize notes with tags. WHAT adds or removes tags from notes. HOW accepts note_id, action (add/remove), and tag string. OUT confirms the tag operation.",
     category: "organize",
@@ -2807,7 +3704,7 @@ var TOOL_DEFINITIONS = [
     sideEffects: true
   },
   {
-    id: "mnemos.manage_collections",
+    id: "fortemi.manage_collections",
     name: "Manage Collections",
     description: "WHEN you need to organize notes into folders. WHAT creates, updates, or manages collections. HOW accepts collection operations (create/list/assign/delete). OUT returns collection data.",
     category: "organize",
@@ -2821,7 +3718,7 @@ var TOOL_DEFINITIONS = [
     sideEffects: true
   },
   {
-    id: "mnemos.manage_links",
+    id: "fortemi.manage_links",
     name: "Manage Links",
     description: "WHEN you need to connect related notes. WHAT creates bidirectional links between notes. HOW accepts source/target note IDs and link type. OUT returns the link data.",
     category: "organize",
@@ -2836,7 +3733,7 @@ var TOOL_DEFINITIONS = [
     sideEffects: true
   },
   {
-    id: "mnemos.manage_archive",
+    id: "fortemi.manage_archive",
     name: "Manage Archive",
     description: "WHEN you need to switch between or manage knowledge archives. WHAT creates, lists, switches, or deletes archives. HOW accepts archive name and operation. OUT returns archive info.",
     category: "system",
@@ -2848,7 +3745,7 @@ var TOOL_DEFINITIONS = [
     sideEffects: true
   },
   {
-    id: "mnemos.manage_capabilities",
+    id: "fortemi.manage_capabilities",
     name: "Manage Capabilities",
     description: "WHEN you need to enable optional features like vector search or LLM. WHAT enables, disables, or queries WASM capability modules. HOW accepts capability name and action. OUT returns capability status.",
     category: "system",
@@ -2894,8 +3791,8 @@ var FortemiToolManifest = class {
       (t) => t.name.toLowerCase().includes(q) || t.description.toLowerCase().includes(q) || t.tags.some((tag) => tag.includes(q))
     );
   }
-  /** Project all tools as PlinyCapability entries for bridge registration. */
-  toPlinyCapabilities() {
+  /** Project all tools as BridgeCapability entries for bridge registration. */
+  toBridgeCapabilities() {
     return this.list().map((tool) => ({
       id: tool.id,
       name: tool.name,
@@ -3475,19 +4372,6 @@ function setEmbedFunction(fn) {
 function getEmbedFunction() {
   return embedFn;
 }
-async function ensureEmbeddingSet(db) {
-  const result = await db.query(
-    `SELECT id FROM embedding_set WHERE model_name = $1`,
-    ["all-MiniLM-L6-v2"]
-  );
-  if (result.rows.length > 0) return result.rows[0].id;
-  const id = generateId();
-  await db.query(
-    `INSERT INTO embedding_set (id, model_name, dimensions) VALUES ($1, $2, $3)`,
-    [id, "all-MiniLM-L6-v2", 384]
-  );
-  return id;
-}
 function averageEmbeddings(embeddings) {
   if (embeddings.length === 1) return embeddings[0];
   const dims = embeddings[0].length;
@@ -3515,27 +4399,14 @@ async function embeddingGenerationHandler(job, db) {
   const chunks = chunkText(content);
   const embeddings = await fn(chunks);
   const vector2 = averageEmbeddings(embeddings);
-  const setId = await ensureEmbeddingSet(db);
-  await db.query(
-    `DELETE FROM embedding_set_member WHERE note_id = $1 AND embedding_set_id = $2`,
-    [job.note_id, setId]
-  );
-  await db.query(
-    `DELETE FROM embedding WHERE note_id = $1 AND embedding_set_id = $2`,
-    [job.note_id, setId]
-  );
-  const embId = generateId();
-  const vectorStr = `[${vector2.join(",")}]`;
-  await db.query(
-    `INSERT INTO embedding (id, note_id, embedding_set_id, vector) VALUES ($1, $2, $3, $4::vector)`,
-    [embId, job.note_id, setId, vectorStr]
-  );
-  await db.query(
-    `INSERT INTO embedding_set_member (embedding_set_id, note_id, embedding_id) VALUES ($1, $2, $3)
-     ON CONFLICT (embedding_set_id, note_id) DO UPDATE SET embedding_id = $3`,
-    [setId, job.note_id, embId]
-  );
-  return { chunks: chunks.length, embeddings: embeddings.length, setId };
+  const embeddingSets = new EmbeddingSetsRepository(db);
+  const set = await embeddingSets.ensureDefault();
+  await embeddingSets.putEmbedding({
+    note_id: job.note_id,
+    embedding_set_id: set.id,
+    vector: vector2
+  });
+  return { chunks: chunks.length, embeddings: embeddings.length, setId: set.id };
 }
 
 // src/capabilities/auto-tag.ts
@@ -4424,16 +5295,16 @@ function createCspReportHandler(onReport) {
     if (request.method !== "POST") {
       return new Response(null, { status: 405, headers: { Allow: "POST" } });
     }
-    let json;
+    let json2;
     try {
-      json = await request.json();
+      json2 = await request.json();
     } catch {
       return new Response(JSON.stringify({ error: "Invalid CSP report JSON" }), {
         status: 400,
         headers: { "Content-Type": "application/json" }
       });
     }
-    await onReport(parseCspReport(json));
+    await onReport(parseCspReport(json2));
     return new Response(null, { status: 204 });
   };
 }
@@ -4647,17 +5518,39 @@ function tagsFromShard(shardTags) {
 function embeddingSetToShard(set) {
   return {
     id: set.id,
+    name: set.name ?? set.model_name,
+    purpose: set.purpose ?? null,
     model: set.model_name,
     dimension: set.dimensions,
-    created_at: toISOString(set.created_at)
+    kind: set.kind ?? "physical",
+    mode: set.mode ?? null,
+    truncate_dimension: set.truncate_dimension ?? null,
+    criteria: jsonObject2(set.criteria_json),
+    source: jsonObject2(set.source_json),
+    compatibility: jsonObject2(set.compatibility_json),
+    materialization: jsonObject2(set.materialization_json),
+    freshness: jsonObject2(set.freshness_json),
+    created_at: toISOString(set.created_at),
+    updated_at: set.updated_at ? toISOString(set.updated_at) : void 0
   };
 }
 function embeddingSetFromShard(shard) {
   return {
     id: shard.id,
+    name: shard.name ?? shard.model,
+    purpose: shard.purpose ?? null,
     model_name: shard.model,
     dimensions: shard.dimension,
-    created_at: shard.created_at
+    kind: shard.kind ?? "physical",
+    mode: shard.mode ?? null,
+    truncate_dimension: shard.truncate_dimension ?? null,
+    criteria_json: jsonString(shard.criteria),
+    source_json: jsonString(shard.source),
+    compatibility_json: jsonString(shard.compatibility),
+    materialization_json: jsonString(shard.materialization),
+    freshness_json: jsonString(shard.freshness),
+    created_at: shard.created_at,
+    updated_at: shard.updated_at ?? null
   };
 }
 function embeddingSetMemberToShard(member) {
@@ -4685,6 +5578,55 @@ function embeddingFromShard(shard) {
     created_at: shard.created_at
   };
 }
+function skosSchemeToShard(scheme) {
+  return {
+    id: scheme.id,
+    title: scheme.title,
+    description: scheme.description,
+    created_at: toISOString(scheme.created_at),
+    updated_at: toISOString(scheme.updated_at)
+  };
+}
+function skosConceptToShard(concept) {
+  return {
+    id: concept.id,
+    scheme_id: concept.scheme_id,
+    pref_label: concept.pref_label,
+    alt_labels: parseJsonArrayField(concept.alt_labels),
+    definition: concept.definition,
+    created_at: toISOString(concept.created_at),
+    updated_at: toISOString(concept.updated_at)
+  };
+}
+function skosRelationToShard(relation) {
+  return {
+    id: relation.id,
+    source_concept_id: relation.source_concept_id,
+    target_concept_id: relation.target_concept_id,
+    relation_type: relation.relation_type,
+    created_at: toISOString(relation.created_at)
+  };
+}
+function noteSkosTagToShard(tag) {
+  return {
+    id: tag.id,
+    note_id: tag.note_id,
+    concept_id: tag.concept_id,
+    created_at: toISOString(tag.created_at)
+  };
+}
+function provenanceEdgeToShard(edge) {
+  return {
+    id: edge.id,
+    entity_type: edge.entity_type,
+    entity_id: edge.entity_id,
+    activity: edge.activity,
+    agent: edge.agent,
+    started_at: toISOString(edge.started_at),
+    ended_at: edge.ended_at ? toISOString(edge.ended_at) : null,
+    attributes: parseJsonObjectField(edge.attributes)
+  };
+}
 function toISOString(date) {
   if (date instanceof Date) return date.toISOString();
   return date;
@@ -4693,9 +5635,37 @@ function parseVector(vectorStr) {
   const inner = vectorStr.replace(/^\[/, "").replace(/\]$/, "");
   return inner.split(",").map(Number);
 }
+function parseJsonArrayField(value) {
+  if (Array.isArray(value)) return value;
+  if (!value) return [];
+  const parsed = JSON.parse(value);
+  return Array.isArray(parsed) ? parsed.map(String) : [];
+}
+function parseJsonObjectField(value) {
+  if (!value) return null;
+  if (typeof value !== "string") return value;
+  const parsed = JSON.parse(value);
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+}
+function jsonObject2(value) {
+  if (value == null) return null;
+  if (typeof value === "string") return JSON.parse(value);
+  return value;
+}
+function jsonString(value) {
+  return value == null ? null : JSON.stringify(value);
+}
 
 // src/shard/shard-export.ts
 var encoder = new TextEncoder();
+function jsonObject3(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") return JSON.parse(value);
+  return value;
+}
+function iso2(value) {
+  return value instanceof Date ? value.toISOString() : value;
+}
 async function exportShard(db, options) {
   const files = /* @__PURE__ */ new Map();
   const components = [];
@@ -4797,6 +5767,41 @@ async function exportShard(db, options) {
   files.set("links.jsonl", encoder.encode(linksJsonl));
   components.push("links");
   counts.links = filteredLinks.length;
+  const allNoteSkosRows = await db.query(`SELECT * FROM note_skos_tag ORDER BY created_at`);
+  const filteredNoteSkosRows = isFiltered ? allNoteSkosRows.rows.filter((row) => exportedNoteIds.has(row.note_id)) : allNoteSkosRows.rows;
+  const referencedConceptIds = new Set(filteredNoteSkosRows.map((row) => row.concept_id));
+  const allConceptRows = await db.query(`SELECT * FROM skos_concept WHERE deleted_at IS NULL ORDER BY pref_label`);
+  const filteredConceptRows = isFiltered ? allConceptRows.rows.filter((row) => referencedConceptIds.has(row.id)) : allConceptRows.rows;
+  const exportedConceptIds = new Set(filteredConceptRows.map((row) => row.id));
+  const exportedSchemeIds = new Set(filteredConceptRows.map((row) => row.scheme_id));
+  const allSchemeRows = await db.query(`SELECT * FROM skos_scheme WHERE deleted_at IS NULL ORDER BY title`);
+  const filteredSchemeRows = isFiltered ? allSchemeRows.rows.filter((row) => exportedSchemeIds.has(row.id)) : allSchemeRows.rows;
+  const allRelationRows = await db.query(`SELECT * FROM skos_concept_relation ORDER BY created_at`);
+  const filteredRelationRows = isFiltered ? allRelationRows.rows.filter(
+    (row) => exportedConceptIds.has(row.source_concept_id) && exportedConceptIds.has(row.target_concept_id)
+  ) : allRelationRows.rows;
+  const shardSkosSchemes = filteredSchemeRows.map(skosSchemeToShard);
+  files.set("skos_schemes.json", encoder.encode(JSON.stringify(shardSkosSchemes)));
+  components.push("skos_schemes");
+  counts.skos_schemes = shardSkosSchemes.length;
+  const shardSkosConcepts = filteredConceptRows.map(skosConceptToShard);
+  files.set("skos_concepts.json", encoder.encode(JSON.stringify(shardSkosConcepts)));
+  components.push("skos_concepts");
+  counts.skos_concepts = shardSkosConcepts.length;
+  const skosRelationsJsonl = filteredRelationRows.map((row) => JSON.stringify(skosRelationToShard(row))).join("\n");
+  files.set("skos_relations.jsonl", encoder.encode(skosRelationsJsonl));
+  components.push("skos_relations");
+  counts.skos_relations = filteredRelationRows.length;
+  const noteSkosJsonl = filteredNoteSkosRows.map((row) => JSON.stringify(noteSkosTagToShard(row))).join("\n");
+  files.set("note_skos_tags.jsonl", encoder.encode(noteSkosJsonl));
+  components.push("note_skos_tags");
+  counts.note_skos_tags = filteredNoteSkosRows.length;
+  const provenanceRows = await db.query(`SELECT * FROM provenance_edge ORDER BY started_at`);
+  const filteredProvenanceRows = isFiltered ? provenanceRows.rows.filter((row) => row.entity_type !== "note" || exportedNoteIds.has(row.entity_id)) : provenanceRows.rows;
+  const provenanceJsonl = filteredProvenanceRows.map((row) => JSON.stringify(provenanceEdgeToShard(row))).join("\n");
+  files.set("provenance_edges.jsonl", encoder.encode(provenanceJsonl));
+  components.push("provenance_edges");
+  counts.provenance_edges = filteredProvenanceRows.length;
   if (options?.includeEmbeddings) {
     const embSetRows = await db.query(`SELECT * FROM embedding_set ORDER BY created_at`);
     const shardEmbSets = embSetRows.rows.map(embeddingSetToShard);
@@ -4814,6 +5819,92 @@ async function exportShard(db, options) {
     components.push("embeddings");
     counts.embeddings = embRows.rows.length;
   }
+  const graphSourceRows = await db.query(`SELECT * FROM graph_source ORDER BY created_at, id`);
+  if (graphSourceRows.rows.length > 0) {
+    const shardGraphSources = graphSourceRows.rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      kind: row.kind,
+      source_table: row.source_table,
+      embedding_set_id: row.embedding_set_id,
+      virtual_set_id: row.virtual_set_id,
+      model: row.model,
+      dimension: row.dimension,
+      truncate_dimension: row.truncate_dimension,
+      metric: row.metric,
+      algorithm: row.algorithm,
+      parameters: jsonObject3(row.parameters_json),
+      input_hash: row.input_hash,
+      freshness: jsonObject3(row.freshness_json) ?? { status: "unknown" },
+      created_at: iso2(row.created_at)
+    }));
+    files.set("graph_sources.json", encoder.encode(JSON.stringify(shardGraphSources)));
+    components.push("graph_sources");
+    counts.graph_sources = shardGraphSources.length;
+  }
+  const graphEdgeRows = await db.query(`SELECT * FROM graph_edge_artifact ORDER BY graph_source_id, from_note_id, to_note_id, kind`);
+  if (graphEdgeRows.rows.length > 0) {
+    const graphEdgesJsonl = graphEdgeRows.rows.map((row) => JSON.stringify({
+      graph_source_id: row.graph_source_id,
+      from_note_id: row.from_note_id,
+      to_note_id: row.to_note_id,
+      weight: row.weight,
+      kind: row.kind,
+      rank: row.rank,
+      metadata: jsonObject3(row.metadata_json)
+    })).join("\n");
+    files.set("graph_edges.jsonl", encoder.encode(graphEdgesJsonl));
+    components.push("graph_edges");
+    counts.graph_edges = graphEdgeRows.rows.length;
+  }
+  const communitySetRows = await db.query(`SELECT * FROM community_set ORDER BY created_at, id`);
+  const communityRows = await db.query(`SELECT * FROM community ORDER BY community_set_id, rank NULLS LAST, id`);
+  if (communitySetRows.rows.length > 0) {
+    const communitiesBySet = /* @__PURE__ */ new Map();
+    for (const row of communityRows.rows) {
+      const rows = communitiesBySet.get(row.community_set_id) ?? [];
+      rows.push(row);
+      communitiesBySet.set(row.community_set_id, rows);
+    }
+    const shardCommunitySets = communitySetRows.rows.map((row) => ({
+      id: row.id,
+      graph_source_id: row.graph_source_id,
+      name: row.name,
+      source_type: row.source_type,
+      algorithm: row.algorithm,
+      parameters: jsonObject3(row.parameters_json),
+      input_hash: row.input_hash,
+      freshness: jsonObject3(row.freshness_json) ?? { status: "unknown" },
+      communities: (communitiesBySet.get(row.id) ?? []).map((community) => ({
+        id: community.id,
+        label: community.label,
+        rank: community.rank,
+        size: community.size,
+        confidence: community.confidence,
+        representative_note_ids: community.representative_note_ids ?? [],
+        metadata: jsonObject3(community.metadata_json)
+      })),
+      created_at: iso2(row.created_at)
+    }));
+    files.set("communities.json", encoder.encode(JSON.stringify(shardCommunitySets)));
+    components.push("communities");
+    counts.community_sets = shardCommunitySets.length;
+    counts.communities = communityRows.rows.length;
+  }
+  const assignmentRows = await db.query(`SELECT * FROM community_assignment ORDER BY community_set_id, community_id, note_id`);
+  if (assignmentRows.rows.length > 0) {
+    const assignmentsJsonl = assignmentRows.rows.map((row) => JSON.stringify({
+      community_set_id: row.community_set_id,
+      community_id: row.community_id,
+      note_id: row.note_id,
+      confidence: row.confidence,
+      source_type: row.source_type,
+      metadata: jsonObject3(row.metadata_json)
+    })).join("\n");
+    files.set("community_assignments.jsonl", encoder.encode(assignmentsJsonl));
+    components.push("community_assignments");
+    counts.community_assignments = assignmentRows.rows.length;
+  }
   const checksums = {};
   for (const [filename, data] of files) {
     checksums[filename] = await sha256Hex(data);
@@ -4846,7 +5937,17 @@ async function importShard(db, data, options) {
     links: 0,
     embedding_sets: 0,
     embedding_set_members: 0,
-    embeddings: 0
+    embeddings: 0,
+    skos_schemes: 0,
+    skos_concepts: 0,
+    skos_relations: 0,
+    note_skos_tags: 0,
+    provenance_edges: 0,
+    graph_sources: 0,
+    graph_edges: 0,
+    community_sets: 0,
+    communities: 0,
+    community_assignments: 0
   };
   const skipped = {};
   const inputData = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
@@ -4919,6 +6020,15 @@ async function importShard(db, data, options) {
     files.get("embedding_set_members.jsonl")
   );
   const parsedEmbeddings = parseJsonl(files.get("embeddings.jsonl"));
+  const parsedSkosSchemes = parseJsonArray(files.get("skos_schemes.json"));
+  const parsedSkosConcepts = parseJsonArray(files.get("skos_concepts.json"));
+  const parsedSkosRelations = parseJsonl(files.get("skos_relations.jsonl"));
+  const parsedNoteSkosTags = parseJsonl(files.get("note_skos_tags.jsonl"));
+  const parsedProvenanceEdges = parseJsonl(files.get("provenance_edges.jsonl"));
+  const parsedGraphSources = parseJsonArray(files.get("graph_sources.json"));
+  const parsedGraphEdges = parseJsonl(files.get("graph_edges.jsonl"));
+  const parsedCommunitySets = parseJsonArray(files.get("communities.json"));
+  const parsedCommunityAssignments = parseJsonl(files.get("community_assignments.jsonl"));
   const knownFiles = /* @__PURE__ */ new Set([
     "manifest.json",
     "notes.jsonl",
@@ -4929,7 +6039,16 @@ async function importShard(db, data, options) {
     "embedding_set_members.jsonl",
     "embedding_configs.json",
     "embeddings.jsonl",
-    "templates.json"
+    "templates.json",
+    "skos_schemes.json",
+    "skos_concepts.json",
+    "skos_relations.jsonl",
+    "note_skos_tags.jsonl",
+    "provenance_edges.jsonl",
+    "graph_sources.json",
+    "graph_edges.jsonl",
+    "communities.json",
+    "community_assignments.jsonl"
   ]);
   for (const filename of files.keys()) {
     if (!knownFiles.has(filename)) {
@@ -5038,6 +6157,41 @@ async function importShard(db, data, options) {
         }
         counts.notes++;
       }
+      for (const scheme of parsedSkosSchemes) {
+        if (strategy === "replace") {
+          await tx.query(
+            `INSERT INTO skos_scheme (id, title, description, created_at, updated_at)
+             VALUES ($1, $2, $3, $4, $5)
+             ON CONFLICT (id) DO UPDATE SET title = $2, description = $3, updated_at = $5`,
+            [scheme.id, scheme.title, scheme.description, scheme.created_at, scheme.updated_at]
+          );
+        } else {
+          await tx.query(
+            `INSERT INTO skos_scheme (id, title, description, created_at, updated_at)
+             VALUES ($1, $2, $3, $4, $5) ${conflictClause}`,
+            [scheme.id, scheme.title, scheme.description, scheme.created_at, scheme.updated_at]
+          );
+        }
+        counts.skos_schemes++;
+      }
+      for (const concept of parsedSkosConcepts) {
+        const altLabels = JSON.stringify(concept.alt_labels ?? []);
+        if (strategy === "replace") {
+          await tx.query(
+            `INSERT INTO skos_concept (id, scheme_id, pref_label, alt_labels, definition, created_at, updated_at)
+             VALUES ($1, $2, $3, $4, $5, $6, $7)
+             ON CONFLICT (id) DO UPDATE SET scheme_id = $2, pref_label = $3, alt_labels = $4, definition = $5, updated_at = $7`,
+            [concept.id, concept.scheme_id, concept.pref_label, altLabels, concept.definition, concept.created_at, concept.updated_at]
+          );
+        } else {
+          await tx.query(
+            `INSERT INTO skos_concept (id, scheme_id, pref_label, alt_labels, definition, created_at, updated_at)
+             VALUES ($1, $2, $3, $4, $5, $6, $7) ${conflictClause}`,
+            [concept.id, concept.scheme_id, concept.pref_label, altLabels, concept.definition, concept.created_at, concept.updated_at]
+          );
+        }
+        counts.skos_concepts++;
+      }
       for (const shardLink of parsedLinks) {
         const link = linkFromShard(shardLink);
         if (strategy === "replace") {
@@ -5056,20 +6210,70 @@ async function importShard(db, data, options) {
         }
         counts.links++;
       }
+      for (const relation of parsedSkosRelations) {
+        if (strategy === "replace") {
+          await tx.query(
+            `INSERT INTO skos_concept_relation (id, source_concept_id, target_concept_id, relation_type, created_at)
+             VALUES ($1, $2, $3, $4, $5)
+             ON CONFLICT (id) DO UPDATE SET source_concept_id = $2, target_concept_id = $3, relation_type = $4`,
+            [relation.id, relation.source_concept_id, relation.target_concept_id, relation.relation_type, relation.created_at]
+          );
+        } else {
+          await tx.query(
+            `INSERT INTO skos_concept_relation (id, source_concept_id, target_concept_id, relation_type, created_at)
+             VALUES ($1, $2, $3, $4, $5) ${conflictClause}`,
+            [relation.id, relation.source_concept_id, relation.target_concept_id, relation.relation_type, relation.created_at]
+          );
+        }
+        counts.skos_relations++;
+      }
+      for (const tag of parsedNoteSkosTags) {
+        await tx.query(
+          `INSERT INTO note_skos_tag (id, note_id, concept_id, created_at)
+           VALUES ($1, $2, $3, $4)
+           ON CONFLICT (note_id, concept_id) DO NOTHING`,
+          [tag.id, tag.note_id, tag.concept_id, tag.created_at]
+        );
+        counts.note_skos_tags++;
+      }
+      for (const edge of parsedProvenanceEdges) {
+        const attributes = edge.attributes === null ? null : JSON.stringify(edge.attributes);
+        if (strategy === "replace") {
+          await tx.query(
+            `INSERT INTO provenance_edge (id, entity_type, entity_id, activity, agent, started_at, ended_at, attributes)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+             ON CONFLICT (id) DO UPDATE SET entity_type = $2, entity_id = $3, activity = $4, agent = $5, started_at = $6, ended_at = $7, attributes = $8`,
+            [edge.id, edge.entity_type, edge.entity_id, edge.activity, edge.agent, edge.started_at, edge.ended_at, attributes]
+          );
+        } else {
+          await tx.query(
+            `INSERT INTO provenance_edge (id, entity_type, entity_id, activity, agent, started_at, ended_at, attributes)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8) ${conflictClause}`,
+            [edge.id, edge.entity_type, edge.entity_id, edge.activity, edge.agent, edge.started_at, edge.ended_at, attributes]
+          );
+        }
+        counts.provenance_edges++;
+      }
       for (const shardSet of parsedEmbSets) {
         const set = embeddingSetFromShard(shardSet);
         if (strategy === "replace") {
           await tx.query(
-            `INSERT INTO embedding_set (id, model_name, dimensions, created_at)
-             VALUES ($1, $2, $3, $4)
-             ON CONFLICT (id) DO UPDATE SET model_name = $2, dimensions = $3`,
-            [set.id, set.model_name, set.dimensions, set.created_at]
+            `INSERT INTO embedding_set (
+               id, name, purpose, model_name, dimensions, kind, mode, truncate_dimension,
+               criteria_json, source_json, compatibility_json, materialization_json, freshness_json, created_at, updated_at
+             ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::jsonb, $10::jsonb, $11::jsonb, $12::jsonb, $13::jsonb, $14, COALESCE($15::timestamptz, $14::timestamptz))
+             ON CONFLICT (id) DO UPDATE SET name = $2, purpose = $3, model_name = $4, dimensions = $5,
+               kind = $6, mode = $7, truncate_dimension = $8, criteria_json = $9::jsonb, source_json = $10::jsonb,
+               compatibility_json = $11::jsonb, materialization_json = $12::jsonb, freshness_json = $13::jsonb, updated_at = COALESCE($15::timestamptz, $14::timestamptz)`,
+            [set.id, set.name, set.purpose, set.model_name, set.dimensions, set.kind, set.mode, set.truncate_dimension, set.criteria_json, set.source_json, set.compatibility_json, set.materialization_json, set.freshness_json, set.created_at, set.updated_at]
           );
         } else {
           await tx.query(
-            `INSERT INTO embedding_set (id, model_name, dimensions, created_at)
-             VALUES ($1, $2, $3, $4) ${conflictClause}`,
-            [set.id, set.model_name, set.dimensions, set.created_at]
+            `INSERT INTO embedding_set (
+               id, name, purpose, model_name, dimensions, kind, mode, truncate_dimension,
+               criteria_json, source_json, compatibility_json, materialization_json, freshness_json, created_at, updated_at
+             ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::jsonb, $10::jsonb, $11::jsonb, $12::jsonb, $13::jsonb, $14, COALESCE($15::timestamptz, $14::timestamptz)) ${conflictClause}`,
+            [set.id, set.name, set.purpose, set.model_name, set.dimensions, set.kind, set.mode, set.truncate_dimension, set.criteria_json, set.source_json, set.compatibility_json, set.materialization_json, set.freshness_json, set.created_at, set.updated_at]
           );
         }
         counts.embedding_sets++;
@@ -5092,6 +6296,60 @@ async function importShard(db, data, options) {
         }
         counts.embeddings++;
       }
+      for (const source of parsedGraphSources) {
+        const parameters = source.parameters == null ? null : JSON.stringify(source.parameters);
+        const freshness = JSON.stringify({ ...source.freshness ?? {}, status: "unknown" });
+        await tx.query(
+          `INSERT INTO graph_source (
+             id, name, kind, source_table, embedding_set_id, virtual_set_id, model, dimension,
+             truncate_dimension, metric, algorithm, parameters_json, input_hash, freshness_json, created_at
+           ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12::jsonb, $13, $14::jsonb, $15)
+           ${strategy === "replace" ? "ON CONFLICT (id) DO UPDATE SET name = $2, kind = $3, source_table = $4, embedding_set_id = $5, virtual_set_id = $6, model = $7, dimension = $8, truncate_dimension = $9, metric = $10, algorithm = $11, parameters_json = $12::jsonb, input_hash = $13, freshness_json = $14::jsonb, created_at = $15" : conflictClause}`,
+          [source.id, source.name, source.kind, source.source_table ?? null, source.embedding_set_id ?? null, source.virtual_set_id ?? null, source.model ?? null, source.dimension ?? null, source.truncate_dimension ?? null, source.metric ?? null, source.algorithm ?? null, parameters, source.input_hash, freshness, source.created_at]
+        );
+        counts.graph_sources++;
+      }
+      for (const edge of parsedGraphEdges) {
+        const metadata = edge.metadata == null ? null : JSON.stringify(edge.metadata);
+        await tx.query(
+          `INSERT INTO graph_edge_artifact (graph_source_id, from_note_id, to_note_id, weight, kind, rank, metadata_json)
+           VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)
+           ${strategy === "replace" ? "ON CONFLICT (graph_source_id, from_note_id, to_note_id, kind) DO UPDATE SET weight = $4, rank = $6, metadata_json = $7::jsonb" : conflictClause}`,
+          [edge.graph_source_id, edge.from_note_id, edge.to_note_id, edge.weight, edge.kind, edge.rank ?? null, metadata]
+        );
+        counts.graph_edges++;
+      }
+      for (const set of parsedCommunitySets) {
+        const parameters = set.parameters == null ? null : JSON.stringify(set.parameters);
+        const freshness = JSON.stringify({ ...set.freshness ?? {}, status: "unknown" });
+        await tx.query(
+          `INSERT INTO community_set (id, graph_source_id, name, source_type, algorithm, parameters_json, input_hash, freshness_json, created_at)
+           VALUES ($1, $2, $3, $4, $5, $6::jsonb, $7, $8::jsonb, $9)
+           ${strategy === "replace" ? "ON CONFLICT (id) DO UPDATE SET graph_source_id = $2, name = $3, source_type = $4, algorithm = $5, parameters_json = $6::jsonb, input_hash = $7, freshness_json = $8::jsonb, created_at = $9" : conflictClause}`,
+          [set.id, set.graph_source_id, set.name, set.source_type, set.algorithm ?? null, parameters, set.input_hash, freshness, set.created_at]
+        );
+        counts.community_sets++;
+        for (const community of set.communities ?? []) {
+          const metadata = community.metadata == null ? null : JSON.stringify(community.metadata);
+          await tx.query(
+            `INSERT INTO community (community_set_id, id, label, rank, size, confidence, representative_note_ids, metadata_json)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb)
+             ${strategy === "replace" ? "ON CONFLICT (community_set_id, id) DO UPDATE SET label = $3, rank = $4, size = $5, confidence = $6, representative_note_ids = $7, metadata_json = $8::jsonb" : conflictClause}`,
+            [set.id, community.id, community.label ?? null, community.rank ?? null, community.size ?? null, community.confidence ?? null, community.representative_note_ids ?? [], metadata]
+          );
+          counts.communities++;
+        }
+      }
+      for (const assignment of parsedCommunityAssignments) {
+        const metadata = assignment.metadata == null ? null : JSON.stringify(assignment.metadata);
+        await tx.query(
+          `INSERT INTO community_assignment (community_set_id, community_id, note_id, confidence, source_type, metadata_json)
+           VALUES ($1, $2, $3, $4, $5, $6::jsonb)
+           ${strategy === "replace" ? "ON CONFLICT (community_set_id, note_id) DO UPDATE SET community_id = $2, confidence = $4, source_type = $5, metadata_json = $6::jsonb" : conflictClause}`,
+          [assignment.community_set_id, assignment.community_id, assignment.note_id, assignment.confidence ?? null, assignment.source_type, metadata]
+        );
+        counts.community_assignments++;
+      }
       for (const member of parsedEmbMembers) {
         await tx.query(
           `INSERT INTO embedding_set_member (embedding_set_id, note_id, embedding_id)
@@ -5131,8 +6389,8 @@ function parseJsonArray(data) {
 }
 
 // src/index.ts
-var VERSION = "2026.5.2";
+var VERSION = "2026.5.4";
 
-export { ArchiveManager, AttachmentsRepository, CURRENT_SHARD_VERSION, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, FallbackRouter, FortemiToolManifest, GetNoteInputSchema, JOB_CAPABILITIES, JOB_PRIORITIES, JobQueueWorker, LOCAL_ENDPOINTS, LinksRepository, ListNotesInputSchema, ManageArchiveInputSchema, ManageAttachmentsInputSchema, ManageCapabilitiesInputSchema, ManageCollectionsInputSchema, ManageLinksInputSchema, ManageNoteInputSchema, ManageTagsInputSchema, MemoryBlobStore, MigrationRunner, NotesRepository, OpenAICompatibleProvider, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, ProviderRegistry, SHARD_FORMAT, SearchInputSchema, SearchRepository, SkosRepository, TagsRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, allMigrations, appendPluginScript, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, collectionFromShard, collectionToShard, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createBlobStore, createCspReportHandler, createFortemi, createLegacyProvider, createPGliteInstance, createRoutes, defaultStorageBackendFactory, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchPluginScript, fortemiManifest, generateId, getEmbedFunction, getJobQueueStatus, getLlmFunction, getNote, importShard, isPluginScriptAllowed, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, noteFromShard, noteToShard, packTarGz, parseCspReport, registerLlmCapability, registerSemanticCapability, registerServiceWorker, searchTool, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, suggestTags, tagsFromShard, tagsToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, validateChecksums, verifySri };
+export { ArchiveManager, AttachmentsRepository, CURRENT_SHARD_VERSION, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, CommunitiesRepository, EmbeddingSetsRepository, FallbackRouter, FortemiToolManifest, GetNoteInputSchema, GraphRepository, JOB_CAPABILITIES, JOB_PRIORITIES, JobQueueWorker, LOCAL_ENDPOINTS, LinksRepository, ListNotesInputSchema, ManageArchiveInputSchema, ManageAttachmentsInputSchema, ManageCapabilitiesInputSchema, ManageCollectionsInputSchema, ManageLinksInputSchema, ManageNoteInputSchema, ManageTagsInputSchema, MemoryBlobStore, MigrationRunner, NotesRepository, OpenAICompatibleProvider, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, ProviderRegistry, SHARD_FORMAT, SearchInputSchema, SearchRepository, SkosRepository, TagsRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, allMigrations, appendPluginScript, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, collectionFromShard, collectionToShard, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createBlobStore, createCspReportHandler, createFortemi, createLegacyProvider, createPGliteInstance, createRoutes, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchPluginScript, fortemiManifest, generateId, getEmbedFunction, getJobQueueStatus, getLlmFunction, getNote, importShard, isPluginScriptAllowed, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, noteFromShard, noteSkosTagToShard, noteToShard, packTarGz, parseCspReport, provenanceEdgeToShard, registerLlmCapability, registerSemanticCapability, registerServiceWorker, searchTool, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsFromShard, tagsToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, validateChecksums, verifySri };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map