@fortemi/core 2026.6.4 → 2026.6.5

package/dist/index.js

@@ -135,406 +135,63 @@ function getDataDir(persistence, archiveName) {
       return void 0;
   }
 }
-async function createPGliteInstance(persistence, archiveName = "default") {
+async function createPGliteInstance(persistence, archiveName = "default", options = {}) {
   const dataDir = getDataDir(persistence, archiveName);
-  const options = {
+  const pgliteOptions = {
     database: "postgres",
     // PGlite 0.4.x breaking change: explicit required
     extensions: { vector }
   };
   if (dataDir) {
-    options.dataDir = dataDir;
+    pgliteOptions.dataDir = dataDir;
   }
-  const db = await PGlite.create(options);
+  if (options.loadDataDir) {
+    pgliteOptions.loadDataDir = options.loadDataDir;
+  }
+  const db = await PGlite.create(pgliteOptions);
   await db.exec("CREATE EXTENSION IF NOT EXISTS vector");
   return db;
 }
 
-// src/worker/worker-client.ts
-var PGliteWorkerClient = class {
-  constructor(worker) {
-    this.worker = worker;
-    this.readyPromise = new Promise((resolve) => {
-      this.resolveReady = resolve;
-    });
-    this.worker.addEventListener("message", (e) => {
-      const msg = e.data;
-      if (msg.type === "READY") {
-        this.resolveReady();
-        return;
-      }
-      if (!("id" in msg)) return;
-      const pending = this.pending.get(msg.id);
-      if (!pending) return;
-      this.pending.delete(msg.id);
-      if (msg.type === "ERROR") {
-        pending.reject(new Error(msg.error));
-      } else {
-        pending.resolve(msg);
-      }
-    });
-  }
-  pending = /* @__PURE__ */ new Map();
-  readyPromise;
-  resolveReady;
-  /** Resolves when the worker broadcasts READY after database initialisation. */
-  async waitReady() {
-    return this.readyPromise;
-  }
-  send(request) {
-    const id = generateId();
-    return new Promise((resolve, reject) => {
-      this.pending.set(id, {
-        resolve,
-        reject
-      });
-      this.worker.postMessage({ ...request, id });
-    });
-  }
-  async query(sql, params) {
-    const resp = await this.send({ type: "QUERY", sql, params });
-    return { rows: resp.rows, fields: resp.fields };
-  }
-  async exec(sql) {
-    await this.send({ type: "EXEC", sql });
-  }
-  async transaction(fn) {
-    const resp = await this.send({ type: "BEGIN" });
-    const txId = resp.txId;
-    const proxy = new TransactionProxy(this, txId);
-    try {
-      const result = await fn(proxy);
-      await this.send({ type: "COMMIT", txId });
-      return result;
-    } catch (err) {
-      await this.send({ type: "ROLLBACK", txId }).catch(() => {
-      });
-      throw err;
-    }
-  }
-  /** Forward TX_QUERY for TransactionProxy — not part of the public surface. */
-  async _txQuery(txId, sql, params) {
-    const resp = await this.send({
-      type: "TX_QUERY",
-      txId,
-      sql,
-      params
-    });
-    return { rows: resp.rows };
-  }
-  /** Forward TX_EXEC for TransactionProxy — not part of the public surface. */
-  async _txExec(txId, sql) {
-    await this.send({ type: "TX_EXEC", txId, sql });
-  }
-  async ping() {
-    await this.send({ type: "PING" });
-  }
-  async close() {
-    await this.send({ type: "CLOSE" });
-    this.worker.terminate();
-  }
-};
-var TransactionProxy = class {
-  constructor(client, txId) {
-    this.client = client;
-    this.txId = txId;
-  }
-  async query(sql, params) {
-    return this.client._txQuery(this.txId, sql, params);
-  }
-  async exec(sql) {
-    return this.client._txExec(this.txId, sql);
-  }
-};
+// src/migrations/0001_initial_schema.ts
+var migration0001 = {
+  version: 1,
+  name: "0001_initial_schema",
+  sql: `
+    -- Archive (multi-database tracking)
+    CREATE TABLE IF NOT EXISTS archive (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      schema_version INTEGER NOT NULL DEFAULT 0,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+    );
 
-// src/storage-backend.ts
-var PGliteStorageBackend = class {
-  constructor(id, db) {
-    this.id = id;
-    this.db = db;
-  }
-  mode = "readwrite";
-  query(sql, params) {
-    return this.db.query(sql, params);
-  }
-  exec(sql) {
-    return this.db.exec(sql);
-  }
-  async transaction(fn) {
-    return this.db.transaction((tx) => fn(tx));
-  }
-  close() {
-    return this.db.close();
-  }
-};
-var PGliteStorageBackendFactory = class {
-  async open(input) {
-    const db = await createPGliteInstance(input.persistence, input.archiveName);
-    return new PGliteStorageBackend(`pglite:${input.persistence}:${input.archiveName}`, db);
-  }
-};
-var defaultStorageBackendFactory = new PGliteStorageBackendFactory();
-var PGliteWorkerStorageBackend = class {
-  constructor(id, client) {
-    this.id = id;
-    this.client = client;
-  }
-  mode = "readwrite";
-  query(sql, params) {
-    return this.client.query(sql, params);
-  }
-  exec(sql) {
-    return this.client.exec(sql);
-  }
-  transaction(fn) {
-    return this.client.transaction(fn);
-  }
-  close() {
-    return this.client.close();
-  }
-};
-var PGliteWorkerStorageBackendFactory = class {
-  constructor(options) {
-    this.options = options;
-  }
-  async open(input) {
-    const worker = this.options.createWorker();
-    const client = new PGliteWorkerClient(worker);
-    worker.postMessage({
-      type: "INIT",
-      persistence: input.persistence,
-      archiveName: input.archiveName
-    });
-    await client.waitReady();
-    return new PGliteWorkerStorageBackend(`pglite-worker:${input.persistence}:${input.archiveName}`, client);
-  }
-};
+    -- Note (core entity)
+    CREATE TABLE IF NOT EXISTS note (
+      id TEXT PRIMARY KEY,
+      archive_id TEXT REFERENCES archive(id),
+      title TEXT,
+      format TEXT NOT NULL DEFAULT 'markdown',
+      source TEXT NOT NULL DEFAULT 'user',
+      visibility TEXT NOT NULL DEFAULT 'private',
+      revision_mode TEXT NOT NULL DEFAULT 'standard',
+      is_starred BOOLEAN NOT NULL DEFAULT false,
+      is_pinned BOOLEAN NOT NULL DEFAULT false,
+      is_archived BOOLEAN NOT NULL DEFAULT false,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      deleted_at TIMESTAMPTZ,
+      tsv tsvector GENERATED ALWAYS AS (to_tsvector('english', coalesce(title, ''))) STORED
+    );
 
-// src/capability-manager.ts
-var VALID_TRANSITIONS = {
-  enable: ["unloaded", "disabled", "error"],
-  disable: ["ready"],
-  markReady: ["loading"],
-  markError: ["loading"]
-};
-function assertTransition(method, name, current) {
-  const allowed = VALID_TRANSITIONS[method];
-  if (!allowed.includes(current)) {
-    throw new Error(
-      `CapabilityManager.${method}('${name}'): invalid transition from state '${current}'. Allowed source states: ${allowed.join(", ")}.`
-    );
-  }
-}
-var CapabilityManager = class {
-  constructor(events) {
-    this.events = events;
-    const names = ["semantic", "llm", "audio", "vision", "pdf"];
-    for (const name of names) {
-      this.capabilities.set(name, { name, state: "unloaded" });
-    }
-  }
-  capabilities = /* @__PURE__ */ new Map();
-  loaders = /* @__PURE__ */ new Map();
-  progressMessages = /* @__PURE__ */ new Map();
-  /**
-   * Register an async loader for a capability.
-   * Called by enable(); if no loader is registered the capability transitions
-   * directly to ready (useful for capabilities that require no async init).
-   */
-  registerLoader(name, loader) {
-    this.loaders.set(name, loader);
-  }
-  getState(name) {
-    return this.capabilities.get(name)?.state ?? "unloaded";
-  }
-  isReady(name) {
-    return this.getState(name) === "ready";
-  }
-  /**
-   * Enable a capability.
-   * Valid from: unloaded, disabled, error (retry).
-   * Runs the registered loader if present; transitions to ready on success,
-   * error on failure.
-   */
-  async enable(name) {
-    const entry = this.capabilities.get(name);
-    if (!entry) return;
-    if (entry.state === "ready" || entry.state === "loading") return;
-    assertTransition("enable", name, entry.state);
-    entry.state = "loading";
-    entry.error = void 0;
-    this.events.emit("capability.loading", { name });
-    const loader = this.loaders.get(name);
-    if (!loader) {
-      entry.state = "ready";
-      this.events.emit("capability.ready", { name });
-      return;
-    }
-    try {
-      await loader();
-      if (entry.state === "loading") {
-        entry.state = "ready";
-        this.events.emit("capability.ready", { name });
-      }
-    } catch (err) {
-      if (entry.state === "loading") {
-        const message = err instanceof Error ? err.message : String(err);
-        entry.state = "error";
-        entry.error = message;
-      }
-    }
-  }
-  /**
-   * Disable a ready capability.
-   * Valid from: ready only.
-   */
-  disable(name) {
-    const entry = this.capabilities.get(name);
-    if (!entry) return;
-    assertTransition("disable", name, entry.state);
-    entry.state = "disabled";
-    this.events.emit("capability.disabled", { name });
-  }
-  /**
-   * Mark a loading capability as ready (external use, e.g. bridge protocol).
-   * Valid from: loading only.
-   */
-  markReady(name) {
-    const entry = this.capabilities.get(name);
-    if (!entry) return;
-    assertTransition("markReady", name, entry.state);
-    entry.state = "ready";
-    entry.error = void 0;
-    this.events.emit("capability.ready", { name });
-  }
-  /**
-   * Mark a loading capability as errored (external use, e.g. bridge protocol).
-   * Valid from: loading only.
-   */
-  markError(name, error) {
-    const entry = this.capabilities.get(name);
-    if (!entry) return;
-    assertTransition("markError", name, entry.state);
-    entry.state = "error";
-    entry.error = error;
-  }
-  /**
-   * Report loading progress (0-100).
-   * Emits capability.loading with progress if the capability is currently loading.
-   * No-op if the capability is not in loading state.
-   */
-  reportProgress(name, progress) {
-    const entry = this.capabilities.get(name);
-    if (!entry || entry.state !== "loading") return;
-    this.events.emit("capability.loading", { name, progress });
-  }
-  /** Set a human-readable progress message for a loading capability */
-  setProgress(name, message) {
-    this.progressMessages.set(name, message);
-    this.events.emit("capability.loading", { name, progress: -1 });
-  }
-  /** Get the current progress message for a capability */
-  getProgress(name) {
-    return this.progressMessages.get(name);
-  }
-  getError(name) {
-    return this.capabilities.get(name)?.error;
-  }
-  listAll() {
-    return Array.from(this.capabilities.values()).map(({ name, state }) => ({
-      name,
-      state
-    }));
-  }
-};
-
-// src/migration-runner.ts
-var MigrationRunner = class {
-  constructor(db, events) {
-    this.db = db;
-    this.events = events;
-  }
-  async ensureSchemaTable() {
-    await this.db.exec(`
-      CREATE TABLE IF NOT EXISTS schema_version (
-        version INTEGER NOT NULL,
-        name TEXT NOT NULL,
-        applied_at TIMESTAMPTZ DEFAULT now(),
-        PRIMARY KEY (version)
-      )
-    `);
-  }
-  async getCurrentVersion() {
-    const result = await this.db.query(
-      "SELECT COALESCE(MAX(version), 0) AS version FROM schema_version"
-    );
-    return result.rows[0].version;
-  }
-  async apply(migrations) {
-    await this.ensureSchemaTable();
-    const currentVersion = await this.getCurrentVersion();
-    const pending = migrations.filter((m) => m.version > currentVersion).sort((a, b) => a.version - b.version);
-    let applied = 0;
-    for (const migration of pending) {
-      await this.db.transaction(async (tx) => {
-        await tx.exec(migration.sql);
-        await tx.query(
-          "INSERT INTO schema_version (version, name) VALUES ($1, $2)",
-          [migration.version, migration.name]
-        );
-      });
-      applied++;
-      this.events?.emit("migration.applied", { version: migration.version });
-    }
-    return applied;
-  }
-  async getAppliedMigrations() {
-    const result = await this.db.query(
-      "SELECT version, name FROM schema_version ORDER BY version"
-    );
-    return result.rows;
-  }
-};
-
-// src/migrations/0001_initial_schema.ts
-var migration0001 = {
-  version: 1,
-  name: "0001_initial_schema",
-  sql: `
-    -- Archive (multi-database tracking)
-    CREATE TABLE IF NOT EXISTS archive (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL UNIQUE,
-      schema_version INTEGER NOT NULL DEFAULT 0,
-      created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-      updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-    );
-
-    -- Note (core entity)
-    CREATE TABLE IF NOT EXISTS note (
-      id TEXT PRIMARY KEY,
-      archive_id TEXT REFERENCES archive(id),
-      title TEXT,
-      format TEXT NOT NULL DEFAULT 'markdown',
-      source TEXT NOT NULL DEFAULT 'user',
-      visibility TEXT NOT NULL DEFAULT 'private',
-      revision_mode TEXT NOT NULL DEFAULT 'standard',
-      is_starred BOOLEAN NOT NULL DEFAULT false,
-      is_pinned BOOLEAN NOT NULL DEFAULT false,
-      is_archived BOOLEAN NOT NULL DEFAULT false,
-      created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-      updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-      deleted_at TIMESTAMPTZ,
-      tsv tsvector GENERATED ALWAYS AS (to_tsvector('english', coalesce(title, ''))) STORED
-    );
-
-    -- Note original content (immutable)
-    CREATE TABLE IF NOT EXISTS note_original (
-      id TEXT PRIMARY KEY,
-      note_id TEXT NOT NULL REFERENCES note(id),
-      content TEXT NOT NULL,
-      content_hash TEXT NOT NULL,
-      created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+    -- Note original content (immutable)
+    CREATE TABLE IF NOT EXISTS note_original (
+      id TEXT PRIMARY KEY,
+      note_id TEXT NOT NULL REFERENCES note(id),
+      content TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now()
     );
 
     -- Note revised current (mutable, latest revision)
@@ -952,1196 +609,931 @@ var allMigrations = [
   migration0009
 ];
 
-// src/archive-manager.ts
-var ArchiveManager = class {
-  constructor(persistenceOrFactory, events, persistenceOverride) {
-    this.events = events;
-    if (typeof persistenceOrFactory === "string") {
-      this.persistence = persistenceOrFactory;
-      this.backendFactory = defaultStorageBackendFactory;
-    } else {
-      this.persistence = persistenceOverride ?? "memory";
-      this.backendFactory = persistenceOrFactory;
-    }
-    this.archives.set("default", {
-      name: "default",
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  currentArchive = "default";
-  db = null;
-  archives = /* @__PURE__ */ new Map();
-  persistence;
-  backendFactory;
-  getCurrentArchiveName() {
-    return this.currentArchive;
-  }
-  getDb() {
-    return this.db;
+// src/data-archive.ts
+var DB_SNAPSHOT_SCHEMA_VERSION = "fortemi.db-snapshot.v1";
+var SUPPORTED_PGLITE_VERSION = "0.4.1";
+var CURRENT_MIGRATION_HEAD = allMigrations.reduce(
+  (head, migration) => Math.max(head, migration.version),
+  0
+);
+async function readMigrationHead(db) {
+  try {
+    const result = await db.query(
+      "SELECT COALESCE(MAX(version), 0) AS head FROM schema_version"
+    );
+    return Number(result.rows[0]?.head ?? 0);
+  } catch {
+    return 0;
   }
-  async open(archiveName = "default") {
-    if (this.db) {
-      await this.db.close();
-    }
-    this.db = await this.backendFactory.open({
-      archiveName,
-      persistence: this.persistence
-    });
-    const runner = new MigrationRunner(this.db, this.events);
-    await runner.apply(allMigrations);
-    this.currentArchive = archiveName;
-    if (!this.archives.has(archiveName)) {
-      this.archives.set(archiveName, {
-        name: archiveName,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-    this.events?.emit("archive.switched", { name: archiveName });
-    return this.db;
+}
+async function readPgvectorVersion(db) {
+  try {
+    const result = await db.query(
+      "SELECT extversion FROM pg_extension WHERE extname = 'vector'"
+    );
+    return result.rows[0]?.extversion ?? null;
+  } catch {
+    return null;
   }
-  async create(archiveName) {
-    if (this.archives.has(archiveName)) {
-      throw new Error(`Archive '${archiveName}' already exists`);
-    }
-    return this.open(archiveName);
+}
+async function dumpDbSnapshot(db, options = {}) {
+  const migration_head = await readMigrationHead(db);
+  const pgvector_version = await readPgvectorVersion(db);
+  const data = await db.dumpDataDir(options.compression ?? "gzip");
+  const meta = {
+    schema_version: DB_SNAPSHOT_SCHEMA_VERSION,
+    pglite_version: SUPPORTED_PGLITE_VERSION,
+    pgvector_version,
+    migration_head,
+    created_at: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    ...options.fortemiVersion ? { fortemi_version: options.fortemiVersion } : {}
+  };
+  return { data, meta };
+}
+function majorMinor(version) {
+  const parts = version.split(".");
+  return `${parts[0] ?? "0"}.${parts[1] ?? "0"}`;
+}
+function verifyDbSnapshotMeta(meta, expected = {}) {
+  const reasons = [];
+  const warnings = [];
+  const expectedHead = expected.migrationHead ?? CURRENT_MIGRATION_HEAD;
+  const expectedPglite = expected.pgliteVersion ?? SUPPORTED_PGLITE_VERSION;
+  if (meta.schema_version !== DB_SNAPSHOT_SCHEMA_VERSION) {
+    reasons.push(`unsupported snapshot schema_version: ${String(meta.schema_version)}`);
   }
-  async switchTo(archiveName) {
-    return this.open(archiveName);
+  if (meta.migration_head !== expectedHead) {
+    reasons.push(`migration head mismatch: snapshot=${meta.migration_head}, supported=${expectedHead}`);
   }
-  async delete(archiveName) {
-    if (archiveName === "default") {
-      throw new Error("Cannot delete the default archive");
-    }
-    if (this.currentArchive === archiveName && this.db) {
-      await this.db.close();
-      this.db = null;
-    }
-    this.archives.delete(archiveName);
+  if (majorMinor(meta.pglite_version) !== majorMinor(expectedPglite)) {
+    reasons.push(`PGlite version mismatch: snapshot=${meta.pglite_version}, supported=${expectedPglite}`);
   }
-  listArchives() {
-    return Array.from(this.archives.values());
+  if (expected.pgvectorVersion !== void 0 && meta.pgvector_version !== expected.pgvectorVersion) {
+    warnings.push(`pgvector version differs: snapshot=${String(meta.pgvector_version)}, expected=${String(expected.pgvectorVersion)}`);
   }
-  async close() {
-    if (this.db) {
-      await this.db.close();
-      this.db = null;
-    }
+  return { compatible: reasons.length === 0, reasons, warnings };
+}
+var DbSnapshotVersionError = class extends Error {
+  reasons;
+  meta;
+  constructor(reasons, meta) {
+    super(`Incompatible DB snapshot: ${reasons.join("; ")}`);
+    this.name = "DbSnapshotVersionError";
+    this.reasons = reasons;
+    this.meta = meta;
   }
 };
+function isInlineSnapshot(source) {
+  return typeof source === "object" && "data" in source && "meta" in source;
+}
+async function resolveSnapshotSource(source, fetchImpl) {
+  if (isInlineSnapshot(source)) return source;
+  const dataUrl = typeof source === "string" ? source : source.dataUrl;
+  const metaUrl = typeof source === "string" ? `${source}.meta.json` : source.metaUrl ?? `${source.dataUrl}.meta.json`;
+  const metaResponse = await fetchImpl(metaUrl);
+  if (!metaResponse.ok) {
+    throw new Error(`Failed to fetch snapshot meta (${metaResponse.status}): ${metaUrl}`);
+  }
+  const meta = await metaResponse.json();
+  const dataResponse = await fetchImpl(dataUrl);
+  if (!dataResponse.ok) {
+    throw new Error(`Failed to fetch snapshot data (${dataResponse.status}): ${dataUrl}`);
+  }
+  const data = await dataResponse.blob();
+  return { data, meta };
+}
+async function restoreDbSnapshot(source, options = {}) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const { data, meta } = await resolveSnapshotSource(source, fetchImpl);
+  const compat = verifyDbSnapshotMeta(meta, options.expectations);
+  if (!compat.compatible) {
+    throw new DbSnapshotVersionError(compat.reasons, meta);
+  }
+  const createOptions = { loadDataDir: data };
+  return createPGliteInstance(options.persistence ?? "memory", options.archiveName ?? "default", createOptions);
+}
+function computeHash(data) {
+  const digest = sha256(data);
+  return `sha256:${bytesToHex(digest)}`;
+}
 
-// src/create-fortemi.ts
-function createFortemi(config) {
-  const events = new TypedEventBus();
-  return {
-    events,
-    config,
-    destroy() {
-      events.removeAllListeners();
-    }
-  };
-}
-function computeHash(data) {
-  const digest = sha256(data);
-  return `sha256:${bytesToHex(digest)}`;
-}
-
-// src/service-worker/register.ts
-async function registerServiceWorker(swUrl = "/sw.js") {
-  if (!("serviceWorker" in navigator)) {
-    return { registered: false, error: "Service Workers not supported" };
+// src/repositories/notes-repository.ts
+var NotesRepository = class {
+  constructor(db, events) {
+    this.db = db;
+    this.events = events;
   }
-  try {
-    const registration = await navigator.serviceWorker.register(swUrl, {
-      type: "module",
-      scope: "/"
+  /**
+   * Create a new note with its original content record, current revision,
+   * optional tags, and an auto-queued title_generation job when no title
+   * is provided.
+   *
+   * All writes happen in a single transaction.
+   */
+  async create(input) {
+    const noteId = generateId();
+    const originalId = generateId();
+    const contentHash = computeHash(new TextEncoder().encode(input.content));
+    await this.db.transaction(async (tx) => {
+      await tx.query(
+        `INSERT INTO note (id, archive_id, title, format, source, visibility)
+         VALUES ($1, $2, $3, $4, $5, $6)`,
+        [
+          noteId,
+          input.archive_id ?? null,
+          input.title ?? null,
+          input.format ?? "markdown",
+          input.source ?? "user",
+          input.visibility ?? "private"
+        ]
+      );
+      await tx.query(
+        `INSERT INTO note_original (id, note_id, content, content_hash)
+         VALUES ($1, $2, $3, $4)`,
+        [originalId, noteId, input.content, contentHash]
+      );
+      await tx.query(
+        `INSERT INTO note_revised_current (note_id, content)
+         VALUES ($1, $2)`,
+        [noteId, input.content]
+      );
+      if (input.tags?.length) {
+        for (const tag of input.tags) {
+          await tx.query(
+            `INSERT INTO note_tag (id, note_id, tag) VALUES ($1, $2, $3)`,
+            [generateId(), noteId, tag]
+          );
+        }
+      }
+      await tx.query(
+        `INSERT INTO job_queue (id, note_id, job_type, status, priority, required_capability)
+         VALUES ($1, $2, 'ai_revision', 'pending', 1, 'llm')`,
+        [generateId(), noteId]
+      );
+      if (!input.title) {
+        await tx.query(
+          `INSERT INTO job_queue (id, note_id, job_type, status, priority)
+           VALUES ($1, $2, 'title_generation', 'pending', 2)`,
+          [generateId(), noteId]
+        );
+      }
+      await tx.query(
+        `INSERT INTO job_queue (id, note_id, job_type, status, priority, required_capability)
+         VALUES ($1, $2, 'embedding', 'pending', 3, 'semantic')`,
+        [generateId(), noteId]
+      );
     });
-    if (registration.installing) {
-      await new Promise((resolve) => {
-        registration.installing.addEventListener("statechange", function handler() {
-          if (this.state === "activated") {
-            this.removeEventListener("statechange", handler);
-            resolve();
-          }
-        });
-      });
+    this.events?.emit("note.created", { id: noteId });
+    return this.get(noteId);
+  }
+  /**
+   * Fetch a single note by its ID.
+   * Returns NoteFull which includes original content, current revision, and tags.
+   * Throws when the note does not exist.
+   */
+  async get(id) {
+    const noteResult = await this.db.query(
+      `SELECT n.id, n.archive_id, n.title, n.format, n.source, n.visibility,
+              n.revision_mode, n.is_starred, n.is_pinned, n.is_archived,
+              n.created_at, n.updated_at, n.deleted_at,
+              o.id         AS original_id,
+              o.content    AS original_content,
+              o.content_hash,
+              o.created_at AS original_created_at,
+              c.content    AS current_content,
+              c.ai_metadata,
+              c.generation_count,
+              c.model,
+              c.is_user_edited,
+              c.updated_at AS current_updated_at
+       FROM note n
+       LEFT JOIN note_original       o ON o.note_id = n.id
+       LEFT JOIN note_revised_current c ON c.note_id = n.id
+       WHERE n.id = $1`,
+      [id]
+    );
+    if (noteResult.rows.length === 0) {
+      throw new Error(`Note not found: ${id}`);
     }
-    return { registered: true, registration };
-  } catch (err) {
+    const row = noteResult.rows[0];
+    const tagsResult = await this.db.query(
+      `SELECT tag FROM note_tag WHERE note_id = $1 ORDER BY tag`,
+      [id]
+    );
     return {
-      registered: false,
-      error: err instanceof Error ? err.message : String(err)
+      id: row.id,
+      archive_id: row.archive_id,
+      title: row.title,
+      format: row.format,
+      source: row.source,
+      visibility: row.visibility,
+      revision_mode: row.revision_mode,
+      is_starred: row.is_starred,
+      is_pinned: row.is_pinned,
+      is_archived: row.is_archived,
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+      deleted_at: row.deleted_at,
+      tags: tagsResult.rows.map((r) => r.tag),
+      original: {
+        id: row.original_id,
+        content: row.original_content,
+        content_hash: row.content_hash,
+        created_at: row.original_created_at
+      },
+      current: {
+        content: row.current_content,
+        ai_metadata: row.ai_metadata,
+        generation_count: row.generation_count,
+        model: row.model,
+        is_user_edited: row.is_user_edited,
+        updated_at: row.current_updated_at
+      }
     };
   }
-}
-
-// src/service-worker/routes.ts
-async function parseJsonBody(request) {
-  try {
-    return await request.json();
-  } catch {
-    return null;
-  }
-}
-function jsonResponse(data, status = 200) {
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function errorResponse(message, status) {
-  return jsonResponse({ error: message }, status);
-}
-var DB_NOT_CONNECTED = "Database not connected. REST API available in standalone mode only.";
-function createRoutes() {
-  return [
-    // GET /api/v1/notes — list notes
-    {
-      method: "GET",
-      pattern: /^\/api\/v1\/notes\/?$/,
-      handler: async () => {
-        return errorResponse(DB_NOT_CONNECTED, 503);
-      }
-    },
-    // POST /api/v1/notes — create note
-    {
-      method: "POST",
-      pattern: /^\/api\/v1\/notes\/?$/,
-      handler: async (request) => {
-        const body = await parseJsonBody(request);
-        if (body === null) return errorResponse("Invalid JSON body", 400);
-        return errorResponse(DB_NOT_CONNECTED, 503);
-      }
-    },
-    // POST /api/v1/notes/:id/restore — restore soft-deleted note (must come before /:id)
-    {
-      method: "POST",
-      pattern: /^\/api\/v1\/notes\/([^/]+)\/restore\/?$/,
-      handler: async () => {
-        return errorResponse(DB_NOT_CONNECTED, 503);
-      }
-    },
-    // POST /api/v1/notes/:id/star — star or unstar a note
-    {
-      method: "POST",
-      pattern: /^\/api\/v1\/notes\/([^/]+)\/star\/?$/,
-      handler: async () => {
-        return errorResponse(DB_NOT_CONNECTED, 503);
-      }
-    },
-    // POST /api/v1/notes/:id/archive — archive or unarchive a note
-    {
-      method: "POST",
-      pattern: /^\/api\/v1\/notes\/([^/]+)\/archive\/?$/,
-      handler: async () => {
-        return errorResponse(DB_NOT_CONNECTED, 503);
-      }
-    },
-    // GET /api/v1/notes/:id — get a single note
-    {
-      method: "GET",
-      pattern: /^\/api\/v1\/notes\/([^/]+)\/?$/,
-      handler: async () => {
-        return errorResponse(DB_NOT_CONNECTED, 503);
-      }
-    },
-    // PUT /api/v1/notes/:id — update a note
-    {
-      method: "PUT",
-      pattern: /^\/api\/v1\/notes\/([^/]+)\/?$/,
-      handler: async () => {
-        return errorResponse(DB_NOT_CONNECTED, 503);
-      }
-    },
-    // DELETE /api/v1/notes/:id — soft-delete a note
-    {
-      method: "DELETE",
-      pattern: /^\/api\/v1\/notes\/([^/]+)\/?$/,
-      handler: async () => {
-        return errorResponse(DB_NOT_CONNECTED, 503);
-      }
-    },
-    // GET /api/v1/search — full-text search
-    {
-      method: "GET",
-      pattern: /^\/api\/v1\/search\/?$/,
-      handler: async () => {
-        return errorResponse(DB_NOT_CONNECTED, 503);
+  /**
+   * List notes with optional filtering, sorting, and pagination.
+   * Excludes soft-deleted notes by default (pass include_deleted: true to override).
+   */
+  async list(options = {}) {
+    const {
+      limit = 50,
+      offset = 0,
+      sort = "created_at",
+      order = "desc",
+      is_starred,
+      is_pinned,
+      is_archived,
+      include_deleted = false,
+      collection_id,
+      tags
+    } = options;
+    const conditions = [];
+    const params = [];
+    let paramIndex = 1;
+    if (!include_deleted) {
+      conditions.push("n.deleted_at IS NULL");
+    }
+    if (is_starred !== void 0) {
+      conditions.push(`n.is_starred = $${paramIndex++}`);
+      params.push(is_starred);
+    }
+    if (is_pinned !== void 0) {
+      conditions.push(`n.is_pinned = $${paramIndex++}`);
+      params.push(is_pinned);
+    }
+    if (is_archived !== void 0) {
+      conditions.push(`n.is_archived = $${paramIndex++}`);
+      params.push(is_archived);
+    }
+    if (collection_id) {
+      conditions.push(
+        `EXISTS (SELECT 1 FROM collection_note cn WHERE cn.note_id = n.id AND cn.collection_id = $${paramIndex++})`
+      );
+      params.push(collection_id);
+    }
+    if (tags?.length) {
+      conditions.push(
+        `EXISTS (SELECT 1 FROM note_tag nt WHERE nt.note_id = n.id AND nt.tag = ANY($${paramIndex++}))`
+      );
+      params.push(tags);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const validSorts = ["created_at", "updated_at", "title"];
+    const sortCol = validSorts.includes(sort) ? sort : "created_at";
+    const sortDir = order === "asc" ? "ASC" : "DESC";
+    const countResult = await this.db.query(
+      `SELECT COUNT(*) AS count FROM note n ${where}`,
+      params
+    );
+    const total = parseInt(countResult.rows[0].count, 10);
+    const listParams = [...params, limit, offset];
+    const rowsResult = await this.db.query(
+      `SELECT n.id, n.title, n.format, n.source, n.visibility,
+              n.is_starred, n.is_pinned, n.is_archived,
+              n.created_at, n.updated_at, n.deleted_at
+       FROM note n ${where}
+       ORDER BY n.${sortCol} ${sortDir}
+       LIMIT $${paramIndex++} OFFSET $${paramIndex++}`,
+      listParams
+    );
+    const noteIds = rowsResult.rows.map((r) => r.id);
+    const tagMap = /* @__PURE__ */ new Map();
+    if (noteIds.length > 0) {
+      const tagsResult = await this.db.query(
+        `SELECT note_id, tag FROM note_tag WHERE note_id = ANY($1) ORDER BY tag`,
+        [noteIds]
+      );
+      for (const row of tagsResult.rows) {
+        const existing = tagMap.get(row.note_id) ?? [];
+        existing.push(row.tag);
+        tagMap.set(row.note_id, existing);
       }
     }
-  ];
-}
-function matchRoute(routes, request, url) {
-  for (const route of routes) {
-    if (request.method !== route.method) continue;
-    const match = url.pathname.match(route.pattern);
-    if (match) return route;
-  }
-  return null;
-}
-
-// src/blob-store.ts
-function hashPath(hash) {
-  return {
-    dir1: hash.slice(0, 2),
-    dir2: hash.slice(2, 4),
-    filename: hash
-  };
-}
-var OpfsBlobStore = class {
-  constructor(archiveName) {
-    this.archiveName = archiveName;
-  }
-  async getRoot() {
-    const root = await navigator.storage.getDirectory();
-    return root.getDirectoryHandle(`fortemi-${this.archiveName}-blobs`, { create: true });
+    const items = rowsResult.rows.map((r) => ({
+      id: r.id,
+      title: r.title,
+      format: r.format,
+      source: r.source,
+      visibility: r.visibility,
+      is_starred: r.is_starred,
+      is_pinned: r.is_pinned,
+      is_archived: r.is_archived,
+      created_at: r.created_at,
+      updated_at: r.updated_at,
+      deleted_at: r.deleted_at,
+      tags: tagMap.get(r.id) ?? []
+    }));
+    return { items, total, limit, offset };
   }
-  async getFileHandle(hash, create) {
-    const { dir1, dir2, filename } = hashPath(hash);
-    try {
-      const root = await this.getRoot();
-      const d1 = await root.getDirectoryHandle(dir1, { create });
-      const d2 = await d1.getDirectoryHandle(dir2, { create });
-      return d2.getFileHandle(filename, { create });
-    } catch (err) {
-      if (err instanceof DOMException && err.name === "NotFoundError") {
-        return null;
+  /**
+   * Update mutable note fields.
+   * When content changes, the previous current content is saved as a numbered
+   * revision before the new content is applied.
+   */
+  async update(id, input) {
+    const countResult = await this.db.query(
+      `SELECT COUNT(*) AS count FROM note_revision WHERE note_id = $1`,
+      [id]
+    );
+    const nextRevision = parseInt(countResult.rows[0].count, 10) + 1;
+    await this.db.transaction(async (tx) => {
+      const setClauses = ["updated_at = now()"];
+      const noteParams = [];
+      let paramIdx = 1;
+      if (input.title !== void 0) {
+        setClauses.push(`title = $${paramIdx++}`);
+        noteParams.push(input.title);
       }
-      throw err;
-    }
+      if (input.format !== void 0) {
+        setClauses.push(`format = $${paramIdx++}`);
+        noteParams.push(input.format);
+      }
+      if (input.visibility !== void 0) {
+        setClauses.push(`visibility = $${paramIdx++}`);
+        noteParams.push(input.visibility);
+      }
+      noteParams.push(id);
+      await tx.query(
+        `UPDATE note SET ${setClauses.join(", ")} WHERE id = $${paramIdx}`,
+        noteParams
+      );
+      if (input.content !== void 0) {
+        const currentResult = await tx.query(
+          `SELECT content FROM note_revised_current WHERE note_id = $1`,
+          [id]
+        );
+        if (currentResult.rows.length > 0) {
+          await tx.query(
+            `INSERT INTO note_revision (id, note_id, revision_number, type, content)
+             VALUES ($1, $2, $3, 'user', $4)`,
+            [generateId(), id, nextRevision, currentResult.rows[0].content]
+          );
+        }
+        await tx.query(
+          `UPDATE note_revised_current
+           SET content = $1, is_user_edited = true, updated_at = now()
+           WHERE note_id = $2`,
+          [input.content, id]
+        );
+      }
+    });
+    this.events?.emit("note.updated", { id });
+    return this.get(id);
   }
-  async write(hash, data) {
-    const fh = await this.getFileHandle(hash, true);
-    if (!fh) throw new Error(`OpfsBlobStore: could not create file for hash ${hash}`);
-    const writable = await fh.createWritable();
-    await writable.write(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
-    await writable.close();
+  /**
+   * Soft-delete a note by setting deleted_at to the current timestamp.
+   */
+  async delete(id) {
+    await this.db.query(
+      `UPDATE note SET deleted_at = now(), updated_at = now() WHERE id = $1`,
+      [id]
+    );
+    this.events?.emit("note.deleted", { id });
   }
-  async read(hash) {
-    const fh = await this.getFileHandle(hash, false);
-    if (!fh) return null;
-    const file = await fh.getFile();
-    const buffer = await file.arrayBuffer();
-    return new Uint8Array(buffer);
+  /**
+   * Restore a soft-deleted note by clearing deleted_at.
+   */
+  async restore(id) {
+    await this.db.query(
+      `UPDATE note SET deleted_at = NULL, updated_at = now() WHERE id = $1`,
+      [id]
+    );
+    this.events?.emit("note.restored", { id });
+    return this.get(id);
   }
-  async remove(hash) {
-    const { dir1, dir2, filename } = hashPath(hash);
-    try {
-      const root = await this.getRoot();
-      const d1 = await root.getDirectoryHandle(dir1, { create: false });
-      const d2 = await d1.getDirectoryHandle(dir2, { create: false });
-      await d2.removeEntry(filename);
-    } catch (err) {
-      if (err instanceof DOMException && err.name === "NotFoundError") {
-        return;
-      }
-      throw err;
-    }
+  /**
+   * Toggle the is_starred field on a note.
+   */
+  async star(id, starred) {
+    await this.db.query(
+      `UPDATE note SET is_starred = $1, updated_at = now() WHERE id = $2`,
+      [starred, id]
+    );
+    this.events?.emit("note.updated", { id });
   }
-  async exists(hash) {
-    const fh = await this.getFileHandle(hash, false);
-    return fh !== null;
+  /**
+   * Toggle the is_pinned field on a note.
+   */
+  async pin(id, pinned) {
+    await this.db.query(
+      `UPDATE note SET is_pinned = $1, updated_at = now() WHERE id = $2`,
+      [pinned, id]
+    );
+    this.events?.emit("note.updated", { id });
   }
-};
-var IDB_STORE = "blobs";
-var IDB_VERSION = 1;
-function openDb(dbName) {
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open(dbName, IDB_VERSION);
-    req.onupgradeneeded = () => {
-      req.result.createObjectStore(IDB_STORE);
-    };
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-  });
-}
-var IdbBlobStore = class {
-  dbName;
-  _db = null;
-  constructor(archiveName) {
-    this.dbName = `fortemi-${archiveName}-blobs`;
+  /**
+   * Toggle the is_archived field on a note.
+   */
+  async archive(id, archived) {
+    await this.db.query(
+      `UPDATE note SET is_archived = $1, updated_at = now() WHERE id = $2`,
+      [archived, id]
+    );
+    this.events?.emit("note.updated", { id });
   }
-  async db() {
-    if (!this._db) {
-      this._db = await openDb(this.dbName);
-    }
-    return this._db;
+  /**
+   * Get revision history for a note, ordered by revision_number descending.
+   */
+  async getRevisions(noteId) {
+    const result = await this.db.query(
+      `SELECT id, note_id, revision_number, type, content, ai_metadata, model, created_at
+       FROM note_revision
+       WHERE note_id = $1
+       ORDER BY revision_number DESC`,
+      [noteId]
+    );
+    return result.rows;
   }
-  async write(hash, data) {
-    const db = await this.db();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IDB_STORE, "readwrite");
-      tx.objectStore(IDB_STORE).put(data, hash);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
-    });
+};
+
+// src/repositories/condition-builder.ts
+function buildNoteConditions(options, startIdx, includeDeleted = false) {
+  const conditions = [];
+  const params = [];
+  let idx = startIdx;
+  if (!includeDeleted) {
+    conditions.push("n.deleted_at IS NULL");
   }
-  async read(hash) {
-    const db = await this.db();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IDB_STORE, "readonly");
-      const req = tx.objectStore(IDB_STORE).get(hash);
-      req.onsuccess = () => resolve(req.result ?? null);
-      req.onerror = () => reject(req.error);
-    });
+  if (options.tags?.length) {
+    conditions.push(
+      `EXISTS (SELECT 1 FROM note_tag nt WHERE nt.note_id = n.id AND nt.tag = ANY($${idx++}))`
+    );
+    params.push(options.tags);
   }
-  async remove(hash) {
-    const db = await this.db();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IDB_STORE, "readwrite");
-      tx.objectStore(IDB_STORE).delete(hash);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
-    });
+  if (options.collection_id) {
+    conditions.push(
+      `EXISTS (SELECT 1 FROM collection_note cn WHERE cn.note_id = n.id AND cn.collection_id = $${idx++})`
+    );
+    params.push(options.collection_id);
   }
-  async exists(hash) {
-    const db = await this.db();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IDB_STORE, "readonly");
-      const req = tx.objectStore(IDB_STORE).count(hash);
-      req.onsuccess = () => resolve(req.result > 0);
-      req.onerror = () => reject(req.error);
-    });
+  if (options.date_from) {
+    conditions.push(`n.created_at >= $${idx++}`);
+    params.push(options.date_from);
   }
-};
-var MemoryBlobStore = class {
-  store = /* @__PURE__ */ new Map();
-  async write(hash, data) {
-    this.store.set(hash, data);
+  if (options.date_to) {
+    conditions.push(`n.created_at <= $${idx++}`);
+    params.push(options.date_to);
   }
-  async read(hash) {
-    return this.store.get(hash) ?? null;
+  if (options.is_starred !== void 0) {
+    conditions.push(`n.is_starred = $${idx++}`);
+    params.push(options.is_starred);
   }
-  async remove(hash) {
-    this.store.delete(hash);
+  if (options.is_archived !== void 0) {
+    conditions.push(`n.is_archived = $${idx++}`);
+    params.push(options.is_archived);
   }
-  async exists(hash) {
-    return this.store.has(hash);
+  if (options.format) {
+    conditions.push(`n.format = $${idx++}`);
+    params.push(options.format);
   }
-};
-function createBlobStore(archiveName) {
-  if (typeof navigator !== "undefined" && "storage" in navigator && "getDirectory" in navigator.storage) {
-    return new OpfsBlobStore(archiveName);
+  if (options.source) {
+    conditions.push(`n.source = $${idx++}`);
+    params.push(options.source);
   }
-  return new IdbBlobStore(archiveName);
+  if (options.visibility) {
+    conditions.push(`n.visibility = $${idx++}`);
+    params.push(options.visibility);
+  }
+  return { conditions, params, nextIdx: idx };
 }
 
-// src/repositories/notes-repository.ts
-var NotesRepository = class {
-  constructor(db, events) {
+// 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();
+}
+function hashJson(value) {
+  return computeHash(new TextEncoder().encode(JSON.stringify(value)));
+}
+var EmbeddingSetsRepository = class {
+  constructor(db) {
     this.db = db;
-    this.events = events;
   }
-  /**
-   * Create a new note with its original content record, current revision,
-   * optional tags, and an auto-queued title_generation job when no title
-   * is provided.
-   *
-   * All writes happen in a single transaction.
-   */
   async create(input) {
-    const noteId = generateId();
-    const originalId = generateId();
-    const contentHash = computeHash(new TextEncoder().encode(input.content));
-    await this.db.transaction(async (tx) => {
-      await tx.query(
-        `INSERT INTO note (id, archive_id, title, format, source, visibility)
-         VALUES ($1, $2, $3, $4, $5, $6)`,
-        [
-          noteId,
-          input.archive_id ?? null,
-          input.title ?? null,
-          input.format ?? "markdown",
-          input.source ?? "user",
-          input.visibility ?? "private"
-        ]
-      );
-      await tx.query(
-        `INSERT INTO note_original (id, note_id, content, content_hash)
-         VALUES ($1, $2, $3, $4)`,
-        [originalId, noteId, input.content, contentHash]
-      );
-      await tx.query(
-        `INSERT INTO note_revised_current (note_id, content)
-         VALUES ($1, $2)`,
-        [noteId, input.content]
-      );
-      if (input.tags?.length) {
-        for (const tag of input.tags) {
-          await tx.query(
-            `INSERT INTO note_tag (id, note_id, tag) VALUES ($1, $2, $3)`,
-            [generateId(), noteId, tag]
-          );
-        }
-      }
-      await tx.query(
-        `INSERT INTO job_queue (id, note_id, job_type, status, priority, required_capability)
-         VALUES ($1, $2, 'ai_revision', 'pending', 1, 'llm')`,
-        [generateId(), noteId]
-      );
-      if (!input.title) {
-        await tx.query(
-          `INSERT INTO job_queue (id, note_id, job_type, status, priority)
-           VALUES ($1, $2, 'title_generation', 'pending', 2)`,
-          [generateId(), noteId]
-        );
-      }
-      await tx.query(
-        `INSERT INTO job_queue (id, note_id, job_type, status, priority, required_capability)
-         VALUES ($1, $2, 'embedding', 'pending', 3, 'semantic')`,
-        [generateId(), noteId]
-      );
-    });
-    this.events?.emit("note.created", { id: noteId });
-    return this.get(noteId);
+    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);
   }
-  /**
-   * Fetch a single note by its ID.
-   * Returns NoteFull which includes original content, current revision, and tags.
-   * Throws when the note does not exist.
-   */
-  async get(id) {
-    const noteResult = await this.db.query(
-      `SELECT n.id, n.archive_id, n.title, n.format, n.source, n.visibility,
-              n.revision_mode, n.is_starred, n.is_pinned, n.is_archived,
-              n.created_at, n.updated_at, n.deleted_at,
-              o.id         AS original_id,
-              o.content    AS original_content,
-              o.content_hash,
-              o.created_at AS original_created_at,
-              c.content    AS current_content,
-              c.ai_metadata,
-              c.generation_count,
-              c.model,
-              c.is_user_edited,
-              c.updated_at AS current_updated_at
-       FROM note n
-       LEFT JOIN note_original       o ON o.note_id = n.id
-       LEFT JOIN note_revised_current c ON c.note_id = n.id
-       WHERE n.id = $1`,
-      [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
+      ]
     );
-    if (noteResult.rows.length === 0) {
-      throw new Error(`Note not found: ${id}`);
+    const row = await this.get(id);
+    if (input.materialization?.allowed) {
+      await this.refreshMaterializedVirtualSet(id);
+      return this.get(id);
     }
-    const row = noteResult.rows[0];
-    const tagsResult = await this.db.query(
-      `SELECT tag FROM note_tag WHERE note_id = $1 ORDER BY tag`,
+    return row;
+  }
+  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,
-      archive_id: row.archive_id,
-      title: row.title,
-      format: row.format,
-      source: row.source,
-      visibility: row.visibility,
-      revision_mode: row.revision_mode,
-      is_starred: row.is_starred,
-      is_pinned: row.is_pinned,
-      is_archived: row.is_archived,
-      created_at: row.created_at,
-      updated_at: row.updated_at,
-      deleted_at: row.deleted_at,
-      tags: tagsResult.rows.map((r) => r.tag),
-      original: {
-        id: row.original_id,
-        content: row.original_content,
-        content_hash: row.content_hash,
-        created_at: row.original_created_at
-      },
-      current: {
-        content: row.current_content,
-        ai_metadata: row.ai_metadata,
-        generation_count: row.generation_count,
-        model: row.model,
-        is_user_edited: row.is_user_edited,
-        updated_at: row.current_updated_at
-      }
+      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" }
     };
   }
-  /**
-   * List notes with optional filtering, sorting, and pagination.
-   * Excludes soft-deleted notes by default (pass include_deleted: true to override).
-   */
-  async list(options = {}) {
-    const {
-      limit = 50,
-      offset = 0,
-      sort = "created_at",
-      order = "desc",
-      is_starred,
-      is_pinned,
-      is_archived,
-      include_deleted = false,
-      collection_id,
-      tags
-    } = options;
-    const conditions = [];
-    const params = [];
-    let paramIndex = 1;
-    if (!include_deleted) {
-      conditions.push("n.deleted_at IS NULL");
-    }
-    if (is_starred !== void 0) {
-      conditions.push(`n.is_starred = $${paramIndex++}`);
-      params.push(is_starred);
-    }
-    if (is_pinned !== void 0) {
-      conditions.push(`n.is_pinned = $${paramIndex++}`);
-      params.push(is_pinned);
-    }
-    if (is_archived !== void 0) {
-      conditions.push(`n.is_archived = $${paramIndex++}`);
-      params.push(is_archived);
-    }
-    if (collection_id) {
-      conditions.push(
-        `EXISTS (SELECT 1 FROM collection_note cn WHERE cn.note_id = n.id AND cn.collection_id = $${paramIndex++})`
-      );
-      params.push(collection_id);
+  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 (tags?.length) {
-      conditions.push(
-        `EXISTS (SELECT 1 FROM note_tag nt WHERE nt.note_id = n.id AND nt.tag = ANY($${paramIndex++}))`
+    if (input.vector.length !== set.dimensions) {
+      throw new Error(
+        `Embedding vector has ${input.vector.length} dimensions; set ${set.id} expects ${set.dimensions}`
       );
-      params.push(tags);
     }
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const validSorts = ["created_at", "updated_at", "title"];
-    const sortCol = validSorts.includes(sort) ? sort : "created_at";
-    const sortDir = order === "asc" ? "ASC" : "DESC";
-    const countResult = await this.db.query(
-      `SELECT COUNT(*) AS count FROM note n ${where}`,
-      params
+    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]
     );
-    const total = parseInt(countResult.rows[0].count, 10);
-    const listParams = [...params, limit, offset];
-    const rowsResult = await this.db.query(
-      `SELECT n.id, n.title, n.format, n.source, n.visibility,
-              n.is_starred, n.is_pinned, n.is_archived,
-              n.created_at, n.updated_at, n.deleted_at
-       FROM note n ${where}
-       ORDER BY n.${sortCol} ${sortDir}
-       LIMIT $${paramIndex++} OFFSET $${paramIndex++}`,
-      listParams
+    await this.db.query(
+      `DELETE FROM embedding WHERE note_id = $1 AND embedding_set_id = $2`,
+      [input.note_id, input.embedding_set_id]
     );
-    const noteIds = rowsResult.rows.map((r) => r.id);
-    const tagMap = /* @__PURE__ */ new Map();
-    if (noteIds.length > 0) {
-      const tagsResult = await this.db.query(
-        `SELECT note_id, tag FROM note_tag WHERE note_id = ANY($1) ORDER BY tag`,
-        [noteIds]
-      );
-      for (const row of tagsResult.rows) {
-        const existing = tagMap.get(row.note_id) ?? [];
-        existing.push(row.tag);
-        tagMap.set(row.note_id, existing);
+    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, set);
       }
+      return this.resolvePhysicalSet(selector, set.id);
     }
-    const items = rowsResult.rows.map((r) => ({
-      id: r.id,
-      title: r.title,
-      format: r.format,
-      source: r.source,
-      visibility: r.visibility,
-      is_starred: r.is_starred,
-      is_pinned: r.is_pinned,
-      is_archived: r.is_archived,
-      created_at: r.created_at,
-      updated_at: r.updated_at,
-      deleted_at: r.deleted_at,
-      tags: tagMap.get(r.id) ?? []
-    }));
-    return { items, total, limit, offset };
+    if (!selector.definition) throw new Error("virtual-definition selector requires definition");
+    return this.resolveDefinition(selector, selector.definition);
   }
-  /**
-   * Update mutable note fields.
-   * When content changes, the previous current content is saved as a numbered
-   * revision before the new content is applied.
-   */
-  async update(id, input) {
-    const countResult = await this.db.query(
-      `SELECT COUNT(*) AS count FROM note_revision WHERE note_id = $1`,
-      [id]
-    );
-    const nextRevision = parseInt(countResult.rows[0].count, 10) + 1;
-    await this.db.transaction(async (tx) => {
-      const setClauses = ["updated_at = now()"];
-      const noteParams = [];
-      let paramIdx = 1;
-      if (input.title !== void 0) {
-        setClauses.push(`title = $${paramIdx++}`);
-        noteParams.push(input.title);
-      }
-      if (input.format !== void 0) {
-        setClauses.push(`format = $${paramIdx++}`);
-        noteParams.push(input.format);
-      }
-      if (input.visibility !== void 0) {
-        setClauses.push(`visibility = $${paramIdx++}`);
-        noteParams.push(input.visibility);
-      }
-      noteParams.push(id);
-      await tx.query(
-        `UPDATE note SET ${setClauses.join(", ")} WHERE id = $${paramIdx}`,
-        noteParams
+  async refreshMaterializedVirtualSet(setId) {
+    const set = await this.get(setId);
+    if (set.kind !== "virtual") throw new Error(`Embedding set is not virtual: ${setId}`);
+    const definition = this.definitionFromRow(set);
+    if (!definition.materialization?.allowed) {
+      throw new Error(`Virtual embedding set does not allow materialization: ${setId}`);
+    }
+    const live = await this.resolveDefinition(
+      { kind: "embedding-set", embeddingSetId: setId },
+      definition,
+      set,
+      { forceLive: true }
+    );
+    await this.db.query(`DELETE FROM embedding_set_member WHERE embedding_set_id = $1`, [setId]);
+    for (const row of live.rows) {
+      await this.db.query(
+        `INSERT INTO embedding_set_member (embedding_set_id, note_id, embedding_id)
+         VALUES ($1, $2, $3)
+         ON CONFLICT DO NOTHING`,
+        [setId, row.note_id, row.embedding_id]
       );
-      if (input.content !== void 0) {
-        const currentResult = await tx.query(
-          `SELECT content FROM note_revised_current WHERE note_id = $1`,
-          [id]
-        );
-        if (currentResult.rows.length > 0) {
-          await tx.query(
-            `INSERT INTO note_revision (id, note_id, revision_number, type, content)
-             VALUES ($1, $2, $3, 'user', $4)`,
-            [generateId(), id, nextRevision, currentResult.rows[0].content]
-          );
-        }
-        await tx.query(
-          `UPDATE note_revised_current
-           SET content = $1, is_user_edited = true, updated_at = now()
-           WHERE note_id = $2`,
-          [input.content, id]
-        );
-      }
-    });
-    this.events?.emit("note.updated", { id });
-    return this.get(id);
-  }
-  /**
-   * Soft-delete a note by setting deleted_at to the current timestamp.
-   */
-  async delete(id) {
+    }
+    const inputHash = this.resolutionInputHash(definition, live.rows);
+    const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const materialization = {
+      ...definition.materialization,
+      allowed: true,
+      includeResolvedMembers: true,
+      freshness: "fresh",
+      inputHash,
+      generatedAt,
+      resolvedMemberCount: live.rows.length
+    };
+    const freshness = {
+      status: "fresh",
+      sourceHash: inputHash,
+      checkedAt: generatedAt
+    };
     await this.db.query(
-      `UPDATE note SET deleted_at = now(), updated_at = now() WHERE id = $1`,
-      [id]
+      `UPDATE embedding_set
+       SET materialization_json = $2::jsonb, freshness_json = $3::jsonb, updated_at = now()
+       WHERE id = $1`,
+      [setId, jsonParam(materialization), jsonParam(freshness)]
     );
-    this.events?.emit("note.deleted", { id });
-  }
-  /**
-   * Restore a soft-deleted note by clearing deleted_at.
-   */
-  async restore(id) {
-    await this.db.query(
-      `UPDATE note SET deleted_at = NULL, updated_at = now() WHERE id = $1`,
-      [id]
+    return this.finalizeResolution(
+      { kind: "embedding-set", embeddingSetId: setId },
+      live.rows,
+      live.errors,
+      definition.compatibility,
+      "fresh",
+      "materialized"
     );
-    this.events?.emit("note.restored", { id });
-    return this.get(id);
   }
-  /**
-   * Toggle the is_starred field on a note.
-   */
-  async star(id, starred) {
+  async markVirtualSetStale(setId, reason) {
+    const set = await this.get(setId);
+    if (set.kind !== "virtual") throw new Error(`Embedding set is not virtual: ${setId}`);
+    const definition = this.definitionFromRow(set);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const materialization = definition.materialization ? { ...definition.materialization, freshness: "stale" } : null;
     await this.db.query(
-      `UPDATE note SET is_starred = $1, updated_at = now() WHERE id = $2`,
-      [starred, id]
+      `UPDATE embedding_set
+       SET materialization_json = $2::jsonb, freshness_json = $3::jsonb, updated_at = now()
+       WHERE id = $1`,
+      [
+        setId,
+        jsonParam(materialization),
+        jsonParam({ status: "stale", sourceHash: definition.materialization?.inputHash, checkedAt: now, reason })
+      ]
     );
-    this.events?.emit("note.updated", { id });
   }
-  /**
-   * Toggle the is_pinned field on a note.
-   */
-  async pin(id, pinned) {
-    await this.db.query(
-      `UPDATE note SET is_pinned = $1, updated_at = now() WHERE id = $2`,
-      [pinned, id]
-    );
-    this.events?.emit("note.updated", { id });
+  async resolveDefinition(selector, definition, set, options = {}) {
+    if (!options.forceLive && set && definition.materialization?.allowed && definition.materialization.freshness === "fresh") {
+      const materialized = await this.resolveMaterializedRows(set.id);
+      if (materialized.length > 0 || definition.materialization.resolvedMemberCount === 0) {
+        return this.finalizeResolution(
+          selector,
+          materialized,
+          [],
+          definition.compatibility,
+          "fresh",
+          "materialized"
+        );
+      }
+    }
+    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", "live");
   }
-  /**
-   * Toggle the is_archived field on a note.
-   */
-  async archive(id, archived) {
-    await this.db.query(
-      `UPDATE note SET is_archived = $1, updated_at = now() WHERE id = $2`,
-      [archived, id]
-    );
-    this.events?.emit("note.updated", { id });
+  async resolvePhysicalSet(selector, setId) {
+    return this.finalizeResolution(selector, await this.resolvePhysicalRows(setId), [], DEFAULT_COMPATIBILITY, "fresh", "live");
   }
-  /**
-   * Get revision history for a note, ordered by revision_number descending.
-   */
-  async getRevisions(noteId) {
+  async resolvePhysicalRows(setId) {
     const result = await this.db.query(
-      `SELECT id, note_id, revision_number, type, content, ai_metadata, model, created_at
-       FROM note_revision
-       WHERE note_id = $1
-       ORDER BY revision_number DESC`,
-      [noteId]
+      `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;
   }
-};
-
-// src/repositories/condition-builder.ts
-function buildNoteConditions(options, startIdx, includeDeleted = false) {
-  const conditions = [];
-  const params = [];
-  let idx = startIdx;
-  if (!includeDeleted) {
-    conditions.push("n.deleted_at IS NULL");
-  }
-  if (options.tags?.length) {
-    conditions.push(
-      `EXISTS (SELECT 1 FROM note_tag nt WHERE nt.note_id = n.id AND nt.tag = ANY($${idx++}))`
-    );
-    params.push(options.tags);
-  }
-  if (options.collection_id) {
-    conditions.push(
-      `EXISTS (SELECT 1 FROM collection_note cn WHERE cn.note_id = n.id AND cn.collection_id = $${idx++})`
+  async resolveMaterializedRows(setId) {
+    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_set_member m
+       JOIN embedding e ON e.id = m.embedding_id
+       WHERE m.embedding_set_id = $1
+       ORDER BY e.note_id, e.created_at DESC`,
+      [setId]
     );
-    params.push(options.collection_id);
-  }
-  if (options.date_from) {
-    conditions.push(`n.created_at >= $${idx++}`);
-    params.push(options.date_from);
-  }
-  if (options.date_to) {
-    conditions.push(`n.created_at <= $${idx++}`);
-    params.push(options.date_to);
-  }
-  if (options.is_starred !== void 0) {
-    conditions.push(`n.is_starred = $${idx++}`);
-    params.push(options.is_starred);
-  }
-  if (options.is_archived !== void 0) {
-    conditions.push(`n.is_archived = $${idx++}`);
-    params.push(options.is_archived);
-  }
-  if (options.format) {
-    conditions.push(`n.format = $${idx++}`);
-    params.push(options.format);
-  }
-  if (options.source) {
-    conditions.push(`n.source = $${idx++}`);
-    params.push(options.source);
-  }
-  if (options.visibility) {
-    conditions.push(`n.visibility = $${idx++}`);
-    params.push(options.visibility);
+    return result.rows;
   }
-  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();
-}
-function hashJson(value) {
-  return computeHash(new TextEncoder().encode(JSON.stringify(value)));
-}
-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
-      ]
-    );
-    const row = await this.get(id);
-    if (input.materialization?.allowed) {
-      await this.refreshMaterializedVirtualSet(id);
-      return this.get(id);
+  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.sources?.length) {
+      conditions.push(`n.source = ANY($${idx++})`);
+      params.push(criteria.sources);
+    }
+    if (criteria.formats?.length) {
+      conditions.push(`n.format = ANY($${idx++})`);
+      params.push(criteria.formats);
+    }
+    if (criteria.visibilities?.length) {
+      conditions.push(`n.visibility = ANY($${idx++})`);
+      params.push(criteria.visibilities);
+    }
+    if (criteria.isStarred !== void 0) {
+      conditions.push(`n.is_starred = $${idx++}`);
+      params.push(criteria.isStarred);
+    }
+    if (criteria.isArchived !== void 0) {
+      conditions.push(`n.is_archived = $${idx++}`);
+      params.push(criteria.isArchived);
+    }
+    if (criteria.hasTitle !== void 0) {
+      conditions.push(criteria.hasTitle ? `n.title IS NOT NULL AND n.title <> ''` : `(n.title IS NULL OR n.title = '')`);
+    }
+    if (criteria.hasEmbedding === false) {
+      conditions.push("FALSE");
+    }
+    if (criteria.isUserEdited !== void 0) {
+      conditions.push(`COALESCE(c.is_user_edited, false) = $${idx++}`);
+      params.push(criteria.isUserEdited);
+    }
+    if (criteria.hasAiMetadata !== void 0) {
+      conditions.push(criteria.hasAiMetadata ? `c.ai_metadata IS NOT NULL` : `c.ai_metadata IS NULL`);
+    }
+    if (criteria.hasRevisions !== void 0) {
+      conditions.push(criteria.hasRevisions ? `EXISTS (SELECT 1 FROM note_revision nr WHERE nr.note_id = n.id)` : `NOT EXISTS (SELECT 1 FROM note_revision nr WHERE nr.note_id = n.id)`);
+    }
+    if (criteria.minGenerationCount !== void 0) {
+      conditions.push(`COALESCE(c.generation_count, 0) >= $${idx++}`);
+      params.push(criteria.minGenerationCount);
+    }
+    if (criteria.maxGenerationCount !== void 0) {
+      conditions.push(`COALESCE(c.generation_count, 0) <= $${idx++}`);
+      params.push(criteria.maxGenerationCount);
+    }
+    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);
     }
-    return row;
-  }
-  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`
+      `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 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}`);
+  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 (input.vector.length !== set.dimensions) {
-      throw new Error(
-        `Embedding vector has ${input.vector.length} dimensions; set ${set.id} expects ${set.dimensions}`
-      );
+    if (source.operation === "intersection") {
+      return firstRows.filter((row) => noteSets.every((set) => set.has(row.note_id)));
     }
-    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 };
+    return this.resolveDuplicateRows(source.setIds.flatMap((setId) => bySet.get(setId) ?? []), compatibility, errors);
   }
-  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, set);
-      }
-      return this.resolvePhysicalSet(selector, set.id);
-    }
-    if (!selector.definition) throw new Error("virtual-definition selector requires definition");
-    return this.resolveDefinition(selector, selector.definition);
-  }
-  async refreshMaterializedVirtualSet(setId) {
-    const set = await this.get(setId);
-    if (set.kind !== "virtual") throw new Error(`Embedding set is not virtual: ${setId}`);
-    const definition = this.definitionFromRow(set);
-    if (!definition.materialization?.allowed) {
-      throw new Error(`Virtual embedding set does not allow materialization: ${setId}`);
-    }
-    const live = await this.resolveDefinition(
-      { kind: "embedding-set", embeddingSetId: setId },
-      definition,
-      set,
-      { forceLive: true }
-    );
-    await this.db.query(`DELETE FROM embedding_set_member WHERE embedding_set_id = $1`, [setId]);
-    for (const row of live.rows) {
-      await this.db.query(
-        `INSERT INTO embedding_set_member (embedding_set_id, note_id, embedding_id)
-         VALUES ($1, $2, $3)
-         ON CONFLICT DO NOTHING`,
-        [setId, row.note_id, row.embedding_id]
-      );
-    }
-    const inputHash = this.resolutionInputHash(definition, live.rows);
-    const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const materialization = {
-      ...definition.materialization,
-      allowed: true,
-      includeResolvedMembers: true,
-      freshness: "fresh",
-      inputHash,
-      generatedAt,
-      resolvedMemberCount: live.rows.length
-    };
-    const freshness = {
-      status: "fresh",
-      sourceHash: inputHash,
-      checkedAt: generatedAt
-    };
-    await this.db.query(
-      `UPDATE embedding_set
-       SET materialization_json = $2::jsonb, freshness_json = $3::jsonb, updated_at = now()
-       WHERE id = $1`,
-      [setId, jsonParam(materialization), jsonParam(freshness)]
-    );
-    return this.finalizeResolution(
-      { kind: "embedding-set", embeddingSetId: setId },
-      live.rows,
-      live.errors,
-      definition.compatibility,
-      "fresh",
-      "materialized"
-    );
-  }
-  async markVirtualSetStale(setId, reason) {
-    const set = await this.get(setId);
-    if (set.kind !== "virtual") throw new Error(`Embedding set is not virtual: ${setId}`);
-    const definition = this.definitionFromRow(set);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const materialization = definition.materialization ? { ...definition.materialization, freshness: "stale" } : null;
-    await this.db.query(
-      `UPDATE embedding_set
-       SET materialization_json = $2::jsonb, freshness_json = $3::jsonb, updated_at = now()
-       WHERE id = $1`,
-      [
-        setId,
-        jsonParam(materialization),
-        jsonParam({ status: "stale", sourceHash: definition.materialization?.inputHash, checkedAt: now, reason })
-      ]
-    );
-  }
-  async resolveDefinition(selector, definition, set, options = {}) {
-    if (!options.forceLive && set && definition.materialization?.allowed && definition.materialization.freshness === "fresh") {
-      const materialized = await this.resolveMaterializedRows(set.id);
-      if (materialized.length > 0 || definition.materialization.resolvedMemberCount === 0) {
-        return this.finalizeResolution(
-          selector,
-          materialized,
-          [],
-          definition.compatibility,
-          "fresh",
-          "materialized"
-        );
-      }
-    }
-    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", "live");
-  }
-  async resolvePhysicalSet(selector, setId) {
-    return this.finalizeResolution(selector, await this.resolvePhysicalRows(setId), [], DEFAULT_COMPATIBILITY, "fresh", "live");
-  }
-  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 resolveMaterializedRows(setId) {
-    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_set_member m
-       JOIN embedding e ON e.id = m.embedding_id
-       WHERE m.embedding_set_id = $1
-       ORDER BY e.note_id, e.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.sources?.length) {
-      conditions.push(`n.source = ANY($${idx++})`);
-      params.push(criteria.sources);
-    }
-    if (criteria.formats?.length) {
-      conditions.push(`n.format = ANY($${idx++})`);
-      params.push(criteria.formats);
-    }
-    if (criteria.visibilities?.length) {
-      conditions.push(`n.visibility = ANY($${idx++})`);
-      params.push(criteria.visibilities);
-    }
-    if (criteria.isStarred !== void 0) {
-      conditions.push(`n.is_starred = $${idx++}`);
-      params.push(criteria.isStarred);
-    }
-    if (criteria.isArchived !== void 0) {
-      conditions.push(`n.is_archived = $${idx++}`);
-      params.push(criteria.isArchived);
-    }
-    if (criteria.hasTitle !== void 0) {
-      conditions.push(criteria.hasTitle ? `n.title IS NOT NULL AND n.title <> ''` : `(n.title IS NULL OR n.title = '')`);
-    }
-    if (criteria.hasEmbedding === false) {
-      conditions.push("FALSE");
-    }
-    if (criteria.isUserEdited !== void 0) {
-      conditions.push(`COALESCE(c.is_user_edited, false) = $${idx++}`);
-      params.push(criteria.isUserEdited);
-    }
-    if (criteria.hasAiMetadata !== void 0) {
-      conditions.push(criteria.hasAiMetadata ? `c.ai_metadata IS NOT NULL` : `c.ai_metadata IS NULL`);
-    }
-    if (criteria.hasRevisions !== void 0) {
-      conditions.push(criteria.hasRevisions ? `EXISTS (SELECT 1 FROM note_revision nr WHERE nr.note_id = n.id)` : `NOT EXISTS (SELECT 1 FROM note_revision nr WHERE nr.note_id = n.id)`);
-    }
-    if (criteria.minGenerationCount !== void 0) {
-      conditions.push(`COALESCE(c.generation_count, 0) >= $${idx++}`);
-      params.push(criteria.minGenerationCount);
-    }
-    if (criteria.maxGenerationCount !== void 0) {
-      conditions.push(`COALESCE(c.generation_count, 0) <= $${idx++}`);
-      params.push(criteria.maxGenerationCount);
-    }
-    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);
-      }
+  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));
   }
@@ -2593,21 +1985,1032 @@ var SearchRepository = class {
       collections: collResult.rows.map((r) => ({ id: r.id, name: r.name, count: parseInt(r.count, 10) }))
     };
   }
-  async fetchTagMap(noteIds) {
-    const tagMap = /* @__PURE__ */ new Map();
-    if (noteIds.length === 0) return tagMap;
-    const tagsResult = await this.db.query(
-      `SELECT note_id, tag FROM note_tag WHERE note_id = ANY($1) ORDER BY tag`,
-      [noteIds]
-    );
-    for (const row of tagsResult.rows) {
-      const existing = tagMap.get(row.note_id) ?? [];
-      existing.push(row.tag);
-      tagMap.set(row.note_id, existing);
+  async fetchTagMap(noteIds) {
+    const tagMap = /* @__PURE__ */ new Map();
+    if (noteIds.length === 0) return tagMap;
+    const tagsResult = await this.db.query(
+      `SELECT note_id, tag FROM note_tag WHERE note_id = ANY($1) ORDER BY tag`,
+      [noteIds]
+    );
+    for (const row of tagsResult.rows) {
+      const existing = tagMap.get(row.note_id) ?? [];
+      existing.push(row.tag);
+      tagMap.set(row.note_id, existing);
+    }
+    return tagMap;
+  }
+};
+var CaptureKnowledgeInputSchema = z.object({
+  action: z.enum(["create", "bulk_create", "from_template"]),
+  // For create
+  content: z.string().optional(),
+  title: z.string().optional(),
+  format: z.enum(["markdown", "plain", "html"]).default("markdown"),
+  source: z.string().default("user"),
+  visibility: z.enum(["private", "shared", "public"]).default("private"),
+  tags: z.array(z.string()).optional(),
+  archive_id: z.string().optional(),
+  // For bulk_create
+  notes: z.array(
+    z.object({
+      content: z.string(),
+      title: z.string().optional(),
+      format: z.enum(["markdown", "plain", "html"]).default("markdown"),
+      tags: z.array(z.string()).optional()
+    })
+  ).optional(),
+  // For from_template
+  template: z.string().optional(),
+  variables: z.record(z.string()).optional()
+});
+var ManageNoteInputSchema = z.object({
+  action: z.enum(["update", "delete", "restore", "archive", "unarchive", "star", "unstar"]),
+  note_id: z.string(),
+  // For update
+  title: z.string().optional(),
+  content: z.string().optional(),
+  format: z.string().optional(),
+  visibility: z.string().optional()
+});
+var SearchInputSchema = z.object({
+  query: z.string(),
+  mode: z.enum(["text", "semantic", "hybrid"]).default("text"),
+  limit: z.number().int().min(1).max(100).default(20),
+  offset: z.number().int().min(0).default(0),
+  tags: z.array(z.string()).optional(),
+  collection_id: z.string().optional(),
+  date_from: z.coerce.date().optional(),
+  date_to: z.coerce.date().optional(),
+  is_starred: z.boolean().optional(),
+  is_archived: z.boolean().optional(),
+  format: z.enum(["markdown", "plain", "html"]).optional(),
+  source: z.string().optional(),
+  visibility: z.enum(["private", "shared", "public"]).optional(),
+  include_facets: z.boolean().default(false)
+});
+
+// src/tools/manage-note.ts
+async function manageNote(db, rawInput, events) {
+  const input = ManageNoteInputSchema.parse(rawInput);
+  const repo = new NotesRepository(db, events);
+  switch (input.action) {
+    case "update": {
+      const note = await repo.update(input.note_id, {
+        title: input.title,
+        content: input.content,
+        format: input.format,
+        visibility: input.visibility
+      });
+      return { action: "update", note_id: input.note_id, note };
+    }
+    case "delete": {
+      await repo.delete(input.note_id);
+      return { action: "delete", note_id: input.note_id };
+    }
+    case "restore": {
+      const note = await repo.restore(input.note_id);
+      return { action: "restore", note_id: input.note_id, note };
+    }
+    case "archive": {
+      await repo.archive(input.note_id, true);
+      const note = await repo.get(input.note_id);
+      return { action: "archive", note_id: input.note_id, note };
+    }
+    case "unarchive": {
+      await repo.archive(input.note_id, false);
+      const note = await repo.get(input.note_id);
+      return { action: "unarchive", note_id: input.note_id, note };
+    }
+    case "star": {
+      await repo.star(input.note_id, true);
+      const note = await repo.get(input.note_id);
+      return { action: "star", note_id: input.note_id, note };
+    }
+    case "unstar": {
+      await repo.star(input.note_id, false);
+      const note = await repo.get(input.note_id);
+      return { action: "unstar", note_id: input.note_id, note };
+    }
+  }
+}
+
+// src/data-backend.ts
+var SEMANTIC_RANK = {
+  none: 0,
+  "cosine-small": 1,
+  "ann-full": 2,
+  server: 3
+};
+var STARTUP_RANK = {
+  instant: 0,
+  "index-build": 1,
+  network: 2
+};
+function missingFor(request, caps) {
+  const missing = [];
+  if (request.read && !caps.read) missing.push("read");
+  if (request.write && !caps.write) missing.push("write");
+  if (request.merge && !caps.merge) missing.push("merge");
+  if (request.multiUser && !caps.multiUser) missing.push("multiUser");
+  if (request.semantic && SEMANTIC_RANK[caps.semantic] < SEMANTIC_RANK[request.semantic]) {
+    missing.push(`semantic:${request.semantic}`);
+  }
+  return missing;
+}
+function selectBackend(request, available) {
+  const candidates = available.map((backend) => ({
+    backend,
+    missing: missingFor(request, backend.capabilities)
+  }));
+  if (candidates.length === 0) {
+    return { backend: null, capabilities: null, missing: [], candidates };
+  }
+  const lighter = (a, b) => STARTUP_RANK[a.capabilities.startupCost] - STARTUP_RANK[b.capabilities.startupCost];
+  const fullySatisfying = candidates.filter((c) => c.missing.length === 0);
+  const pool = fullySatisfying.length > 0 ? fullySatisfying : candidates;
+  const chosen = [...pool].sort((a, b) => {
+    if (a.missing.length !== b.missing.length) return a.missing.length - b.missing.length;
+    return lighter(a.backend, b.backend);
+  })[0];
+  return {
+    backend: chosen.backend,
+    capabilities: chosen.backend.capabilities,
+    missing: chosen.missing,
+    candidates
+  };
+}
+function toIso(d) {
+  return d instanceof Date ? d.toISOString() : String(d);
+}
+function summaryToBackend(s) {
+  return {
+    id: s.id,
+    title: s.title,
+    tags: s.tags,
+    createdAt: toIso(s.created_at),
+    updatedAt: toIso(s.updated_at),
+    source: s.source,
+    starred: s.is_starred,
+    archived: s.is_archived
+  };
+}
+function searchResultToBackend(r) {
+  return {
+    id: r.id,
+    title: r.title,
+    tags: r.tags,
+    createdAt: toIso(r.created_at),
+    updatedAt: toIso(r.updated_at)
+  };
+}
+function createPGliteBackend(db, options = {}) {
+  const semanticAvailable = options.semanticAvailable ?? false;
+  const notes = new NotesRepository(db);
+  const search = new SearchRepository(db, semanticAvailable);
+  return {
+    id: options.id ?? "pglite",
+    capabilities: {
+      read: true,
+      write: true,
+      merge: true,
+      multiUser: false,
+      semantic: semanticAvailable ? "ann-full" : "none",
+      startupCost: "index-build"
+    },
+    async listNotes(o) {
+      const r = await notes.list({ offset: o?.offset, limit: o?.limit });
+      return { items: r.items.map(summaryToBackend), total: r.total };
+    },
+    async getNote(id) {
+      try {
+        const f = await notes.get(id);
+        return summaryToBackend(f);
+      } catch {
+        return null;
+      }
+    },
+    async search(query, o) {
+      const r = await search.search(query, {
+        limit: o?.limit,
+        offset: o?.offset,
+        tags: o?.tags,
+        source: o?.source?.[0],
+        include_facets: true
+      });
+      const hits = r.results.map((res) => ({
+        note: searchResultToBackend(res),
+        rank: res.rank,
+        snippet: res.snippet
+      }));
+      const facets = r.facets ? {
+        tags: Object.fromEntries(r.facets.tags.map((t) => [t.tag, t.count]))
+      } : void 0;
+      return { hits, total: r.total, facets };
+    },
+    async getNoteFull(id) {
+      try {
+        const f = await notes.get(id);
+        return { ...summaryToBackend(f), content: f.current.content };
+      } catch {
+        return null;
+      }
+    },
+    async manageNote(input) {
+      return manageNote(db, input);
+    }
+  };
+}
+function shardNoteToBackend(n) {
+  return {
+    id: n.id,
+    title: n.title,
+    tags: n.tags,
+    createdAt: toIso(n.created_at),
+    updatedAt: toIso(n.updated_at),
+    source: n.source,
+    starred: n.is_starred,
+    archived: n.is_archived
+  };
+}
+function createShardBackend(reader, options = {}) {
+  const semantic = options.semantic ?? "none";
+  return {
+    id: options.id ?? "static-file",
+    capabilities: {
+      read: true,
+      write: false,
+      merge: false,
+      multiUser: false,
+      semantic,
+      startupCost: "instant"
+    },
+    async listNotes(o) {
+      const r = await reader.listNotes(o);
+      return { items: r.items.map(shardNoteToBackend), total: r.total };
+    },
+    async getNote(id) {
+      const n = await reader.getNote(id);
+      return n ? shardNoteToBackend(n) : null;
+    },
+    async search(query, o) {
+      const r = await reader.search(query, { ...o, rank: true, snippets: true });
+      const hits = r.rankedItems ? r.rankedItems.map((it) => ({
+        note: shardNoteToBackend(it.note),
+        rank: it.rank,
+        snippet: it.snippet
+      })) : r.items.map((note) => ({ note: shardNoteToBackend(note) }));
+      return { hits, total: r.total, facets: r.facets };
+    },
+    async getNoteFull(id) {
+      const f = await reader.getNoteFull(id);
+      if (!f) return null;
+      return {
+        ...shardNoteToBackend(f.note),
+        content: f.note.revised_content ?? f.note.original_content
+      };
+    },
+    async semantic(query, k) {
+      const r = await reader.semantic(query, k);
+      return r.map(({ note, score }) => ({ note: shardNoteToBackend(note), rank: score }));
+    }
+  };
+}
+
+// src/worker/worker-client.ts
+var PGliteWorkerClient = class {
+  constructor(worker) {
+    this.worker = worker;
+    this.readyPromise = new Promise((resolve) => {
+      this.resolveReady = resolve;
+    });
+    this.worker.addEventListener("message", (e) => {
+      const msg = e.data;
+      if (msg.type === "READY") {
+        this.resolveReady();
+        return;
+      }
+      if (!("id" in msg)) return;
+      const pending = this.pending.get(msg.id);
+      if (!pending) return;
+      this.pending.delete(msg.id);
+      if (msg.type === "ERROR") {
+        pending.reject(new Error(msg.error));
+      } else {
+        pending.resolve(msg);
+      }
+    });
+  }
+  pending = /* @__PURE__ */ new Map();
+  readyPromise;
+  resolveReady;
+  /** Resolves when the worker broadcasts READY after database initialisation. */
+  async waitReady() {
+    return this.readyPromise;
+  }
+  send(request) {
+    const id = generateId();
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, {
+        resolve,
+        reject
+      });
+      this.worker.postMessage({ ...request, id });
+    });
+  }
+  async query(sql, params) {
+    const resp = await this.send({ type: "QUERY", sql, params });
+    return { rows: resp.rows, fields: resp.fields };
+  }
+  async exec(sql) {
+    await this.send({ type: "EXEC", sql });
+  }
+  async transaction(fn) {
+    const resp = await this.send({ type: "BEGIN" });
+    const txId = resp.txId;
+    const proxy = new TransactionProxy(this, txId);
+    try {
+      const result = await fn(proxy);
+      await this.send({ type: "COMMIT", txId });
+      return result;
+    } catch (err) {
+      await this.send({ type: "ROLLBACK", txId }).catch(() => {
+      });
+      throw err;
+    }
+  }
+  /** Forward TX_QUERY for TransactionProxy — not part of the public surface. */
+  async _txQuery(txId, sql, params) {
+    const resp = await this.send({
+      type: "TX_QUERY",
+      txId,
+      sql,
+      params
+    });
+    return { rows: resp.rows };
+  }
+  /** Forward TX_EXEC for TransactionProxy — not part of the public surface. */
+  async _txExec(txId, sql) {
+    await this.send({ type: "TX_EXEC", txId, sql });
+  }
+  async ping() {
+    await this.send({ type: "PING" });
+  }
+  async close() {
+    await this.send({ type: "CLOSE" });
+    this.worker.terminate();
+  }
+};
+var TransactionProxy = class {
+  constructor(client, txId) {
+    this.client = client;
+    this.txId = txId;
+  }
+  async query(sql, params) {
+    return this.client._txQuery(this.txId, sql, params);
+  }
+  async exec(sql) {
+    return this.client._txExec(this.txId, sql);
+  }
+};
+
+// src/storage-backend.ts
+var PGliteStorageBackend = class {
+  constructor(id, db) {
+    this.id = id;
+    this.db = db;
+  }
+  mode = "readwrite";
+  query(sql, params) {
+    return this.db.query(sql, params);
+  }
+  exec(sql) {
+    return this.db.exec(sql);
+  }
+  async transaction(fn) {
+    return this.db.transaction((tx) => fn(tx));
+  }
+  close() {
+    return this.db.close();
+  }
+};
+var PGliteStorageBackendFactory = class {
+  async open(input) {
+    const db = await createPGliteInstance(input.persistence, input.archiveName);
+    return new PGliteStorageBackend(`pglite:${input.persistence}:${input.archiveName}`, db);
+  }
+};
+var defaultStorageBackendFactory = new PGliteStorageBackendFactory();
+var PGliteWorkerStorageBackend = class {
+  constructor(id, client) {
+    this.id = id;
+    this.client = client;
+  }
+  mode = "readwrite";
+  query(sql, params) {
+    return this.client.query(sql, params);
+  }
+  exec(sql) {
+    return this.client.exec(sql);
+  }
+  transaction(fn) {
+    return this.client.transaction(fn);
+  }
+  close() {
+    return this.client.close();
+  }
+};
+var PGliteWorkerStorageBackendFactory = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async open(input) {
+    const worker = this.options.createWorker();
+    const client = new PGliteWorkerClient(worker);
+    worker.postMessage({
+      type: "INIT",
+      persistence: input.persistence,
+      archiveName: input.archiveName
+    });
+    await client.waitReady();
+    return new PGliteWorkerStorageBackend(`pglite-worker:${input.persistence}:${input.archiveName}`, client);
+  }
+};
+
+// src/capability-manager.ts
+var VALID_TRANSITIONS = {
+  enable: ["unloaded", "disabled", "error"],
+  disable: ["ready"],
+  markReady: ["loading"],
+  markError: ["loading"]
+};
+function assertTransition(method, name, current) {
+  const allowed = VALID_TRANSITIONS[method];
+  if (!allowed.includes(current)) {
+    throw new Error(
+      `CapabilityManager.${method}('${name}'): invalid transition from state '${current}'. Allowed source states: ${allowed.join(", ")}.`
+    );
+  }
+}
+var CapabilityManager = class {
+  constructor(events) {
+    this.events = events;
+    const names = ["semantic", "llm", "audio", "vision", "pdf"];
+    for (const name of names) {
+      this.capabilities.set(name, { name, state: "unloaded" });
+    }
+  }
+  capabilities = /* @__PURE__ */ new Map();
+  loaders = /* @__PURE__ */ new Map();
+  progressMessages = /* @__PURE__ */ new Map();
+  /**
+   * Register an async loader for a capability.
+   * Called by enable(); if no loader is registered the capability transitions
+   * directly to ready (useful for capabilities that require no async init).
+   */
+  registerLoader(name, loader) {
+    this.loaders.set(name, loader);
+  }
+  getState(name) {
+    return this.capabilities.get(name)?.state ?? "unloaded";
+  }
+  isReady(name) {
+    return this.getState(name) === "ready";
+  }
+  /**
+   * Enable a capability.
+   * Valid from: unloaded, disabled, error (retry).
+   * Runs the registered loader if present; transitions to ready on success,
+   * error on failure.
+   */
+  async enable(name) {
+    const entry = this.capabilities.get(name);
+    if (!entry) return;
+    if (entry.state === "ready" || entry.state === "loading") return;
+    assertTransition("enable", name, entry.state);
+    entry.state = "loading";
+    entry.error = void 0;
+    this.events.emit("capability.loading", { name });
+    const loader = this.loaders.get(name);
+    if (!loader) {
+      entry.state = "ready";
+      this.events.emit("capability.ready", { name });
+      return;
+    }
+    try {
+      await loader();
+      if (entry.state === "loading") {
+        entry.state = "ready";
+        this.events.emit("capability.ready", { name });
+      }
+    } catch (err) {
+      if (entry.state === "loading") {
+        const message = err instanceof Error ? err.message : String(err);
+        entry.state = "error";
+        entry.error = message;
+      }
+    }
+  }
+  /**
+   * Disable a ready capability.
+   * Valid from: ready only.
+   */
+  disable(name) {
+    const entry = this.capabilities.get(name);
+    if (!entry) return;
+    assertTransition("disable", name, entry.state);
+    entry.state = "disabled";
+    this.events.emit("capability.disabled", { name });
+  }
+  /**
+   * Mark a loading capability as ready (external use, e.g. bridge protocol).
+   * Valid from: loading only.
+   */
+  markReady(name) {
+    const entry = this.capabilities.get(name);
+    if (!entry) return;
+    assertTransition("markReady", name, entry.state);
+    entry.state = "ready";
+    entry.error = void 0;
+    this.events.emit("capability.ready", { name });
+  }
+  /**
+   * Mark a loading capability as errored (external use, e.g. bridge protocol).
+   * Valid from: loading only.
+   */
+  markError(name, error) {
+    const entry = this.capabilities.get(name);
+    if (!entry) return;
+    assertTransition("markError", name, entry.state);
+    entry.state = "error";
+    entry.error = error;
+  }
+  /**
+   * Report loading progress (0-100).
+   * Emits capability.loading with progress if the capability is currently loading.
+   * No-op if the capability is not in loading state.
+   */
+  reportProgress(name, progress) {
+    const entry = this.capabilities.get(name);
+    if (!entry || entry.state !== "loading") return;
+    this.events.emit("capability.loading", { name, progress });
+  }
+  /** Set a human-readable progress message for a loading capability */
+  setProgress(name, message) {
+    this.progressMessages.set(name, message);
+    this.events.emit("capability.loading", { name, progress: -1 });
+  }
+  /** Get the current progress message for a capability */
+  getProgress(name) {
+    return this.progressMessages.get(name);
+  }
+  getError(name) {
+    return this.capabilities.get(name)?.error;
+  }
+  listAll() {
+    return Array.from(this.capabilities.values()).map(({ name, state }) => ({
+      name,
+      state
+    }));
+  }
+};
+
+// src/migration-runner.ts
+var MigrationRunner = class {
+  constructor(db, events) {
+    this.db = db;
+    this.events = events;
+  }
+  async ensureSchemaTable() {
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_version (
+        version INTEGER NOT NULL,
+        name TEXT NOT NULL,
+        applied_at TIMESTAMPTZ DEFAULT now(),
+        PRIMARY KEY (version)
+      )
+    `);
+  }
+  async getCurrentVersion() {
+    const result = await this.db.query(
+      "SELECT COALESCE(MAX(version), 0) AS version FROM schema_version"
+    );
+    return result.rows[0].version;
+  }
+  async apply(migrations) {
+    await this.ensureSchemaTable();
+    const currentVersion = await this.getCurrentVersion();
+    const pending = migrations.filter((m) => m.version > currentVersion).sort((a, b) => a.version - b.version);
+    let applied = 0;
+    for (const migration of pending) {
+      await this.db.transaction(async (tx) => {
+        await tx.exec(migration.sql);
+        await tx.query(
+          "INSERT INTO schema_version (version, name) VALUES ($1, $2)",
+          [migration.version, migration.name]
+        );
+      });
+      applied++;
+      this.events?.emit("migration.applied", { version: migration.version });
+    }
+    return applied;
+  }
+  async getAppliedMigrations() {
+    const result = await this.db.query(
+      "SELECT version, name FROM schema_version ORDER BY version"
+    );
+    return result.rows;
+  }
+};
+
+// src/archive-manager.ts
+var ArchiveManager = class {
+  constructor(persistenceOrFactory, events, persistenceOverride) {
+    this.events = events;
+    if (typeof persistenceOrFactory === "string") {
+      this.persistence = persistenceOrFactory;
+      this.backendFactory = defaultStorageBackendFactory;
+    } else {
+      this.persistence = persistenceOverride ?? "memory";
+      this.backendFactory = persistenceOrFactory;
+    }
+    this.archives.set("default", {
+      name: "default",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  currentArchive = "default";
+  db = null;
+  archives = /* @__PURE__ */ new Map();
+  persistence;
+  backendFactory;
+  getCurrentArchiveName() {
+    return this.currentArchive;
+  }
+  getDb() {
+    return this.db;
+  }
+  async open(archiveName = "default") {
+    if (this.db) {
+      await this.db.close();
+    }
+    this.db = await this.backendFactory.open({
+      archiveName,
+      persistence: this.persistence
+    });
+    const runner = new MigrationRunner(this.db, this.events);
+    await runner.apply(allMigrations);
+    this.currentArchive = archiveName;
+    if (!this.archives.has(archiveName)) {
+      this.archives.set(archiveName, {
+        name: archiveName,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    this.events?.emit("archive.switched", { name: archiveName });
+    return this.db;
+  }
+  /**
+   * Adopt an already-created backend WITHOUT running migrations — for a backend
+   * whose schema is already present, e.g. a PGlite restored from a physical
+   * data-dir snapshot (issue #187, `restoreDbSnapshot`). Running migrations here
+   * would be wrong: the restored dir already carries them (and the HNSW index).
+   */
+  async adopt(backend, archiveName = "default") {
+    if (this.db) {
+      await this.db.close();
+    }
+    this.db = backend;
+    this.currentArchive = archiveName;
+    if (!this.archives.has(archiveName)) {
+      this.archives.set(archiveName, {
+        name: archiveName,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    this.events?.emit("archive.switched", { name: archiveName });
+    return this.db;
+  }
+  async create(archiveName) {
+    if (this.archives.has(archiveName)) {
+      throw new Error(`Archive '${archiveName}' already exists`);
+    }
+    return this.open(archiveName);
+  }
+  async switchTo(archiveName) {
+    return this.open(archiveName);
+  }
+  async delete(archiveName) {
+    if (archiveName === "default") {
+      throw new Error("Cannot delete the default archive");
+    }
+    if (this.currentArchive === archiveName && this.db) {
+      await this.db.close();
+      this.db = null;
+    }
+    this.archives.delete(archiveName);
+  }
+  listArchives() {
+    return Array.from(this.archives.values());
+  }
+  async close() {
+    if (this.db) {
+      await this.db.close();
+      this.db = null;
+    }
+  }
+};
+
+// src/create-fortemi.ts
+function createFortemi(config) {
+  const events = new TypedEventBus();
+  return {
+    events,
+    config,
+    destroy() {
+      events.removeAllListeners();
+    }
+  };
+}
+
+// src/service-worker/register.ts
+async function registerServiceWorker(swUrl = "/sw.js") {
+  if (!("serviceWorker" in navigator)) {
+    return { registered: false, error: "Service Workers not supported" };
+  }
+  try {
+    const registration = await navigator.serviceWorker.register(swUrl, {
+      type: "module",
+      scope: "/"
+    });
+    if (registration.installing) {
+      await new Promise((resolve) => {
+        registration.installing.addEventListener("statechange", function handler() {
+          if (this.state === "activated") {
+            this.removeEventListener("statechange", handler);
+            resolve();
+          }
+        });
+      });
+    }
+    return { registered: true, registration };
+  } catch (err) {
+    return {
+      registered: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/service-worker/routes.ts
+async function parseJsonBody(request) {
+  try {
+    return await request.json();
+  } catch {
+    return null;
+  }
+}
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function errorResponse(message, status) {
+  return jsonResponse({ error: message }, status);
+}
+var DB_NOT_CONNECTED = "Database not connected. REST API available in standalone mode only.";
+function createRoutes() {
+  return [
+    // GET /api/v1/notes — list notes
+    {
+      method: "GET",
+      pattern: /^\/api\/v1\/notes\/?$/,
+      handler: async () => {
+        return errorResponse(DB_NOT_CONNECTED, 503);
+      }
+    },
+    // POST /api/v1/notes — create note
+    {
+      method: "POST",
+      pattern: /^\/api\/v1\/notes\/?$/,
+      handler: async (request) => {
+        const body = await parseJsonBody(request);
+        if (body === null) return errorResponse("Invalid JSON body", 400);
+        return errorResponse(DB_NOT_CONNECTED, 503);
+      }
+    },
+    // POST /api/v1/notes/:id/restore — restore soft-deleted note (must come before /:id)
+    {
+      method: "POST",
+      pattern: /^\/api\/v1\/notes\/([^/]+)\/restore\/?$/,
+      handler: async () => {
+        return errorResponse(DB_NOT_CONNECTED, 503);
+      }
+    },
+    // POST /api/v1/notes/:id/star — star or unstar a note
+    {
+      method: "POST",
+      pattern: /^\/api\/v1\/notes\/([^/]+)\/star\/?$/,
+      handler: async () => {
+        return errorResponse(DB_NOT_CONNECTED, 503);
+      }
+    },
+    // POST /api/v1/notes/:id/archive — archive or unarchive a note
+    {
+      method: "POST",
+      pattern: /^\/api\/v1\/notes\/([^/]+)\/archive\/?$/,
+      handler: async () => {
+        return errorResponse(DB_NOT_CONNECTED, 503);
+      }
+    },
+    // GET /api/v1/notes/:id — get a single note
+    {
+      method: "GET",
+      pattern: /^\/api\/v1\/notes\/([^/]+)\/?$/,
+      handler: async () => {
+        return errorResponse(DB_NOT_CONNECTED, 503);
+      }
+    },
+    // PUT /api/v1/notes/:id — update a note
+    {
+      method: "PUT",
+      pattern: /^\/api\/v1\/notes\/([^/]+)\/?$/,
+      handler: async () => {
+        return errorResponse(DB_NOT_CONNECTED, 503);
+      }
+    },
+    // DELETE /api/v1/notes/:id — soft-delete a note
+    {
+      method: "DELETE",
+      pattern: /^\/api\/v1\/notes\/([^/]+)\/?$/,
+      handler: async () => {
+        return errorResponse(DB_NOT_CONNECTED, 503);
+      }
+    },
+    // GET /api/v1/search — full-text search
+    {
+      method: "GET",
+      pattern: /^\/api\/v1\/search\/?$/,
+      handler: async () => {
+        return errorResponse(DB_NOT_CONNECTED, 503);
+      }
+    }
+  ];
+}
+function matchRoute(routes, request, url) {
+  for (const route of routes) {
+    if (request.method !== route.method) continue;
+    const match = url.pathname.match(route.pattern);
+    if (match) return route;
+  }
+  return null;
+}
+
+// src/blob-store.ts
+function hashPath(hash) {
+  return {
+    dir1: hash.slice(0, 2),
+    dir2: hash.slice(2, 4),
+    filename: hash
+  };
+}
+var OpfsBlobStore = class {
+  constructor(archiveName) {
+    this.archiveName = archiveName;
+  }
+  async getRoot() {
+    const root = await navigator.storage.getDirectory();
+    return root.getDirectoryHandle(`fortemi-${this.archiveName}-blobs`, { create: true });
+  }
+  async getFileHandle(hash, create) {
+    const { dir1, dir2, filename } = hashPath(hash);
+    try {
+      const root = await this.getRoot();
+      const d1 = await root.getDirectoryHandle(dir1, { create });
+      const d2 = await d1.getDirectoryHandle(dir2, { create });
+      return d2.getFileHandle(filename, { create });
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "NotFoundError") {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async write(hash, data) {
+    const fh = await this.getFileHandle(hash, true);
+    if (!fh) throw new Error(`OpfsBlobStore: could not create file for hash ${hash}`);
+    const writable = await fh.createWritable();
+    await writable.write(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
+    await writable.close();
+  }
+  async read(hash) {
+    const fh = await this.getFileHandle(hash, false);
+    if (!fh) return null;
+    const file = await fh.getFile();
+    const buffer = await file.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  async remove(hash) {
+    const { dir1, dir2, filename } = hashPath(hash);
+    try {
+      const root = await this.getRoot();
+      const d1 = await root.getDirectoryHandle(dir1, { create: false });
+      const d2 = await d1.getDirectoryHandle(dir2, { create: false });
+      await d2.removeEntry(filename);
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "NotFoundError") {
+        return;
+      }
+      throw err;
+    }
+  }
+  async exists(hash) {
+    const fh = await this.getFileHandle(hash, false);
+    return fh !== null;
+  }
+};
+var IDB_STORE = "blobs";
+var IDB_VERSION = 1;
+function openDb(dbName) {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(dbName, IDB_VERSION);
+    req.onupgradeneeded = () => {
+      req.result.createObjectStore(IDB_STORE);
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+var IdbBlobStore = class {
+  dbName;
+  _db = null;
+  constructor(archiveName) {
+    this.dbName = `fortemi-${archiveName}-blobs`;
+  }
+  async db() {
+    if (!this._db) {
+      this._db = await openDb(this.dbName);
     }
-    return tagMap;
+    return this._db;
+  }
+  async write(hash, data) {
+    const db = await this.db();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(IDB_STORE, "readwrite");
+      tx.objectStore(IDB_STORE).put(data, hash);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async read(hash) {
+    const db = await this.db();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(IDB_STORE, "readonly");
+      const req = tx.objectStore(IDB_STORE).get(hash);
+      req.onsuccess = () => resolve(req.result ?? null);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async remove(hash) {
+    const db = await this.db();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(IDB_STORE, "readwrite");
+      tx.objectStore(IDB_STORE).delete(hash);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async exists(hash) {
+    const db = await this.db();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(IDB_STORE, "readonly");
+      const req = tx.objectStore(IDB_STORE).count(hash);
+      req.onsuccess = () => resolve(req.result > 0);
+      req.onerror = () => reject(req.error);
+    });
+  }
+};
+var MemoryBlobStore = class {
+  store = /* @__PURE__ */ new Map();
+  async write(hash, data) {
+    this.store.set(hash, data);
+  }
+  async read(hash) {
+    return this.store.get(hash) ?? null;
+  }
+  async remove(hash) {
+    this.store.delete(hash);
+  }
+  async exists(hash) {
+    return this.store.has(hash);
   }
 };
+function createBlobStore(archiveName) {
+  if (typeof navigator !== "undefined" && "storage" in navigator && "getDirectory" in navigator.storage) {
+    return new OpfsBlobStore(archiveName);
+  }
+  return new IdbBlobStore(archiveName);
+}
 
 // src/repositories/graph-repository.ts
 var SIMILARITY_GRAPH_ALGORITHM = "knn-batched-v1";
@@ -3716,54 +4119,6 @@ var SkosRepository = class {
     return result.rows;
   }
 };
-var CaptureKnowledgeInputSchema = z.object({
-  action: z.enum(["create", "bulk_create", "from_template"]),
-  // For create
-  content: z.string().optional(),
-  title: z.string().optional(),
-  format: z.enum(["markdown", "plain", "html"]).default("markdown"),
-  source: z.string().default("user"),
-  visibility: z.enum(["private", "shared", "public"]).default("private"),
-  tags: z.array(z.string()).optional(),
-  archive_id: z.string().optional(),
-  // For bulk_create
-  notes: z.array(
-    z.object({
-      content: z.string(),
-      title: z.string().optional(),
-      format: z.enum(["markdown", "plain", "html"]).default("markdown"),
-      tags: z.array(z.string()).optional()
-    })
-  ).optional(),
-  // For from_template
-  template: z.string().optional(),
-  variables: z.record(z.string()).optional()
-});
-var ManageNoteInputSchema = z.object({
-  action: z.enum(["update", "delete", "restore", "archive", "unarchive", "star", "unstar"]),
-  note_id: z.string(),
-  // For update
-  title: z.string().optional(),
-  content: z.string().optional(),
-  format: z.string().optional(),
-  visibility: z.string().optional()
-});
-var SearchInputSchema = z.object({
-  query: z.string(),
-  mode: z.enum(["text", "semantic", "hybrid"]).default("text"),
-  limit: z.number().int().min(1).max(100).default(20),
-  offset: z.number().int().min(0).default(0),
-  tags: z.array(z.string()).optional(),
-  collection_id: z.string().optional(),
-  date_from: z.coerce.date().optional(),
-  date_to: z.coerce.date().optional(),
-  is_starred: z.boolean().optional(),
-  is_archived: z.boolean().optional(),
-  format: z.enum(["markdown", "plain", "html"]).optional(),
-  source: z.string().optional(),
-  visibility: z.enum(["private", "shared", "public"]).optional(),
-  include_facets: z.boolean().default(false)
-});
 
 // src/tools/capture-knowledge.ts
 async function captureKnowledge(db, rawInput, events) {
@@ -3816,51 +4171,6 @@ async function captureKnowledge(db, rawInput, events) {
   }
 }
 
-// src/tools/manage-note.ts
-async function manageNote(db, rawInput, events) {
-  const input = ManageNoteInputSchema.parse(rawInput);
-  const repo = new NotesRepository(db, events);
-  switch (input.action) {
-    case "update": {
-      const note = await repo.update(input.note_id, {
-        title: input.title,
-        content: input.content,
-        format: input.format,
-        visibility: input.visibility
-      });
-      return { action: "update", note_id: input.note_id, note };
-    }
-    case "delete": {
-      await repo.delete(input.note_id);
-      return { action: "delete", note_id: input.note_id };
-    }
-    case "restore": {
-      const note = await repo.restore(input.note_id);
-      return { action: "restore", note_id: input.note_id, note };
-    }
-    case "archive": {
-      await repo.archive(input.note_id, true);
-      const note = await repo.get(input.note_id);
-      return { action: "archive", note_id: input.note_id, note };
-    }
-    case "unarchive": {
-      await repo.archive(input.note_id, false);
-      const note = await repo.get(input.note_id);
-      return { action: "unarchive", note_id: input.note_id, note };
-    }
-    case "star": {
-      await repo.star(input.note_id, true);
-      const note = await repo.get(input.note_id);
-      return { action: "star", note_id: input.note_id, note };
-    }
-    case "unstar": {
-      await repo.star(input.note_id, false);
-      const note = await repo.get(input.note_id);
-      return { action: "unstar", note_id: input.note_id, note };
-    }
-  }
-}
-
 // src/tools/search.ts
 async function searchTool(db, rawInput) {
   const input = SearchInputSchema.parse(rawInput);
@@ -5104,13 +5414,13 @@ var OpenAICompatibleProvider = class {
       throw new Error("Streaming not supported: response body is null");
     }
     const reader = response.body.getReader();
-    const decoder2 = new TextDecoder();
+    const decoder4 = new TextDecoder();
     let buffer = "";
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        buffer += decoder2.decode(value, { stream: true });
+        buffer += decoder4.decode(value, { stream: true });
         const lines = buffer.split("\n");
         buffer = lines.pop() ?? "";
         for (const line of lines) {
@@ -6141,8 +6451,21 @@ async function exportShard(db, options) {
     tags: tagsByNote.get(row.id) ?? []
   }));
   const exportedNoteIds = new Set(notes.map((n) => n.id));
-  const notesJsonl = notes.map((n) => JSON.stringify(noteToShard(n))).join("\n");
-  files.set("notes.jsonl", encoder.encode(notesJsonl));
+  const shardNotes = notes.map((n) => noteToShard(n));
+  let layout;
+  const clusterSize = options?.clusterNotesSize;
+  if (clusterSize && Number.isInteger(clusterSize) && clusterSize > 0 && shardNotes.length > 0) {
+    const clusters = [];
+    for (let offset = 0; offset < shardNotes.length; offset += clusterSize) {
+      const slice = shardNotes.slice(offset, offset + clusterSize);
+      const href = `notes/${String(offset).padStart(6, "0")}.jsonl`;
+      clusters.push({ href, offset, count: slice.length });
+      files.set(href, encoder.encode(slice.map((n) => JSON.stringify(n)).join("\n")));
+    }
+    layout = { clusters: { notes: clusters } };
+  } else {
+    files.set("notes.jsonl", encoder.encode(shardNotes.map((n) => JSON.stringify(n)).join("\n")));
+  }
   components.push("notes");
   counts.notes = notes.length;
   const collectionRows = await db.query(
@@ -6375,7 +6698,8 @@ async function exportShard(db, options) {
     components,
     counts,
     checksums,
-    min_reader_version: "1.0.0"
+    min_reader_version: "1.0.0",
+    ...layout ? { layout } : {}
   };
   files.set("manifest.json", encoder.encode(JSON.stringify(manifest, null, 2)));
   return packTarGz(files);
@@ -6489,7 +6813,8 @@ async function importShard(db, data, options) {
     };
   }
   report?.({ phase: "validate", done: 1, total: 1 });
-  const parsedNotes = parseJsonl(files.get("notes.jsonl"));
+  const noteClusters = manifest.layout?.clusters?.notes;
+  const parsedNotes = noteClusters && noteClusters.length > 0 ? [...noteClusters].sort((a, b) => a.offset - b.offset).flatMap((ref) => parseJsonl(files.get(ref.href))) : parseJsonl(files.get("notes.jsonl"));
   const parsedCollections = parseJsonArray(files.get("collections.json"));
   parseJsonArray(files.get("tags.json"));
   const parsedLinks = parseJsonl(files.get("links.jsonl"));
@@ -6915,6 +7240,354 @@ function parseJsonArray(data) {
   return JSON.parse(decoder.decode(data));
 }
 
+// src/shard/shard-reader.ts
+var decoder2 = new TextDecoder();
+function parseJsonlBytes(data) {
+  if (!data || data.byteLength === 0) return [];
+  return decoder2.decode(data).split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+}
+function parseJsonArrayBytes(data) {
+  if (!data || data.byteLength === 0) return [];
+  return JSON.parse(decoder2.decode(data));
+}
+var DEFAULT_WEIGHTS = { title: 4, content: 1, tag: 2 };
+async function toBytes(blobOrBytes) {
+  if (blobOrBytes instanceof Uint8Array) return blobOrBytes;
+  return new Uint8Array(await blobOrBytes.arrayBuffer());
+}
+var PackedComponentStore = class {
+  manifest;
+  files;
+  constructor(files, manifest) {
+    this.files = files;
+    this.manifest = manifest;
+  }
+  read(filename) {
+    return Promise.resolve(this.files.get(filename));
+  }
+};
+var UrlComponentStore = class {
+  manifest;
+  baseUrl;
+  fetchImpl;
+  cache = /* @__PURE__ */ new Map();
+  constructor(baseUrl, fetchImpl, manifest) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.fetchImpl = fetchImpl;
+    this.manifest = manifest;
+  }
+  async read(filename) {
+    if (this.cache.has(filename)) return this.cache.get(filename);
+    const response = await this.fetchImpl(`${this.baseUrl}/${filename}`);
+    if (!response.ok) {
+      this.cache.set(filename, void 0);
+      return void 0;
+    }
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    this.cache.set(filename, bytes);
+    return bytes;
+  }
+};
+async function resolveStore(source) {
+  if (typeof source === "object" && "baseUrl" in source) {
+    const fetchImpl = source.fetchImpl ?? globalThis.fetch;
+    const base = source.baseUrl.replace(/\/$/, "");
+    const manifestResponse = await fetchImpl(`${base}/manifest.json`);
+    if (!manifestResponse.ok) {
+      throw new Error(`Failed to fetch shard manifest (${manifestResponse.status}): ${base}/manifest.json`);
+    }
+    const manifest2 = await manifestResponse.json();
+    return new UrlComponentStore(base, fetchImpl, manifest2);
+  }
+  const bytes = await toBytes(source);
+  const files = unpackTarGz(bytes);
+  const manifestBytes = files.get("manifest.json");
+  if (!manifestBytes) throw new Error("Missing manifest.json in shard archive");
+  const manifest = JSON.parse(decoder2.decode(manifestBytes));
+  return new PackedComponentStore(files, manifest);
+}
+function tokenize(query) {
+  return query.toLowerCase().split(/[^a-z0-9]+/i).filter((token) => token.length > 0);
+}
+function noteSearchText(note) {
+  return `${note.title ?? ""} ${note.original_content} ${note.revised_content ?? ""}`.toLowerCase();
+}
+function countOccurrences(haystack, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let index = haystack.indexOf(needle);
+  while (index !== -1) {
+    count += 1;
+    index = haystack.indexOf(needle, index + needle.length);
+  }
+  return count;
+}
+function noteMatchesTokens(note, tokens) {
+  if (tokens.length === 0) return true;
+  const text = noteSearchText(note);
+  const tagText = note.tags.join(" ").toLowerCase();
+  return tokens.every((token) => text.includes(token) || tagText.includes(token));
+}
+function rankNote(note, tokens, weights) {
+  if (tokens.length === 0) return 0;
+  const title = (note.title ?? "").toLowerCase();
+  const content = `${note.original_content} ${note.revised_content ?? ""}`.toLowerCase();
+  const tagText = note.tags.join(" ").toLowerCase();
+  let score = 0;
+  for (const token of tokens) {
+    score += countOccurrences(title, token) * weights.title;
+    score += countOccurrences(content, token) * weights.content;
+    if (tagText.includes(token)) score += weights.tag;
+  }
+  return score;
+}
+function makeSnippet(note, tokens, length) {
+  const content = `${note.original_content} ${note.revised_content ?? ""}`.trim();
+  if (tokens.length === 0) return content.slice(0, length);
+  const lower = content.toLowerCase();
+  const firstAt = tokens.map((token) => lower.indexOf(token)).filter((index) => index !== -1).sort((a, b) => a - b)[0] ?? 0;
+  const start = Math.max(0, firstAt - Math.floor(length / 3));
+  return (start > 0 ? "\u2026" : "") + content.slice(start, start + length) + (start + length < content.length ? "\u2026" : "");
+}
+function passesFilters(note, options) {
+  if (!options.includeDeleted && note.deleted_at) return false;
+  if (options.includeArchived === false && note.archived) return false;
+  if (options.tags && !options.tags.every((tag) => note.tags.includes(tag))) return false;
+  if (options.source && !options.source.includes(note.source)) return false;
+  return true;
+}
+function facetCounts(notes) {
+  const tags = {};
+  const source = {};
+  for (const note of notes) {
+    for (const tag of note.tags) tags[tag] = (tags[tag] ?? 0) + 1;
+    source[note.source] = (source[note.source] ?? 0) + 1;
+  }
+  return { tags, source };
+}
+var ShardReaderImpl = class {
+  manifest;
+  store;
+  options;
+  noteClusterCache = /* @__PURE__ */ new Map();
+  allNotes = null;
+  links = null;
+  noteSkos = null;
+  concepts = null;
+  matchCache = /* @__PURE__ */ new Map();
+  maxCachedMatches;
+  semanticPrepared = false;
+  constructor(store, options) {
+    this.store = store;
+    this.manifest = store.manifest;
+    this.options = options;
+    this.maxCachedMatches = options.maxCachedMatches && options.maxCachedMatches > 0 ? options.maxCachedMatches : 5e3;
+  }
+  noteClusters() {
+    return this.manifest.layout?.clusters?.notes ?? null;
+  }
+  async readCluster(ref) {
+    const cached = this.noteClusterCache.get(ref.href);
+    if (cached) return { notes: cached, fetched: false };
+    const notes = parseJsonlBytes(await this.store.read(ref.href));
+    this.noteClusterCache.set(ref.href, notes);
+    return { notes, fetched: true };
+  }
+  /** Load every note (clustered or monolithic). Returns count of cluster files fetched. */
+  async loadAllNotes() {
+    const clusters = this.noteClusters();
+    if (!clusters) {
+      if (!this.allNotes) {
+        this.allNotes = parseJsonlBytes(await this.store.read("notes.jsonl"));
+        return { notes: this.allNotes, fetched: 1 };
+      }
+      return { notes: this.allNotes, fetched: 0 };
+    }
+    const all = [];
+    let fetched = 0;
+    for (const ref of clusters) {
+      const loaded = await this.readCluster(ref);
+      if (loaded.fetched) fetched += 1;
+      all.push(...loaded.notes);
+    }
+    return { notes: all, fetched };
+  }
+  async listNotes(options = {}) {
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? Number.MAX_SAFE_INTEGER;
+    const { notes } = await this.loadAllNotes();
+    const filtered = notes.filter((note) => passesFilters(note, options));
+    const page = filtered.slice(offset, offset + limit);
+    return { items: page.map(noteFromShard), total: filtered.length };
+  }
+  async getNote(id) {
+    const { notes } = await this.loadAllNotes();
+    const found = notes.find((note) => note.id === id);
+    return found ? noteFromShard(found) : null;
+  }
+  matchKey(query, options) {
+    return JSON.stringify({
+      q: query.trim().toLowerCase(),
+      tags: options.tags ?? null,
+      source: options.source ?? null,
+      includeArchived: options.includeArchived ?? true,
+      includeDeleted: options.includeDeleted ?? false,
+      weights: { ...DEFAULT_WEIGHTS, ...options.weights }
+    });
+  }
+  cacheMatches(key, notes) {
+    this.matchCache.delete(key);
+    this.matchCache.set(key, notes);
+    let total = 0;
+    for (const set of this.matchCache.values()) total += set.length;
+    while (total > this.maxCachedMatches && this.matchCache.size > 1) {
+      const oldest = this.matchCache.keys().next().value;
+      if (oldest === void 0 || oldest === key) break;
+      total -= this.matchCache.get(oldest)?.length ?? 0;
+      this.matchCache.delete(oldest);
+    }
+  }
+  async search(query, options = {}) {
+    const tokens = tokenize(query);
+    const weights = { ...DEFAULT_WEIGHTS, ...options.weights };
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? Number.MAX_SAFE_INTEGER;
+    const key = this.matchKey(query, options);
+    let matched = this.matchCache.get(key);
+    let fetchedClusters = 0;
+    if (matched) {
+      this.matchCache.delete(key);
+      this.matchCache.set(key, matched);
+    } else {
+      const { notes, fetched } = await this.loadAllNotes();
+      fetchedClusters = fetched;
+      matched = notes.filter((note) => passesFilters(note, options) && noteMatchesTokens(note, tokens));
+      if (tokens.length > 0 && options.rank !== false) {
+        matched = [...matched].sort((a, b) => rankNote(b, tokens, weights) - rankNote(a, tokens, weights));
+      }
+      this.cacheMatches(key, matched);
+    }
+    const page = matched.slice(offset, offset + limit);
+    const result = {
+      items: page.map(noteFromShard),
+      total: matched.length,
+      facets: facetCounts(matched),
+      fetchedClusters
+    };
+    if (options.rank || options.snippets) {
+      const snippetLength = options.snippetLength ?? 160;
+      result.rankedItems = page.map((note) => ({
+        note: noteFromShard(note),
+        rank: rankNote(note, tokens, weights),
+        ...options.snippets ? { snippet: makeSnippet(note, tokens, snippetLength) } : {}
+      }));
+    }
+    return result;
+  }
+  async loadLinks() {
+    if (!this.links) this.links = parseJsonlBytes(await this.store.read("links.jsonl"));
+    return this.links;
+  }
+  async linksOf(id) {
+    const links = await this.loadLinks();
+    return links.filter((link) => link.from_note_id === id || link.to_note_id === id);
+  }
+  async loadConcepts() {
+    if (!this.noteSkos) {
+      this.noteSkos = parseJsonlBytes(await this.store.read("note_skos_tags.jsonl"));
+    }
+    if (!this.concepts) {
+      const list = parseJsonArrayBytes(await this.store.read("skos_concepts.json"));
+      this.concepts = new Map(list.map((concept) => [concept.id, concept]));
+    }
+    return { noteSkos: this.noteSkos, concepts: this.concepts };
+  }
+  async conceptsOf(id) {
+    const { noteSkos, concepts } = await this.loadConcepts();
+    const out = [];
+    for (const tag of noteSkos) {
+      if (tag.note_id !== id) continue;
+      const concept = concepts.get(tag.concept_id);
+      if (concept) out.push(concept);
+    }
+    return out;
+  }
+  async getNoteFull(id) {
+    const note = await this.getNote(id);
+    if (!note) return null;
+    const [links, concepts] = await Promise.all([this.linksOf(id), this.conceptsOf(id)]);
+    return { note, links, concepts };
+  }
+  async semantic(query, k = 10) {
+    const provider = this.options.semantic;
+    if (!provider) return [];
+    if (!this.semanticPrepared) {
+      await provider.prepare?.(this.store);
+      this.semanticPrepared = true;
+    }
+    const hits = await provider.search(query, k);
+    const { notes } = await this.loadAllNotes();
+    const byId = new Map(notes.map((note) => [note.id, note]));
+    const out = [];
+    for (const hit of hits) {
+      const note = byId.get(hit.id);
+      if (note) out.push({ note: noteFromShard(note), score: hit.score });
+    }
+    return out;
+  }
+  close() {
+    this.noteClusterCache.clear();
+    this.matchCache.clear();
+    this.allNotes = null;
+    this.links = null;
+    this.noteSkos = null;
+    this.concepts = null;
+  }
+};
+async function openShard(source, options = {}) {
+  const store = await resolveStore(source);
+  if (store.manifest.min_reader_version && store.manifest.min_reader_version > CURRENT_SHARD_VERSION) {
+    throw new Error(
+      `Shard requires reader version ${store.manifest.min_reader_version}, but this build supports ${CURRENT_SHARD_VERSION}. Import the shard instead.`
+    );
+  }
+  return new ShardReaderImpl(store, options);
+}
+
+// src/shard/semantic-providers.ts
+var decoder3 = new TextDecoder();
+function cosine(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function createCosineSemanticProvider(options) {
+  let vectors = options.vectors ?? [];
+  return {
+    async prepare(store) {
+      if (options.vectors) return;
+      const bytes = await store.read(options.vectorsFile ?? "vectors.jsonl");
+      if (!bytes || bytes.byteLength === 0) {
+        vectors = [];
+        return;
+      }
+      vectors = decoder3.decode(bytes).split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+    },
+    async search(query, k) {
+      const queryVector = await options.embedQuery(query);
+      return vectors.map((entry) => ({ id: entry.id, score: cosine(queryVector, entry.vector) })).sort((a, b) => b.score - a.score).slice(0, k);
+    }
+  };
+}
+
 // src/shard/prefetch.ts
 var DEFAULT_CACHE_NAME = "fortemi-shards";
 var warmStore = /* @__PURE__ */ new Map();
@@ -7166,6 +7839,9 @@ function validateAiwgFortemiChunkManifest(value) {
   if (data.detail !== void 0) {
     if (!hasString(data.detail.href)) errors.push("detail.href is required");
     else if (!data.detail.href.includes("{id}")) errors.push("detail.href must contain the {id} placeholder");
+    if (data.detail.encoding !== void 0 && data.detail.encoding !== "uri" && data.detail.encoding !== "base64url") {
+      errors.push("detail.encoding must be 'uri' or 'base64url'");
+    }
   }
   if (!Array.isArray(data?.parts)) errors.push("parts must be an array");
   let expectedOffset = 0;
@@ -7267,10 +7943,20 @@ function createAiwgFetchChunkLoader(baseUrl) {
     return response.json();
   };
 }
+function encodeAiwgDetailId(id, encoding = "base64url") {
+  if (encoding === "uri") return encodeURIComponent(id);
+  const bytes = new TextEncoder().encode(id);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function aiwgDetailHrefForId(detail, id) {
+  return detail.href.replace("{id}", encodeAiwgDetailId(id, detail.encoding ?? "uri"));
+}
 function createAiwgFetchDetailLoader(baseUrl) {
   return async (id, manifest) => {
     if (!manifest.detail?.href) throw new Error("Manifest has no detail.href for record resolution");
-    const relative = manifest.detail.href.replace("{id}", encodeURIComponent(id));
+    const relative = aiwgDetailHrefForId(manifest.detail, id);
     const href = baseUrl ? new URL(relative, baseUrl).toString() : relative;
     const response = await fetch(href);
     if (!response.ok) throw new Error("Failed to fetch AIWG index detail " + href + ": " + response.status);
@@ -7293,6 +7979,8 @@ function getAiwgFortemiFacets(items) {
 function buildAiwgChunkedIndex(index, options = {}) {
   const partSize = hasPositiveInteger(options.partSize) ? options.partSize : 500;
   const projection = options.projection;
+  const idEncoding = options.idEncoding ?? "base64url";
+  const detailHref = options.detailHref ?? "detail/{id}.json";
   const items = index.items;
   const pad = (value) => String(value).padStart(4, "0");
   const project = (record) => {
@@ -7325,12 +8013,16 @@ function buildAiwgChunkedIndex(index, options = {}) {
     part_size: partSize,
     facets: getAiwgFortemiFacets(items),
     parts: partRefs,
-    ...projection ? { projection, detail: { href: options.detailHref ?? "detail/{id}.json" } } : {}
+    ...projection ? { projection, detail: { href: detailHref, encoding: idEncoding } } : {}
   };
   return {
     manifest,
     parts,
-    details: projection ? items.map((record) => ({ id: record.id, record })) : []
+    details: projection ? items.map((record) => ({
+      id: record.id,
+      href: aiwgDetailHrefForId({ href: detailHref, encoding: idEncoding }, record.id),
+      record
+    })) : []
   };
 }
 function includesAll(actual, expected) {
@@ -7440,6 +8132,34 @@ function clampMaxCachedDetails(value) {
   if (!hasPositiveInteger(value)) return 32;
   return value;
 }
+function clampMaxCachedMatches(value) {
+  if (!hasPositiveInteger(value)) return 5e3;
+  return value;
+}
+function matchSetCacheKey(q, options) {
+  return JSON.stringify({
+    q,
+    types: options.types ?? null,
+    facets: options.facets ?? null,
+    tags: options.tags ?? null,
+    concepts: options.concepts ?? null,
+    privacy: options.privacy ?? null,
+    rel: options.relationshipTargetId ?? null,
+    weights: { ...DEFAULT_QUERY_WEIGHTS, ...options.weights }
+  });
+}
+function cacheMatchEntries(runtime, key, entries) {
+  runtime.matchCache.delete(key);
+  runtime.matchCache.set(key, entries);
+  let total = 0;
+  for (const set of runtime.matchCache.values()) total += set.length;
+  while (total > runtime.maxCachedMatches && runtime.matchCache.size > 1) {
+    const oldest = runtime.matchCache.keys().next().value;
+    if (oldest === void 0 || oldest === key) break;
+    total -= runtime.matchCache.get(oldest)?.length ?? 0;
+    runtime.matchCache.delete(oldest);
+  }
+}
 function isDirectChunkBrowse(query, options) {
   return query.trim() === "" && !options.rank && !options.snippets && !options.includeMatches && !options.types && !options.facets && !options.tags && !options.concepts && !options.privacy && !options.relationshipTargetId;
 }
@@ -7526,6 +8246,19 @@ async function queryChunkedAiwgFortemiIndex(runtime, query = "", options = {}) {
       complete: true
     };
   }
+  const matchKey = matchSetCacheKey(q, options);
+  const cached = runtime.matchCache.get(matchKey);
+  if (cached) {
+    runtime.matchCache.delete(matchKey);
+    runtime.matchCache.set(matchKey, cached);
+    return {
+      ...createQueryResultFromRankedEntries(cached, q, options),
+      manifestTotal: runtime.manifest.total,
+      scannedParts: 0,
+      fetchedParts: 0,
+      complete: true
+    };
+  }
   const entries = [];
   for (const partRef of runtime.manifest.parts) {
     const loaded = await loadChunkPart(runtime, partRef);
@@ -7535,6 +8268,7 @@ async function queryChunkedAiwgFortemiIndex(runtime, query = "", options = {}) {
     entries.push(...createRankedEntries(loaded.part.items, q, options, partRef.offset));
     options.onProgress?.({ phase: "query", done: scannedParts, total: runtime.manifest.parts.length, href: partRef.href });
   }
+  cacheMatchEntries(runtime, matchKey, entries);
   return {
     ...createQueryResultFromRankedEntries(entries, q, options),
     manifestTotal: runtime.manifest.total,
@@ -7605,7 +8339,9 @@ function createAiwgIndexController(initialIndex) {
           partCache: /* @__PURE__ */ new Map(),
           detailLoader: options.detailLoader,
           maxCachedDetails: clampMaxCachedDetails(options.maxCachedDetails),
-          detailCache: /* @__PURE__ */ new Map()
+          detailCache: /* @__PURE__ */ new Map(),
+          maxCachedMatches: clampMaxCachedMatches(options.maxCachedMatches),
+          matchCache: /* @__PURE__ */ new Map()
         };
         data = null;
         reviewDecisions = [];
@@ -7665,6 +8401,7 @@ function createAiwgIndexController(initialIndex) {
     clearChunkCache() {
       chunked?.partCache.clear();
       chunked?.detailCache.clear();
+      chunked?.matchCache.clear();
       error = null;
       notify();
     },
@@ -7690,7 +8427,9 @@ function createAiwgIndexController(initialIndex) {
       notify();
     },
     createReviewDecisionExport(generatedAt) {
-      return createAiwgReviewDecisionExport(requireIndex(), reviewDecisions, generatedAt);
+      const source = index ?? (chunked ? { schema_version: "aiwg.fortemi.index.export.v1" } : null);
+      if (!source) throw new Error("No AIWG index export or chunked manifest loaded");
+      return createAiwgReviewDecisionExport(source, reviewDecisions, generatedAt);
     },
     subscribe(listener) {
       listeners.add(listener);
@@ -7747,6 +8486,6 @@ function communityIdsFor(item, options) {
 // src/index.ts
 var VERSION = "2026.6.4";
 
-export { AIWG_SCAN_REQUIRED_FIELDS, ArchiveManager, AttachmentsRepository, CURRENT_SHARD_VERSION, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, CommunitiesRepository, EMBED_REQUEST_KIND, EMBED_RESPONSE_KIND, 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, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, ProviderRegistry, SHARD_FORMAT, SearchInputSchema, SearchRepository, SkosRepository, TagsRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, aiwgFortemiIndexToCommunityGraph, allMigrations, appendPluginScript, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, buildAiwgChunkedIndex, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, createBlobStore, createCspReportHandler, createFortemi, createLegacyProvider, createPGliteInstance, createRoutes, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchPluginScript, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getLlmFunction, getNote, getPrefetchedSha256, handleEmbedRequests, hasFortemiSecureSecrets, importShard, isPluginScriptAllowed, isShardPrefetched, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, noteFromShard, noteSkosTagToShard, noteToShard, packTarGz, parseCspReport, prefetchShard, provenanceEdgeToShard, queryAiwgFortemiIndex, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, searchTool, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsFromShard, tagsToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateChecksums, verifySri };
+export { AIWG_SCAN_REQUIRED_FIELDS, ArchiveManager, AttachmentsRepository, CURRENT_MIGRATION_HEAD, CURRENT_SHARD_VERSION, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, CommunitiesRepository, DB_SNAPSHOT_SCHEMA_VERSION, DbSnapshotVersionError, EMBED_REQUEST_KIND, EMBED_RESPONSE_KIND, 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, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, ProviderRegistry, SHARD_FORMAT, SUPPORTED_PGLITE_VERSION, SearchInputSchema, SearchRepository, SkosRepository, TagsRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, aiwgFortemiIndexToCommunityGraph, allMigrations, appendPluginScript, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, buildAiwgChunkedIndex, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, createBlobStore, createCosineSemanticProvider, createCspReportHandler, createFortemi, createLegacyProvider, createPGliteBackend, createPGliteInstance, createRoutes, createShardBackend, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dumpDbSnapshot, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchPluginScript, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getLlmFunction, getNote, getPrefetchedSha256, handleEmbedRequests, hasFortemiSecureSecrets, importShard, isPluginScriptAllowed, isShardPrefetched, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, prefetchShard, provenanceEdgeToShard, queryAiwgFortemiIndex, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, restoreDbSnapshot, searchTool, selectBackend, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsFromShard, tagsToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateChecksums, verifyDbSnapshotMeta, verifySri };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map