@equationalapplications/core-llm-wiki 4.15.3 → 4.17.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { __privateAdd, EmbeddingService, SearchService, JobManager, PromptService, IngestionService, MaintenanceService, ImportExportService, RetrievalService, WriteService, __privateGet, __privateSet, normalizeSourceRef, normalizeSourceHash, generateId } from './chunk-J4GBC6CP.mjs';
-export { HOOK_TIMEOUT_MARKER, PromptService, PrunePartialFailureError, WikiBusyError, parseEmbedding } from './chunk-J4GBC6CP.mjs';
+import { __privateAdd, EmbeddingService, SearchService, JobManager, PromptService, IngestionService, MaintenanceService, ImportExportService, RetrievalService, WriteService, __privateGet, __privateSet, normalizeSourceRef, normalizeSourceHash, generateId, validateManifest, emptyManifest, mergeOntologyUpdates, resolveNodeType, validateInlineEdges, resolveEdgeDefinition, normalizeTitleKey } from './chunk-M74FCWLB.mjs';
+export { HOOK_TIMEOUT_MARKER, PromptService, PrunePartialFailureError, WikiBusyError, parseEmbedding } from './chunk-M74FCWLB.mjs';
 import { buildConceptDocument, buildLogMd, buildIndexMd, buildRootIndexMd, parseConcept, extractMarkdownLinks, parseLogMd } from '@equationalapplications/core-okf';
 
 // src/db/schema.ts
@@ -74,6 +74,13 @@ async function setupDatabase(db, prefix) {
       memory_checkpoint INTEGER NOT NULL DEFAULT 0
     );
 
+    CREATE TABLE IF NOT EXISTS ${prefix}entity_manifests (
+      entity_id TEXT PRIMARY KEY,
+      mode TEXT NOT NULL DEFAULT 'off',
+      manifest_json TEXT NOT NULL DEFAULT '{"node_types":[],"edge_types":[]}',
+      updated_at INTEGER NOT NULL
+    );
+
     CREATE TABLE IF NOT EXISTS ${prefix}meta (
       key TEXT PRIMARY KEY,
       value TEXT NOT NULL
@@ -183,6 +190,20 @@ var MIGRATIONS = [
         CREATE INDEX IF NOT EXISTS ${prefix}edges_entity_idx ON ${prefix}edges (entity_id);
       `);
     }
+  },
+  {
+    version: 6,
+    description: "Add entity_manifests table for per-entity ontology state",
+    run: async (db, prefix) => {
+      await db.execAsync(`
+        CREATE TABLE IF NOT EXISTS ${prefix}entity_manifests (
+          entity_id TEXT PRIMARY KEY,
+          mode TEXT NOT NULL DEFAULT 'off',
+          manifest_json TEXT NOT NULL DEFAULT '{"node_types":[],"edge_types":[]}',
+          updated_at INTEGER NOT NULL
+        );
+      `);
+    }
   }
 ];
 for (let i = 1; i < MIGRATIONS.length; i++) {
@@ -306,8 +327,8 @@ var EntryRepository = class extends BaseRepository {
       `INSERT INTO ${this.prefix}entries (
         id, entity_id, title, body, tags, confidence, source_type,
         source_hash, source_ref, created_at, updated_at, last_accessed_at, access_count,
-        deleted_at, embedding_blob, embedding
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        deleted_at, embedding_blob, embedding, okf_type
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         entity_id = excluded.entity_id,
         title = excluded.title,
@@ -322,7 +343,8 @@ var EntryRepository = class extends BaseRepository {
         access_count = excluded.access_count,
         deleted_at = excluded.deleted_at,
         embedding_blob = CASE WHEN excluded.embedding_blob IS NULL THEN embedding_blob ELSE excluded.embedding_blob END,
-        embedding = NULL`,
+        embedding = NULL,
+        okf_type = excluded.okf_type`,
       [
         fact.id,
         fact.entity_id,
@@ -339,7 +361,8 @@ var EntryRepository = class extends BaseRepository {
         fact.access_count,
         fact.deleted_at ?? null,
         embeddingBlob ?? null,
-        null
+        null,
+        fact.okf_type ?? null
       ]
     );
     await this.outbox.push({
@@ -1356,6 +1379,11 @@ var EventRepository = class extends BaseRepository {
 };
 
 // src/repositories/EdgeRepository.ts
+var CONFIDENCE_RANK = {
+  tentative: 0,
+  inferred: 1,
+  certain: 2
+};
 var EdgeRepository = class extends BaseRepository {
   /**
    * Insert an edge, silently skipping on primary-key or uniqueness conflicts.
@@ -1386,21 +1414,111 @@ var EdgeRepository = class extends BaseRepository {
       `SELECT * FROM ${this.prefix}edges WHERE entity_id = ? ORDER BY created_at ASC`,
       [entityId]
     );
-    return rows.map((row) => ({
-      id: String(row.id),
-      entity_id: String(row.entity_id),
-      source_id: String(row.source_id),
-      target_id: String(row.target_id),
-      edge_type: String(row.edge_type),
-      created_at: Number(row.created_at)
-    }));
+    return rows.map(mapRowToEdge);
   }
   /** Hard delete — edges have no soft-delete concept, only presence/absence. `tx` is REQUIRED. */
   async bulkDeleteByEntityId(entityId, tx) {
     const executor = this.getExecutor(tx);
     await executor.runAsync(`DELETE FROM ${this.prefix}edges WHERE entity_id = ?`, [entityId]);
   }
+  /**
+   * Multi-hop traversal from `sourceId` via SQLite `WITH RECURSIVE`. All filtering,
+   * dead-ending, cycle-guarding, capping, and ordering happens in this one query.
+   * The anchor is validated (exists, right entity, not soft-deleted) but never gated
+   * by confidence/source_type — only nodes discovered beyond it are.
+   */
+  async getNeighborhood(entityId, sourceId, opts, tx) {
+    const executor = this.getExecutor(tx);
+    if (opts.edgeTypes && opts.edgeTypes.length === 0) {
+      const anchor = await executor.getFirstAsync(
+        `SELECT id FROM ${this.prefix}entries WHERE id = ? AND entity_id = ? AND deleted_at IS NULL`,
+        [sourceId, entityId]
+      );
+      return { nodeIds: anchor ? [anchor.id] : [], edges: [] };
+    }
+    const edgeTypesClause = opts.edgeTypes ? `e.edge_type IN (${opts.edgeTypes.map(() => "?").join(",")})` : "1=1";
+    const excludeSourceTypesPlaceholders = opts.excludeSourceTypes.map(() => "?").join(",");
+    const minConfidenceRank = CONFIDENCE_RANK[opts.minConfidence];
+    const sql = `
+      WITH RECURSIVE walk(node_id, depth, visited) AS (
+        SELECT id, 0, ',' || id || ','
+        FROM ${this.prefix}entries
+        WHERE id = ? AND entity_id = ? AND deleted_at IS NULL
+
+        UNION
+
+        SELECT
+          CASE WHEN e.source_id = w.node_id THEN e.target_id ELSE e.source_id END,
+          w.depth + 1,
+          w.visited || (CASE WHEN e.source_id = w.node_id THEN e.target_id ELSE e.source_id END) || ','
+        FROM walk w
+        JOIN ${this.prefix}edges e
+          ON e.entity_id = ?
+          AND (
+            (? != 'inbound'  AND e.source_id = w.node_id) OR
+            (? != 'outbound' AND e.target_id = w.node_id)
+          )
+          AND (${edgeTypesClause})
+        JOIN ${this.prefix}entries n
+          ON n.id = (CASE WHEN e.source_id = w.node_id THEN e.target_id ELSE e.source_id END)
+          AND n.entity_id = ?
+          AND n.deleted_at IS NULL
+          AND (
+            CASE n.confidence
+              WHEN 'tentative' THEN 0
+              WHEN 'inferred' THEN 1
+              WHEN 'certain' THEN 2
+              ELSE -1
+            END
+          ) >= ?
+          AND n.source_type NOT IN (${excludeSourceTypesPlaceholders})
+        WHERE w.depth < ?
+          AND instr(w.visited, ',' || (CASE WHEN e.source_id = w.node_id THEN e.target_id ELSE e.source_id END) || ',') = 0
+      )
+      SELECT node_id, MIN(depth) AS depth
+      FROM walk
+      GROUP BY node_id
+      ORDER BY depth ASC, (SELECT updated_at FROM ${this.prefix}entries WHERE id = node_id) DESC
+      LIMIT ?
+    `;
+    const params = [
+      sourceId,
+      entityId,
+      entityId,
+      opts.direction,
+      opts.direction,
+      ...opts.edgeTypes ?? [],
+      entityId,
+      minConfidenceRank,
+      ...opts.excludeSourceTypes,
+      opts.maxDepth,
+      opts.maxNodes
+    ];
+    const rows = await executor.getAllAsync(sql, params);
+    const nodeIds = rows.map((r) => r.node_id);
+    if (nodeIds.length === 0) return { nodeIds: [], edges: [] };
+    const valueRows = nodeIds.map(() => "(?)").join(", ");
+    const edgeRows = await executor.getAllAsync(
+      `WITH neighborhood(node_id) AS (VALUES ${valueRows})
+       SELECT e.* FROM ${this.prefix}edges e
+       JOIN neighborhood ns ON e.source_id = ns.node_id
+       JOIN neighborhood nt ON e.target_id = nt.node_id
+       WHERE e.entity_id = ?`,
+      [...nodeIds, entityId]
+    );
+    return { nodeIds, edges: edgeRows.map(mapRowToEdge) };
+  }
 };
+function mapRowToEdge(row) {
+  return {
+    id: String(row.id),
+    entity_id: String(row.entity_id),
+    source_id: String(row.source_id),
+    target_id: String(row.target_id),
+    edge_type: String(row.edge_type),
+    created_at: Number(row.created_at)
+  };
+}
 
 // src/repositories/MetadataRepository.ts
 var MetadataRepository = class extends BaseRepository {
@@ -1500,6 +1618,183 @@ var MetadataRepository = class extends BaseRepository {
     );
     return rows.map((r) => r.entity_id);
   }
+  async getManifest(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(`SELECT mode, manifest_json FROM ${this.prefix}entity_manifests WHERE entity_id = ?`, [entityId]);
+    if (!row) return null;
+    if (row.mode !== "off" && row.mode !== "strict" && row.mode !== "emergent") {
+      throw new Error(`Invalid ontology mode for entity ${entityId}: ${JSON.stringify(row.mode)}`);
+    }
+    let manifest;
+    try {
+      manifest = JSON.parse(row.manifest_json);
+    } catch (error) {
+      throw new Error(`Invalid manifest_json for entity ${entityId}: ${error.message}`);
+    }
+    validateManifest(manifest);
+    return {
+      mode: row.mode,
+      manifest
+    };
+  }
+  async setManifest(entityId, data, tx) {
+    validateManifest(data.manifest);
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `INSERT INTO ${this.prefix}entity_manifests (entity_id, mode, manifest_json, updated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(entity_id) DO UPDATE SET mode = excluded.mode, manifest_json = excluded.manifest_json, updated_at = excluded.updated_at`,
+      [entityId, data.mode, JSON.stringify(data.manifest), Date.now()]
+    );
+  }
+  async mergeManifestUpdates(entityId, updates, tx) {
+    const current = await this.getManifest(entityId, tx) ?? {
+      mode: "emergent",
+      manifest: emptyManifest()
+    };
+    const merged = mergeOntologyUpdates(current.manifest, updates);
+    await this.setManifest(entityId, { mode: current.mode, manifest: merged }, tx);
+    return merged;
+  }
+};
+
+// src/prompts/ontology.ts
+var FACT_ONTOLOGY_FIELDS = `
+Each fact may optionally include:
+- "okf_type": string \u2014 must be one of the node_types in the manifest
+- "edges": [{ "edge_type": string, "target_title": string }] \u2014 target_title must match another fact's title in this response or existing memory`;
+var EMERGENT_EXTRA = `
+You may also return "ontology_updates" to propose new types:
+"ontology_updates": {
+  "node_types": [{ "type": "slug", "description": "..." }],
+  "edge_types": [{ "type": "slug", "source_type": "...", "target_type": "...", "description": "..." }]
+}
+Only propose types not already in the manifest. Do not redefine existing types.`;
+function buildOntologyPromptAppendix(mode, manifestJson) {
+  const strictRules = mode === "strict" ? "STRICT MODE: Use ONLY types defined in the manifest. If a fact does not fit any node_type, omit okf_type and edges entirely." : "EMERGENT MODE: Prefer manifest types. You may propose new types via ontology_updates when necessary.";
+  const fallback = "If okf_type or an edge is invalid, omit them rather than inventing unlisted types.";
+  const ontologyModeInstructions = [
+    "## Ontology constraints",
+    strictRules,
+    fallback,
+    FACT_ONTOLOGY_FIELDS,
+    mode === "emergent" ? EMERGENT_EXTRA : "",
+    "Manifest:",
+    manifestJson
+  ].filter(Boolean).join("\n");
+  return { ontologyManifest: manifestJson, ontologyModeInstructions };
+}
+
+// src/services/OntologyService.ts
+var OntologyService = class {
+  constructor(metadataRepo, edgeRepo, ontologyConfig) {
+    this.metadataRepo = metadataRepo;
+    this.edgeRepo = edgeRepo;
+    this.ontologyConfig = ontologyConfig;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  resolveMode(storedMode) {
+    return storedMode ?? this.ontologyConfig?.mode ?? "off";
+  }
+  invalidateCache(entityId) {
+    this.cache.delete(entityId);
+  }
+  async getEffectiveState(entityId, tx) {
+    if (!tx) {
+      const cached = this.cache.get(entityId);
+      if (cached) return cached;
+    }
+    const row = await this.metadataRepo.getManifest(entityId, tx);
+    if (row) {
+      const state = { mode: this.resolveMode(row.mode), manifest: row.manifest };
+      if (!tx) this.cache.set(entityId, state);
+      return state;
+    }
+    const seed = this.ontologyConfig?.seedManifests?.[entityId];
+    if (seed) {
+      const state = {
+        mode: this.resolveMode(seed.mode),
+        manifest: seed.manifest
+      };
+      if (tx) {
+        await this.metadataRepo.setManifest(entityId, state, tx);
+      } else {
+        this.cache.set(entityId, state);
+      }
+      return state;
+    }
+    return { mode: "off", manifest: emptyManifest() };
+  }
+  async buildPromptContext(entityId) {
+    const { mode, manifest } = await this.getEffectiveState(entityId);
+    if (mode === "off") return null;
+    const manifestJson = JSON.stringify(manifest, null, 2);
+    return buildOntologyPromptAppendix(mode, manifestJson);
+  }
+  async mergeEmergentUpdates(entityId, updates, tx) {
+    const merged = await this.metadataRepo.mergeManifestUpdates(entityId, updates, tx);
+    this.invalidateCache(entityId);
+    return merged;
+  }
+  validateAndNormalizeFact(fact, manifest) {
+    const rawType = typeof fact.okf_type === "string" ? fact.okf_type : "";
+    const canonical = resolveNodeType(rawType, manifest);
+    if (!canonical) return { okf_type: null, edges: [] };
+    const edges = validateInlineEdges(canonical, null, fact.edges ?? [], manifest);
+    return { okf_type: canonical, edges };
+  }
+  async resolveAndPersistEdges(entityId, sourceId, sourceType, edges, manifest, titleIndex, tx, now) {
+    if (!sourceType || edges.length === 0) return;
+    for (const edge of edges) {
+      const def = resolveEdgeDefinition(edge.edge_type, manifest);
+      if (!def || def.source_type.toLowerCase() !== sourceType.toLowerCase()) continue;
+      const targetKey = normalizeTitleKey(edge.target_title);
+      const target = titleIndex.get(targetKey);
+      if (!target) continue;
+      if (def.target_type.toLowerCase() !== (target.okf_type ?? "").toLowerCase()) continue;
+      const wikiEdge = {
+        id: generateId(),
+        entity_id: entityId,
+        source_id: sourceId,
+        target_id: target.id,
+        edge_type: def.type,
+        created_at: now
+      };
+      await this.edgeRepo.addIgnoreDuplicate(wikiEdge, tx);
+    }
+  }
+};
+
+// src/services/GraphTraversalService.ts
+var GraphTraversalService = class {
+  constructor(edgeRepo, entryRepo, config) {
+    this.edgeRepo = edgeRepo;
+    this.entryRepo = entryRepo;
+    this.config = config;
+  }
+  async traverseGraph(entityId, options) {
+    const fallbackMaxNodes = 20;
+    const rawConfigDefault = this.config.maxTraversalNodes ?? fallbackMaxNodes;
+    const defaultMaxNodes = Number.isFinite(rawConfigDefault) && rawConfigDefault >= 1 ? Math.floor(rawConfigDefault) : fallbackMaxNodes;
+    const rawMaxNodes = options.maxTraversalNodes ?? defaultMaxNodes;
+    const maxNodes = Number.isFinite(rawMaxNodes) && rawMaxNodes >= 1 ? Math.floor(rawMaxNodes) : defaultMaxNodes;
+    const opts = {
+      maxDepth: Math.max(1, Math.min(options.maxDepth ?? 1, 3)),
+      direction: options.direction ?? this.config.traversalDirection ?? "both",
+      edgeTypes: options.edgeTypes,
+      minConfidence: options.minTraversalConfidence ?? this.config.minTraversalConfidence ?? "tentative",
+      excludeSourceTypes: options.excludeSourceTypes ?? this.config.excludeSourceTypes ?? [],
+      maxNodes
+    };
+    const { nodeIds, edges } = await this.edgeRepo.getNeighborhood(entityId, options.sourceId, opts);
+    if (nodeIds.length === 0) return { nodes: [], edges: [] };
+    const nodes = await this.entryRepo.findByIds(nodeIds, [entityId]);
+    const hydratedIds = new Set(nodes.map((node) => node.id));
+    const filteredEdges = edges.filter(
+      (edge) => hydratedIds.has(edge.source_id) && hydratedIds.has(edge.target_id)
+    );
+    return { nodes, edges: filteredEdges };
+  }
 };
 
 // src/WikiMemory.ts
@@ -1523,6 +1818,11 @@ var WikiMemory = class {
     this.eventRepo = new EventRepository(db, this.prefix);
     this.edgeRepo = new EdgeRepository(db, this.prefix);
     this.metadataRepo = new MetadataRepository(db, this.prefix);
+    this.ontologyService = new OntologyService(
+      this.metadataRepo,
+      this.edgeRepo,
+      options.config?.ontology
+    );
     this.embeddingService = new EmbeddingService(this.db, this.options, this.entryRepo, this.metadataRepo);
     this.searchService = new SearchService(this.entryRepo);
     this.jobManager = new JobManager(this.prefix);
@@ -1535,7 +1835,8 @@ var WikiMemory = class {
       this.searchService,
       this.jobManager,
       this.embeddingService,
-      this.promptService
+      this.promptService,
+      this.ontologyService
     );
     this.maintenanceService = new MaintenanceService(
       this.db,
@@ -1548,7 +1849,8 @@ var WikiMemory = class {
       this.searchService,
       this.jobManager,
       this.embeddingService,
-      this.promptService
+      this.promptService,
+      this.ontologyService
     );
     this.importExportService = new ImportExportService(
       this.db,
@@ -1578,6 +1880,11 @@ var WikiMemory = class {
       this.jobManager,
       this.maintenanceService
     );
+    this.graphTraversalService = new GraphTraversalService(
+      this.edgeRepo,
+      this.entryRepo,
+      this.options.config ?? {}
+    );
   }
   /**
    * Explicit escape hatch for test suites: typed access to composed services for mocks/spies.
@@ -1598,6 +1905,7 @@ var WikiMemory = class {
       searchService: this.searchService,
       writeService: this.writeService,
       promptService: this.promptService,
+      graphTraversalService: this.graphTraversalService,
       entryRepo: this.entryRepo,
       metadataRepo: this.metadataRepo,
       jobManager: this.jobManager
@@ -1668,6 +1976,9 @@ var WikiMemory = class {
   async read(entityId, query, options) {
     return this.retrievalService.read(entityId, query, options);
   }
+  async traverseGraph(entityId, options) {
+    return this.graphTraversalService.traverseGraph(entityId, options);
+  }
   async getMemoryBundle(entityId) {
     return this.importExportService.getFullBundle(entityId, { maxEvents: 10 });
   }
@@ -1743,6 +2054,34 @@ var WikiMemory = class {
   async markOutboxEventsProcessed(eventIds) {
     await this.outboxRepo.acknowledge(eventIds);
   }
+  /**
+   * Returns the effective ontology mode and manifest for an entity.
+   * Resolution order: persisted DB row → `WikiConfig.ontology.seedManifests[entityId]` → `null`.
+   */
+  async getOntologyManifest(entityId) {
+    const row = await this.metadataRepo.getManifest(entityId);
+    if (row) return { mode: this.ontologyService.resolveMode(row.mode), manifest: row.manifest };
+    const seed = this.options.config?.ontology?.seedManifests?.[entityId];
+    if (seed) {
+      return {
+        mode: this.ontologyService.resolveMode(seed.mode),
+        manifest: seed.manifest
+      };
+    }
+    return null;
+  }
+  /**
+   * Seeds or replaces an entity's ontology manifest and optional mode override.
+   * Validates manifest invariants (unique type slugs, edge endpoints reference node types).
+   * Invalidates the in-memory ontology cache for this entity.
+   */
+  async setOntologyManifest(entityId, manifest, options) {
+    const mode = options?.mode ?? this.ontologyService.resolveMode();
+    await this.db.withTransactionAsync(
+      (tx) => this.metadataRepo.setManifest(entityId, { mode, manifest }, tx)
+    );
+    this.ontologyService.invalidateCache(entityId);
+  }
 };
 _testAccessNonTestEnvWarned = new WeakMap();
 
@@ -1867,6 +2206,38 @@ function formatContext(bundle, options) {
   return lines.join("\n");
 }
 
+// src/utils/formatGraphContext.ts
+function formatGraphContext(neighborhood) {
+  const { nodes, edges } = neighborhood;
+  if (nodes.length === 0) return "";
+  const nodeById = new Map(nodes.map((n) => [n.id, n]));
+  const nodeIndex = new Map(nodes.map((n, i) => [n.id, i]));
+  const lines = [];
+  for (const node of nodes) {
+    lines.push(`[${node.okf_type ?? "fact"}] ${node.title} (ID: ${node.id})`);
+    const outbound = edgesByDirection(edges, node.id, "source_id", nodeById, nodeIndex);
+    const inbound = edgesByDirection(edges, node.id, "target_id", nodeById, nodeIndex);
+    for (const { edge, other } of outbound) {
+      lines.push(`  -[${edge.edge_type}]-> [${other.okf_type ?? "fact"}] ${other.title}`);
+    }
+    for (const { edge, other } of inbound) {
+      lines.push(`  <-[${edge.edge_type}]- [${other.okf_type ?? "fact"}] ${other.title}`);
+    }
+  }
+  return lines.join("\n");
+}
+function edgesByDirection(edges, nodeId, endpoint, nodeById, nodeIndex) {
+  const otherEndpoint = endpoint === "source_id" ? "target_id" : "source_id";
+  return edges.filter((e) => e[endpoint] === nodeId).filter((e) => {
+    const otherId = e[otherEndpoint];
+    const selfIdx = nodeIndex.get(nodeId);
+    const otherIdx = nodeIndex.get(otherId);
+    return otherIdx !== void 0 && selfIdx < otherIdx;
+  }).map((edge) => ({ edge, other: nodeById.get(edge[otherEndpoint]) })).sort(
+    (a, b) => a.edge.edge_type.localeCompare(b.edge.edge_type) || a.other.title.localeCompare(b.other.title) || a.other.id.localeCompare(b.other.id) || a.edge.id.localeCompare(b.edge.id)
+  );
+}
+
 // src/utils/sanitizeForFilename.ts
 function shortHash(value) {
   let h1 = 5381;
@@ -2375,6 +2746,6 @@ function createWiki(db, options) {
   return new WikiMemory(db, options);
 }
 
-export { DEFAULT_LIBRARIAN_SYNTHESIS_PROMPT, WikiMemory, createWiki, formatContext, formatMemoryDump, formatOkfBundle, hydrateLibrarianPrompt, mapLibrarianOptionsToReadOptions, parseOkfBundle, validateLibrarianPromptTemplate };
+export { DEFAULT_LIBRARIAN_SYNTHESIS_PROMPT, WikiMemory, createWiki, formatContext, formatGraphContext, formatMemoryDump, formatOkfBundle, hydrateLibrarianPrompt, mapLibrarianOptionsToReadOptions, parseOkfBundle, validateLibrarianPromptTemplate };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map