@fortemi/core 2026.5.3 → 2026.6.0

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) {
@@ -2056,12 +2953,12 @@ var JobQueueWorker = class {
       if (job.required_capability) {
         const capName = job.required_capability;
         if (!this.capabilityManager?.isReady(capName)) {
-          console.log(`[JobQueue] Skipping ${job.job_type} \u2014 capability '${capName}' not ready`);
+          await this.blockForCapability(job, capName);
           continue;
         }
       }
       await this.db.query(
-        `UPDATE job_queue SET status = 'processing', updated_at = now() WHERE id = $1`,
+        `UPDATE job_queue SET status = 'processing', error = NULL, updated_at = now() WHERE id = $1`,
         [job.id]
       );
       try {
@@ -2069,7 +2966,7 @@ var JobQueueWorker = class {
         const jobResult = await handler(job, this.db);
         console.log(`[JobQueue] Completed ${job.job_type}:`, jobResult);
         await this.db.query(
-          `UPDATE job_queue SET status = 'completed', result = $1, updated_at = now() WHERE id = $2`,
+          `UPDATE job_queue SET status = 'completed', error = NULL, result = $1, updated_at = now() WHERE id = $2`,
           [JSON.stringify(jobResult ?? null), job.id]
         );
         this.events?.emit("job.completed", {
@@ -2103,6 +3000,30 @@ var JobQueueWorker = class {
     }
     return processed;
   }
+  async blockForCapability(job, capability) {
+    const message = `requires capability '${capability}' \u2014 not ready`;
+    console.log(`[JobQueue] Deferring ${job.job_type} \u2014 ${message}`);
+    await this.db.query(
+      `UPDATE job_queue
+       SET status = 'pending', error = $1, updated_at = now()
+       WHERE id = $2 AND error IS DISTINCT FROM $1`,
+      [message, job.id]
+    );
+    this.events?.emit("job.blocked", {
+      id: job.id,
+      noteId: job.note_id,
+      type: job.job_type,
+      capability,
+      message
+    });
+    this.events?.emit("capability.required", {
+      name: capability,
+      jobId: job.id,
+      noteId: job.note_id,
+      type: job.job_type,
+      message
+    });
+  }
   getBackoffDelay(retryCount) {
     const delay = this.options.backoffBaseMs * Math.pow(2, retryCount);
     return Math.min(delay, this.options.backoffMaxMs);
@@ -3475,19 +4396,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 +4423,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 +5319,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 +5542,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 +5602,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 +5659,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 +5791,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 +5843,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 +5961,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 +6044,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 +6063,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 +6181,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 +6234,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 +6320,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)
@@ -5130,9 +6412,144 @@ function parseJsonArray(data) {
   return JSON.parse(decoder.decode(data));
 }
 
+// src/aiwg-index.ts
+var REQUIRED_RECORD_FIELDS = [
+  "schema_version",
+  "id",
+  "type",
+  "source",
+  "title",
+  "text",
+  "facets",
+  "tags",
+  "concepts",
+  "relationships",
+  "provenance",
+  "privacy",
+  "updated_at"
+];
+var VALID_TYPES = /* @__PURE__ */ new Set([
+  "crm.contact",
+  "crm.organization",
+  "crm.event",
+  "crm.interaction",
+  "aiwg.artifact"
+]);
+function hasString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function pushFacet(counts, name, value) {
+  counts[name] ??= {};
+  counts[name][value] = (counts[name][value] ?? 0) + 1;
+}
+function validateAiwgFortemiIndexExport(value) {
+  const errors = [];
+  const counts = {};
+  const data = value;
+  if (data?.schema_version !== "aiwg.fortemi.index.export.v1") {
+    errors.push("schema_version must be aiwg.fortemi.index.export.v1");
+  }
+  if (!hasString(data?.generated_at)) errors.push("generated_at is required");
+  if (!hasString(data?.source?.repo)) errors.push("source.repo is required");
+  if (!hasString(data?.source?.privacy)) errors.push("source.privacy is required");
+  if (!Array.isArray(data?.items)) errors.push("items must be an array");
+  const ids = /* @__PURE__ */ new Set();
+  let previousId = "";
+  for (const [index, item] of (data.items ?? []).entries()) {
+    for (const field of REQUIRED_RECORD_FIELDS) {
+      if (!(field in item)) errors.push("items[" + index + "]." + field + " is required");
+    }
+    if (item.schema_version !== "aiwg.fortemi.index.record.v1") {
+      errors.push("items[" + index + "].schema_version must be aiwg.fortemi.index.record.v1");
+    }
+    if (!hasString(item.id)) errors.push("items[" + index + "].id is required");
+    if (hasString(item.id) && ids.has(item.id)) errors.push("duplicate id: " + item.id);
+    if (hasString(item.id)) ids.add(item.id);
+    if (previousId && hasString(item.id) && previousId.localeCompare(item.id) > 0) {
+      errors.push("items must be sorted by id: " + previousId + " before " + item.id);
+    }
+    if (hasString(item.id)) previousId = item.id;
+    if (!VALID_TYPES.has(item.type)) errors.push("items[" + index + "].type is invalid");
+    else counts[item.type] = (counts[item.type] ?? 0) + 1;
+    if (!hasString(item.source?.path)) errors.push("items[" + index + "].source.path is required");
+    if (!hasString(item.source?.repo_relative_path)) errors.push("items[" + index + "].source.repo_relative_path is required");
+    if (!hasString(item.source?.locator)) errors.push("items[" + index + "].source.locator is required");
+    if (!Array.isArray(item.tags)) errors.push("items[" + index + "].tags must be an array");
+    if (!Array.isArray(item.concepts)) errors.push("items[" + index + "].concepts must be an array");
+    if (!Array.isArray(item.relationships)) errors.push("items[" + index + "].relationships must be an array");
+    if (!Array.isArray(item.provenance) || item.provenance.length === 0) {
+      errors.push("items[" + index + "].provenance must be a non-empty array");
+    }
+    if (!item.privacy || typeof item.privacy.pii !== "boolean" || !hasString(item.privacy.classification)) {
+      errors.push("items[" + index + "].privacy requires classification and pii");
+    }
+  }
+  return { valid: errors.length === 0, errors, counts };
+}
+function assertAiwgFortemiIndexExport(value) {
+  const result = validateAiwgFortemiIndexExport(value);
+  if (!result.valid) {
+    throw new Error("Invalid AIWG Fortemi index export:\n" + result.errors.join("\n"));
+  }
+  return value;
+}
+function getAiwgFortemiFacets(items) {
+  const result = {};
+  for (const item of items) {
+    pushFacet(result, "type", item.type);
+    pushFacet(result, "privacy", item.privacy.classification);
+    for (const tag of item.tags) pushFacet(result, "tag", tag);
+    for (const concept of item.concepts) pushFacet(result, "concept", concept);
+    for (const [name, values] of Object.entries(item.facets)) {
+      for (const value of values) pushFacet(result, name, value);
+    }
+  }
+  return result;
+}
+function includesAll(actual, expected) {
+  if (!expected || expected.length === 0) return true;
+  const actualSet = new Set(actual);
+  return expected.every((value) => actualSet.has(value));
+}
+function matchesFacetFilters(item, filters) {
+  if (!filters) return true;
+  return Object.entries(filters).every(([name, expected]) => includesAll(item.facets[name] ?? [], expected));
+}
+function queryAiwgFortemiIndex(index, query = "", options = {}) {
+  const q = query.trim().toLowerCase();
+  const filtered = index.items.filter((item) => {
+    if (q) {
+      const haystack = [item.title, item.text, ...item.tags, ...item.concepts].join("\n").toLowerCase();
+      if (!haystack.includes(q)) return false;
+    }
+    if (options.types && !options.types.includes(item.type)) return false;
+    if (options.privacy && !options.privacy.includes(item.privacy.classification)) return false;
+    if (!includesAll(item.tags, options.tags)) return false;
+    if (!includesAll(item.concepts, options.concepts)) return false;
+    if (!matchesFacetFilters(item, options.facets)) return false;
+    if (options.relationshipTargetId && !item.relationships.some((rel) => rel.target_id === options.relationshipTargetId)) return false;
+    return true;
+  });
+  const offset = options.offset ?? 0;
+  const limit = options.limit ?? filtered.length;
+  return {
+    items: filtered.slice(offset, offset + limit),
+    total: filtered.length,
+    facets: getAiwgFortemiFacets(filtered)
+  };
+}
+function createAiwgReviewDecisionExport(source, decisions, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    schema_version: "aiwg.fortemi.review-decisions.v1",
+    generated_at: generatedAt,
+    source_export_schema_version: source.schema_version,
+    decisions: [...decisions].sort((left, right) => left.item_id.localeCompare(right.item_id))
+  };
+}
+
 // src/index.ts
-var VERSION = "2026.5.3";
+var VERSION = "2026.6.0";
 
-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, assertAiwgFortemiIndexExport, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, collectionFromShard, collectionToShard, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createAiwgReviewDecisionExport, 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, getAiwgFortemiFacets, getEmbedFunction, getJobQueueStatus, getLlmFunction, getNote, importShard, isPluginScriptAllowed, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, noteFromShard, noteSkosTagToShard, noteToShard, packTarGz, parseCspReport, provenanceEdgeToShard, queryAiwgFortemiIndex, registerLlmCapability, registerSemanticCapability, registerServiceWorker, searchTool, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsFromShard, tagsToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, validateAiwgFortemiIndexExport, validateChecksums, verifySri };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map