@ponraaj/dimple-sdk 0.0.0-alpha.3 → 0.0.0-alpha.5

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -12,9 +13,10 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/make.ts
-import { Effect as Effect50, Exit as Exit7, Layer as Layer26, ManagedRuntime as ManagedRuntime2, Scope as Scope5 } from "effect";
+import { Effect as Effect50, Exit as Exit7, Layer as Layer26, ManagedRuntime, Scope as Scope5 } from "effect";
 
 // ../core/src/core.ts
 import { Context, Schema } from "effect";
@@ -31,7 +33,7 @@ import { Effect as Effect39, Layer as Layer15, Schema as Schema24 } from "effect
 
 // ../store/src/store.ts
 import { Config as Config4, Effect as Effect26, Layer as Layer10, Schema as Schema19 } from "effect";
-import { eq as eq8, and as and8, desc as desc2, asc as asc5, inArray as inArray4, ne as ne4, or, isNull as isNull2, sql as sql7 } from "drizzle-orm";
+import { eq as eq8, and as and8, desc as desc2, asc as asc5, inArray as inArray4, ne as ne4, or, isNull as isNull2, like, sql as sql7 } from "drizzle-orm";
 
 // ../store/src/db-backend.ts
 import { Context as Context2 } from "effect";
@@ -44,9 +46,6 @@ import { Effect as Effect9, Layer as Layer3, Config as Config2 } from "effect";
 import { createClient } from "@libsql/client";
 import { drizzle } from "drizzle-orm/libsql";
 import { sql as sql2 } from "drizzle-orm";
-import * as fs2 from "node:fs";
-import { dirname as dirname2 } from "node:path";
-import { migrate } from "drizzle-orm/libsql/migrator";
 
 // ../store/src/error.ts
 import { Schema as Schema2 } from "effect";
@@ -109,6 +108,11 @@ var EMBEDDED_MIGRATIONS = [
     name: "20260804035154_dream_state",
     hash: "376f6768a43edf8941614b92720222c895e258411504fb5857569dff5990b62f",
     sql: "CREATE TABLE `dream_state` (\n\t`model_key` text PRIMARY KEY,\n\t`last_dream_at` integer NOT NULL,\n\t`last_dream_memory_count` integer NOT NULL\n);\n"
+  },
+  {
+    name: "20260807074034_ttl_secs_nullable",
+    hash: "be3a8d0e64b0224021d869c1c7e217e40b6eb868615cc4c86a6717f5b7211721",
+    sql: "PRAGMA foreign_keys=OFF;--> statement-breakpoint\nCREATE TABLE `__new_memories` (\n\t`id` text PRIMARY KEY,\n\t`logical_key` text NOT NULL,\n\t`content` text NOT NULL,\n\t`content_type` text DEFAULT 'text/plain' NOT NULL,\n\t`state` text DEFAULT 'active' NOT NULL,\n\t`created_at` integer NOT NULL,\n\t`ttl_secs` integer DEFAULT 604800,\n\t`namespace` text DEFAULT 'default' NOT NULL,\n\t`metadata` text,\n\t`embedding` F32_BLOB(384),\n\t`embedding_model` text\n);\n--> statement-breakpoint\nINSERT INTO `__new_memories`(`id`, `logical_key`, `content`, `content_type`, `state`, `created_at`, `ttl_secs`, `namespace`, `metadata`, `embedding`, `embedding_model`) SELECT `id`, `logical_key`, `content`, `content_type`, `state`, `created_at`, `ttl_secs`, `namespace`, `metadata`, `embedding`, `embedding_model` FROM `memories`;--> statement-breakpoint\nDROP TABLE `memories`;--> statement-breakpoint\nALTER TABLE `__new_memories` RENAME TO `memories`;--> statement-breakpoint\nPRAGMA foreign_keys=ON;--> statement-breakpoint\nCREATE INDEX `idx_memories_ns_created` ON `memories` (`namespace`,`created_at`);--> statement-breakpoint\nCREATE INDEX `idx_memories_state_created` ON `memories` (`state`,`created_at`);--> statement-breakpoint\nCREATE UNIQUE INDEX `idx_memories_active_key` ON `memories` (`namespace`,`logical_key`) WHERE state = 'active';"
   }
 ];
 
@@ -148,7 +152,7 @@ var memories = sqliteTable("memories", {
   contentType: text("content_type").notNull().default("text/plain"),
   state: text("state", { enum: ["active", "superseded", "archived", "forgotten"] }).notNull().default("active"),
   createdAt: integer("created_at").notNull(),
-  ttlSecs: integer("ttl_secs").notNull().default(604800),
+  ttlSecs: integer("ttl_secs").default(604800),
   namespace: text("namespace").notNull().default("default"),
   metadata: text("metadata"),
   embedding: float32Array("embedding", { dimensions: 384 }),
@@ -326,7 +330,7 @@ var artifactEdges = sqliteTable3("artifact_edges", {
   fromMemoryId: text3("from_memory_id").notNull().references(() => memories.id, { onDelete: "cascade" }),
   toMemoryId: text3("to_memory_id").notNull().references(() => memories.id, { onDelete: "cascade" }),
   edgeKind: text3("edge_kind", {
-    enum: ["memory_supports", "memory_supersedes", "memory_contradicts"]
+    enum: ["memory_supports", "memory_supersedes", "memory_contradicts", "code_calls"]
   }).notNull(),
   weight: real3("weight").notNull().default(1),
   status: text3("status", { enum: ["pending", "confirmed", "rejected"] }).notNull().default("pending"),
@@ -378,7 +382,6 @@ import { Effect as Effect6, Schema as Schema6 } from "effect";
 
 // ../logger/src/service.ts
 import { Config, Context as Context3, Effect as Effect5, Layer, Logger, References } from "effect";
-import { closeSync, fsyncSync, openSync, writeSync } from "node:fs";
 
 // ../logger/src/format.ts
 function renderJson(entry) {
@@ -498,13 +501,14 @@ var consoleSink = (pretty) => {
   const render = pretty ? renderPretty : renderJson;
   return {
     write: (entry) => {
-      process.stdout.write(render(entry) + `
+      process.stderr.write(render(entry) + `
 `);
     },
     dispose: () => {}
   };
 };
-var fileSink = (path) => {
+var fileSink = (path) => Effect5.tryPromise(async () => {
+  const { openSync, closeSync, fsyncSync, writeSync } = await import("node:fs");
   const fd = openSync(path, "a");
   let disposed = false;
   const flush = () => {
@@ -537,11 +541,15 @@ var fileSink = (path) => {
       closeSync(fd);
     }
   };
-};
+});
 
 class Service3 extends Context3.Service()("@dimple/logger/Logging") {
 }
-var make = (config) => {
+var makeEffect = (config) => Effect5.gen(function* () {
+  const file = config.file === undefined ? undefined : yield* fileSink(config.file);
+  const sinks = [consoleSink((config.format ?? "jsonl") === "pretty")];
+  if (file !== undefined)
+    sinks.push(file);
   const level = config.level ?? "info";
   const floor = LEVEL_ORDER[level];
   const overrides = {};
@@ -551,9 +559,6 @@ var make = (config) => {
       overrides[scope] = order;
   }
   const ring = new RingBuffer(config.ringSize ?? 4096);
-  const sinks = [consoleSink((config.format ?? "jsonl") === "pretty")];
-  if (config.file !== undefined)
-    sinks.push(fileSink(config.file));
   return Service3.of({
     ring,
     emit: (entry) => {
@@ -572,7 +577,7 @@ var make = (config) => {
         sink.dispose();
     }
   });
-};
+});
 var LEVEL_MAP = {
   FATAL: "error",
   ERROR: "error",
@@ -637,7 +642,7 @@ var EFFECT_LEVEL = {
 };
 var minLevelLayer = (minLevel) => Layer.succeed(References.MinimumLogLevel, minLevel === "None" ? "None" : EFFECT_LEVEL[minLevel]);
 var layer = (config) => {
-  const loggingLayer = Layer.effect(Service3, Effect5.acquireRelease(Effect5.sync(() => make(config)), (logging) => Effect5.sync(() => logging.dispose())));
+  const loggingLayer = Layer.effect(Service3, Effect5.acquireRelease(makeEffect(config), (logging) => Effect5.sync(() => logging.dispose())));
   const minLevel = config.enabled === false ? "None" : lowestLevel(config);
   const withLogger = Layer.provideMerge(loggingLayer)(loggerReplacement());
   return Layer.provideMerge(minLevelLayer(minLevel))(withLogger);
@@ -659,6 +664,7 @@ var EmbeddingModelConfig = Schema6.Struct({
   dimensions: Schema6.Number,
   vectorType: Schema6.optional(Schema6.String),
   apiKey: Schema6.optional(Schema6.String),
+  baseURL: Schema6.optional(Schema6.String),
   indexConfig: Schema6.optional(IndexConfig),
   device: Schema6.optional(Schema6.Literals([
     "auto",
@@ -687,7 +693,8 @@ var EmbeddingModelConfig = Schema6.Struct({
   ])),
   pooling: Schema6.optional(Schema6.Literals(["mean", "cls", "none"])),
   normalize: Schema6.optional(Schema6.Boolean),
-  cacheDir: Schema6.optional(Schema6.String)
+  cacheDir: Schema6.optional(Schema6.String),
+  autoInstall: Schema6.optional(Schema6.Boolean)
 });
 var EmbeddingConfig = Schema6.Struct({
   defaultModel: Schema6.String,
@@ -754,8 +761,6 @@ import { Context as Context4, Effect as Effect8, Layer as Layer2 } from "effect"
 // ../config/src/loader.ts
 import { Effect as Effect7, Schema as Schema7 } from "effect";
 import { parse, parseTree, printParseErrorCode } from "jsonc-parser";
-import * as fs from "node:fs";
-import * as path from "node:path";
 var CONFIG_FILE_NAMES = ["dimple.jsonc", "dimple.json"];
 var GLOBAL_DIR = ".config/dimple";
 var defaults = {
@@ -855,11 +860,14 @@ var parseJsoncEffect = (text4, formatError) => {
     return Effect7.fail(formatError(result.error));
   return Effect7.succeed(result.value);
 };
-var readFile = (filePath) => Effect7.try({
-  try: () => fs.readFileSync(filePath, "utf-8"),
+var readFile = (filePath) => Effect7.tryPromise({
+  try: async () => (await import("node:fs")).promises.readFile(filePath, "utf8"),
   catch: (cause) => new Error(`failed to read config file ${filePath}: ${cause instanceof Error ? cause.message : String(cause)}`)
 }).pipe(Effect7.flatMap((content) => parseJsoncEffect(content, (cause) => new Error(`failed to read config file ${filePath}: ${cause.message}`))));
-var findProjectConfig = () => {
+var loadFs = () => Effect7.tryPromise(() => import("node:fs"));
+var findProjectConfig = () => Effect7.gen(function* () {
+  const fs = yield* loadFs();
+  const path = yield* Effect7.tryPromise(() => import("node:path"));
   let dir = process.cwd();
   for (let i = 0;i < 20; i++) {
     for (const name of CONFIG_FILE_NAMES) {
@@ -873,37 +881,40 @@ var findProjectConfig = () => {
     dir = parent;
   }
   return;
-};
-var getGlobalConfigPath = () => {
+});
+var getGlobalConfigPath = () => Effect7.gen(function* () {
   const home = process.env["HOME"] ?? process.env["USERPROFILE"];
   if (!home)
     return;
+  const fs = yield* loadFs();
+  const path = yield* Effect7.tryPromise(() => import("node:path"));
   for (const name of CONFIG_FILE_NAMES) {
     const p = path.join(home, GLOBAL_DIR, name);
     if (fs.existsSync(p))
       return p;
   }
   return;
-};
-var loadFromFiles = () => {
+});
+var loadFromFiles = () => Effect7.gen(function* () {
   const sources = [];
-  const globalPath = getGlobalConfigPath();
+  const globalPath = yield* getGlobalConfigPath();
   if (globalPath)
     sources.push({ path: globalPath });
-  const projectPath = findProjectConfig();
+  const projectPath = yield* findProjectConfig();
   if (projectPath)
     sources.push({ path: projectPath });
   const envPath = process.env["DIMPLE_CONFIG"];
   if (envPath) {
+    const fs = yield* loadFs();
     if (!fs.existsSync(envPath)) {
-      return Effect7.fail(new Error(`DIMPLE_CONFIG path not found: ${envPath}`));
+      return yield* Effect7.fail(new Error(`DIMPLE_CONFIG path not found: ${envPath}`));
     }
     sources.push({ path: envPath });
   }
   if (sources.length === 0)
-    return Effect7.succeed([]);
-  return Effect7.forEach(sources, (s) => readFile(s.path));
-};
+    return [];
+  return yield* Effect7.forEach(sources, (s) => readFile(s.path));
+});
 var loadFromEnvContent = () => {
   const content = process.env["DIMPLE_CONFIG_CONTENT"];
   if (!content)
@@ -934,15 +945,16 @@ var deepMerge = (base, over) => {
   }
   return out;
 };
-var loadConfigFromFile = (path2) => Effect7.gen(function* () {
+var loadConfigFromFile = (path) => Effect7.gen(function* () {
+  const fs = yield* loadFs();
   const content = yield* Effect7.tryPromise({
-    try: () => fs.promises.readFile(path2, "utf8"),
-    catch: (cause) => new Error(`config read ${path2}: ${cause}`)
+    try: () => fs.promises.readFile(path, "utf8"),
+    catch: (cause) => new Error(`config read ${path}: ${cause}`)
   });
-  const parsed = yield* parseJsoncEffect(content, (cause) => new Error(`config parse ${path2}: ${cause.message}`));
+  const parsed = yield* parseJsoncEffect(content, (cause) => new Error(`config parse ${path}: ${cause.message}`));
   const merged = deepMerge(defaults, parsed);
   const resolved = resolveEnvVars(merged);
-  return yield* Schema7.decodeUnknownEffect(DimpleConfig)(resolved).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
+  return yield* Schema7.decodeUnknownEffect(DimpleConfig, { errors: "all" })(resolved).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
 });
 var loadConfig = (overrides) => Effect7.gen(function* () {
   const fileParts = yield* loadFromFiles();
@@ -955,7 +967,7 @@ var loadConfig = (overrides) => Effect7.gen(function* () {
   if (overrides)
     merged = deepMerge(merged, overrides);
   const resolved = resolveEnvVars(merged);
-  return yield* Schema7.decodeUnknownEffect(DimpleConfig)(resolved).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
+  return yield* Schema7.decodeUnknownEffect(DimpleConfig, { errors: "all" })(resolved).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
 });
 
 // ../config/src/service.ts
@@ -1048,9 +1060,6 @@ var runEmbeddedMigrations = async (client) => {
   }
 };
 var makeClientDb = (url) => {
-  if (url.startsWith("file:")) {
-    fs2.mkdirSync(dirname2(url.slice("file:".length)), { recursive: true });
-  }
   const client = createClient({ url });
   const db = drizzle({ client });
   const rawTransaction = client.transaction.bind(client);
@@ -1113,25 +1122,29 @@ var makeClientDb = (url) => {
   };
   return { client, db };
 };
+var ensureFileDir = (url) => url.startsWith("file:") ? import("node:fs").then((fs) => import("node:path").then(({ dirname }) => {
+  fs.mkdirSync(dirname(url.slice("file:".length)), { recursive: true });
+})) : Promise.resolve();
 var acquireMigrationLock = async (url) => {
   if (!url.startsWith("file:"))
     return;
+  const fs = await import("node:fs");
   const dbPath = url.slice("file:".length);
   const lockPath = `${dbPath}.migrate-lock`;
   const deadline = Date.now() + 30000;
   for (;; ) {
     try {
-      const fd = fs2.openSync(lockPath, "wx");
+      const fd = fs.openSync(lockPath, "wx");
       return () => {
         try {
-          fs2.closeSync(fd);
-          fs2.unlinkSync(lockPath);
+          fs.closeSync(fd);
+          fs.unlinkSync(lockPath);
         } catch {}
       };
     } catch {
       try {
-        if (Date.now() - fs2.statSync(lockPath).mtimeMs > 5 * 60000)
-          fs2.unlinkSync(lockPath);
+        if (Date.now() - fs.statSync(lockPath).mtimeMs > 300000)
+          fs.unlinkSync(lockPath);
       } catch {}
       if (Date.now() > deadline) {
         return Promise.reject(new Error(`timed out waiting for migration lock ${lockPath}`));
@@ -1141,6 +1154,10 @@ var acquireMigrationLock = async (url) => {
   }
 };
 var topicFilter = (topicKeys) => topicKeys && topicKeys.length > 0 ? ` AND m.id IN (SELECT memory_id FROM topic_memberships WHERE topic_key IN (${topicKeys.map(() => "?").join(", ")}) AND model_key = ?)` : "";
+var contentTypeFilter = (contentType) => {
+  const kinds = typeof contentType === "string" ? [contentType] : contentType ?? [];
+  return kinds.length === 0 ? "" : ` AND m.content_type IN (${kinds.map(() => "?").join(", ")})`;
+};
 var makeBackend = (url, client, db, migrationFolder) => ({
   listIsolatedMemories: (limit, modelKey) => Effect9.tryPromise({
     try: () => client.execute({
@@ -1176,6 +1193,7 @@ var makeBackend = (url, client, db, migrationFolder) => ({
       try: async () => {
         try {
           if (migrationFolder !== undefined) {
+            const { migrate } = await import("drizzle-orm/libsql/migrator");
             await migrate(db, { migrationsFolder: migrationFolder });
           } else {
             await runEmbeddedMigrations(client);
@@ -1206,25 +1224,25 @@ var makeBackend = (url, client, db, migrationFolder) => ({
     topics,
     artifactEdges
   },
-  ftsSearch: (query, namespace, limit, topicKeys, modelKey) => Effect9.tryPromise({
+  ftsSearch: (query, namespace, limit, topicKeys, modelKey, contentType) => Effect9.tryPromise({
     try: () => client.execute({
       sql: `SELECT m.*, f.rank
                FROM memories_fts f
                JOIN memories m ON m.rowid = f.rowid
-               WHERE f.content MATCH ? AND m.namespace = ? AND m.state = 'active'${topicFilter(topicKeys)}
+               WHERE f.content MATCH ? AND m.namespace = ? AND m.state = 'active'${topicFilter(topicKeys)}${contentTypeFilter(contentType)}
                ORDER BY f.rank
                LIMIT ?`,
-      args: topicKeys && topicKeys.length > 0 ? [
+      args: [
         `"${query.replaceAll('"', '""')}"`,
         namespace,
-        ...topicKeys,
-        modelKey ?? "",
+        ...topicKeys && topicKeys.length > 0 ? [...topicKeys, modelKey ?? ""] : [],
+        ...typeof contentType === "string" ? [contentType] : contentType ?? [],
         limit
-      ] : [`"${query.replaceAll('"', '""')}"`, namespace, limit]
+      ]
     }).then((rs) => rs.rows),
     catch: (cause) => new StoreError({ message: `DbBackend.ftsSearch: ${cause}` })
   }),
-  vectorSearch: (query, namespace, limit, model, topicKeys) => Effect9.gen(function* () {
+  vectorSearch: (query, namespace, limit, model, topicKeys, contentType) => Effect9.gen(function* () {
     for (const n of query) {
       if (!Number.isFinite(n)) {
         yield* new StoreError({
@@ -1235,7 +1253,13 @@ var makeBackend = (url, client, db, migrationFolder) => ({
     const tableName = vectorTableName(model);
     const vecJson = JSON.stringify([...query]);
     const convertFn = VECTOR_CONVERT_FNS[model.vectorType ?? "float32"] ?? "vector32";
-    const args = topicKeys && topicKeys.length > 0 ? [vecJson, namespace, ...topicKeys, model.id, limit] : [vecJson, namespace, limit];
+    const args = [
+      vecJson,
+      namespace,
+      ...topicKeys && topicKeys.length > 0 ? [...topicKeys, model.id] : [],
+      ...typeof contentType === "string" ? [contentType] : contentType ?? [],
+      limit
+    ];
     const rows = yield* Effect9.tryPromise({
       try: () => client.execute({
         sql: `
@@ -1243,7 +1267,7 @@ var makeBackend = (url, client, db, migrationFolder) => ({
                      vector_distance_cos(v.embedding, ${convertFn}(?)) AS distance
               FROM memories m
               JOIN ${tableName} v ON v.memory_id = m.id
-              WHERE m.namespace = ? AND m.state = 'active'${topicFilter(topicKeys)}
+              WHERE m.namespace = ? AND m.state = 'active'${topicFilter(topicKeys)}${contentTypeFilter(contentType)}
               ORDER BY distance
               LIMIT ?
             `,
@@ -1281,6 +1305,23 @@ var makeBackend = (url, client, db, migrationFolder) => ({
     }),
     catch: (cause) => new StoreError({ message: `DbBackend.sweep: ${cause}` })
   }),
+  listSchema: () => Effect9.tryPromise({
+    try: async () => {
+      const tables = (await client.execute({
+        sql: `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name`
+      })).rows;
+      const out = [];
+      for (const t of tables) {
+        const cols = (await client.execute({ sql: `PRAGMA table_info(${t.name})` })).rows;
+        out.push({
+          table: t.name,
+          columns: cols.map((c) => ({ name: c.name, type: c.type }))
+        });
+      }
+      return out;
+    },
+    catch: (cause) => new StoreError({ message: `DbBackend.listSchema: ${cause}` })
+  }),
   writeAuditRows: (rows) => rows.length === 0 ? Effect9.void : Effect9.tryPromise({
     try: () => db.insert(retrievalLog).values([...rows]),
     catch: (cause) => new StoreError({ message: `DbBackend.writeAuditRows: ${cause}` })
@@ -1329,10 +1370,12 @@ var makeBackend = (url, client, db, migrationFolder) => ({
     const maxTotal = opts?.maxTotal ?? 80;
     const includePending = opts?.includePending ?? true;
     const modelKey = opts?.modelKey;
-    const statusClause = includePending ? `AND e.status IN ('active', 'confirmed', 'pending')` : `AND e.status IN ('active', 'confirmed')`;
+    const statusClause = includePending ? `AND e.expired_at IS NULL AND e.status IN ('active', 'confirmed', 'pending')` : `AND e.expired_at IS NULL AND e.status IN ('active', 'confirmed')`;
     const modelClause = modelKey === undefined ? "" : `AND (e.from_kind <> 'topic'
              OR EXISTS (SELECT 1 FROM topic_memberships tm WHERE tm.topic_key = e.from_id AND tm.memory_id = e.to_id AND tm.model_key = ?)
              OR EXISTS (SELECT 1 FROM topic_relations tr WHERE tr.parent_key = e.from_id AND tr.child_key = e.to_id AND tr.model_key = ?))`;
+    const kinds = opts?.edgeKinds;
+    const kindClause = kinds === undefined || kinds.length === 0 ? "" : `AND e.edge_kind IN (${kinds.map(() => "?").join(",")})`;
     const results = [];
     const seenEdges = new Set;
     const visited = new Set([`${kind}:${id}`]);
@@ -1345,6 +1388,8 @@ var makeBackend = (url, client, db, migrationFolder) => ({
         args.push(node.id, node.kind, node.id, node.kind);
       if (modelKey !== undefined)
         args.push(modelKey, modelKey);
+      if (kinds !== undefined && kinds.length > 0)
+        args.push(...kinds);
       const rows = yield* Effect9.tryPromise({
         try: () => client.execute({
           sql: `SELECT e.from_kind, e.from_id, e.to_kind, e.to_id, e.edge_kind, e.weight, e.status, e.source, e.valid_at, e.expired_at, ? AS depth
@@ -1352,6 +1397,7 @@ var makeBackend = (url, client, db, migrationFolder) => ({
                       WHERE (${touches})
                         ${statusClause}
                         ${modelClause}
+                        ${kindClause}
                       ORDER BY e.from_id, e.edge_kind, e.to_id, e.to_kind`,
           args
         }).then((rs) => rs.rows),
@@ -1523,13 +1569,20 @@ var makeBackend = (url, client, db, migrationFolder) => ({
   })
 });
 var layer3 = (url, options) => {
-  const effect = options?.releaseClient === true ? Effect9.acquireRelease(Effect9.sync(() => makeClientDb(url)), ({ client }) => Effect9.tryPromise({
+  const effect = options?.releaseClient === true ? Effect9.acquireRelease(Effect9.tryPromise({
+    try: () => ensureFileDir(url).then(() => makeClientDb(url)),
+    catch: (cause) => new StoreError({ message: `DbBackend.client: ${cause}` })
+  }), ({ client }) => Effect9.tryPromise({
     try: async () => client.close(),
     catch: () => new Error("DbBackend.close failed")
   }).pipe(Effect9.ignore)).pipe(Effect9.flatMap(({ client, db }) => {
     const backend = Service2.of(makeBackend(url, client, db, options?.migrationFolder));
     return backend.runMigrations().pipe(Effect9.as(backend));
   })) : Effect9.gen(function* () {
+    yield* Effect9.tryPromise({
+      try: () => ensureFileDir(url),
+      catch: (cause) => new StoreError({ message: `DbBackend.client: ${cause}` })
+    });
     const { client, db } = yield* Effect9.sync(() => makeClientDb(url));
     const backend = Service2.of(makeBackend(url, client, db, options?.migrationFolder));
     yield* backend.runMigrations();
@@ -1556,6 +1609,7 @@ var MemoryMetadata = Schema8.Struct({
   confidence: Schema8.Number,
   affordances: Schema8.Array(Schema8.String),
   language: Schema8.optional(Schema8.String),
+  codeVersion: Schema8.optional(Schema8.String),
   pinned: Schema8.optional(Schema8.Boolean)
 });
 var parseMetadata = (blob) => {
@@ -2422,7 +2476,6 @@ import {
 } from "effect";
 import { PersistedQueue } from "effect/unstable/persistence";
 import { SqlClient } from "effect/unstable/sql";
-import { randomUUID } from "node:crypto";
 
 class QueueKey extends Data.Class {
 }
@@ -2433,7 +2486,7 @@ var makeStore = Effect15.fnUntraced(function* (options) {
   const pollInterval = Duration.max(options?.pollInterval ? Duration.fromInputUnsafe(options.pollInterval) : Duration.millis(1000), Duration.millis(1));
   const lockRefreshInterval = Duration.max(options?.lockRefreshInterval ? Duration.fromInputUnsafe(options.lockRefreshInterval) : Duration.seconds(30), Duration.millis(1));
   const lockExpiration = Duration.max(options?.lockExpiration ? Duration.fromInputUnsafe(options.lockExpiration) : Duration.minutes(2), Duration.millis(1));
-  const workerId = randomUUID();
+  const workerId = globalThis.crypto.randomUUID();
   const sqlNow = sql3.literal("CURRENT_TIMESTAMP");
   const expiresAt = sql3.literal(`datetime(CURRENT_TIMESTAMP, '-${Math.ceil(Duration.toSeconds(lockExpiration))} seconds')`);
   const workerIdSql = sql3.literal(`'${workerId}'`);
@@ -2573,7 +2626,7 @@ var storeSqliteLayer = Layer4.effect(PersistedQueue.PersistedQueueStore, makeSto
 // ../../node_modules/.bun/@effect+sql-libsql@4.0.0-beta.103+10c4c6971de0179f/node_modules/@effect/sql-libsql/dist/LibsqlClient.js
 var exports_LibsqlClient = {};
 __export(exports_LibsqlClient, {
-  make: () => make5,
+  make: () => make4,
   layerConfig: () => layerConfig2,
   layer: () => layer5,
   TypeId: () => TypeId,
@@ -2602,7 +2655,7 @@ var classifyError = (cause, message, operation) => classifySqliteError(cause, {
 var TypeId = "~@effect/sql-libsql/LibsqlClient";
 var LibsqlClient = /* @__PURE__ */ Context6.Service("@effect/sql-libsql/LibsqlClient");
 var LibsqlTransaction = /* @__PURE__ */ Context6.Service("@effect/sql-libsql/LibsqlClient/LibsqlTransaction");
-var make5 = (options) => Effect16.gen(function* () {
+var make4 = (options) => Effect16.gen(function* () {
   const compiler = Statement.makeCompilerSqlite(options.transformQueryNames);
   const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames).array : undefined;
   const spanAttributes = [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]];
@@ -2717,11 +2770,9 @@ var make5 = (options) => Effect16.gen(function* () {
     sdk: connection.sdk
   });
 });
-var layerConfig2 = (config) => Layer5.effectContext(Config3.unwrap(config).pipe(Effect16.flatMap(make5), Effect16.map((client) => Context6.make(LibsqlClient, client).pipe(Context6.add(Client.SqlClient, client))))).pipe(Layer5.provide(Reactivity.layer));
-var layer5 = (config) => Layer5.effectContext(Effect16.map(make5(config), (client) => Context6.make(LibsqlClient, client).pipe(Context6.add(Client.SqlClient, client)))).pipe(Layer5.provide(Reactivity.layer));
+var layerConfig2 = (config) => Layer5.effectContext(Config3.unwrap(config).pipe(Effect16.flatMap(make4), Effect16.map((client) => Context6.make(LibsqlClient, client).pipe(Context6.add(Client.SqlClient, client))))).pipe(Layer5.provide(Reactivity.layer));
+var layer5 = (config) => Layer5.effectContext(Effect16.map(make4(config), (client) => Context6.make(LibsqlClient, client).pipe(Context6.add(Client.SqlClient, client)))).pipe(Layer5.provide(Reactivity.layer));
 // ../workflow/src/engine.ts
-import { mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
 var Persistence = PersistenceNamespace2.Persistence;
 var PersistedQueueFactory = PersistedQueue2.PersistedQueueFactory;
 var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect17.gen(function* () {
@@ -2922,7 +2973,9 @@ var workflowTagFor = (workflows, store, executionId) => Effect17.gen(function* (
 });
 var ensureDbDir = (url) => {
   if (url.startsWith("file:")) {
-    mkdirSync2(dirname3(url.slice("file:".length)), { recursive: true });
+    import("node:fs").then((fs) => import("node:path").then(({ dirname }) => {
+      fs.mkdirSync(dirname(url.slice("file:".length)), { recursive: true });
+    }));
   }
 };
 var libsqlStack = (options) => {
@@ -4313,6 +4366,11 @@ var sameLogicalKeyFamily = (a, b) => {
   const fb = familyOf(b);
   return fa !== "" && fa === fb;
 };
+var sameFileChunkFamily = (a, b) => {
+  if (a === undefined || b === undefined || a === "" || b === "")
+    return false;
+  return a.startsWith(`${b}#`) || b.startsWith(`${a}#`);
+};
 var topicsOf = (blob) => {
   if (blob === undefined || blob === null)
     return new Set;
@@ -4357,7 +4415,7 @@ var leafLocalCandidates = (newId, newVector, newCreatedAt, newLogicalKey, newMet
       });
       continue;
     }
-    if (cosine > bands.nearDuplicate) {
+    if (cosine > bands.nearDuplicate && !sameFileChunkFamily(newLogicalKey, member.logicalKey)) {
       const dir = direction(member, newId, newCreatedAt);
       out.push({
         ...dir,
@@ -4369,7 +4427,7 @@ var leafLocalCandidates = (newId, newVector, newCreatedAt, newLogicalKey, newMet
       });
       continue;
     }
-    if (cosine > bands.conflictLow && (sameLogicalKeyFamily(newLogicalKey, member.logicalKey) || sharedMetadataTopics(newMetadata, member.metadata))) {
+    if (cosine > bands.conflictLow && !sameFileChunkFamily(newLogicalKey, member.logicalKey) && (sameLogicalKeyFamily(newLogicalKey, member.logicalKey) || sharedMetadataTopics(newMetadata, member.metadata))) {
       const dir = direction(member, newId, newCreatedAt);
       out.push({
         ...dir,
@@ -4504,7 +4562,12 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       supersedeDemotion: GRAPH_SUPERSEDE_DEMOTION
     });
   });
-  const EDGE_KINDS = ["memory_supports", "memory_supersedes", "memory_contradicts"];
+  const EDGE_KINDS = [
+    "memory_supports",
+    "memory_supersedes",
+    "memory_contradicts",
+    "code_calls"
+  ];
   const EDGE_SOURCES = ["rule", "llm", "agent"];
   const write = Effect26.fn("Store.write")(function* (input) {
     if (input.content.includes("\x00")) {
@@ -4523,7 +4586,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
           content: input.content,
           contentType: input.contentType ?? "text/plain",
           createdAt: now,
-          ttlSecs: input.ttlSecs ?? defaultTtlSecs,
+          ttlSecs: input.ttlSecs === null ? null : input.ttlSecs ?? defaultTtlSecs,
           namespace: input.namespace ?? "default",
           metadata: metadataBlob
         });
@@ -4541,7 +4604,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       contentType: input.contentType ?? "text/plain",
       state: "active",
       createdAt: now,
-      ttlSecs: input.ttlSecs ?? defaultTtlSecs,
+      ttlSecs: input.ttlSecs === null ? null : input.ttlSecs ?? defaultTtlSecs,
       namespace: input.namespace ?? "default",
       metadata: metadataBlob ?? undefined,
       embedding: undefined,
@@ -4585,7 +4648,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
   });
   const searchFts5 = Effect26.fn("Store.searchFts5")(function* (query, namespace, limit, opts) {
     const start = Date.now();
-    const rows = yield* backend.ftsSearch(query, namespace, limit, opts?.topicKeys, modelConfig?.id);
+    const rows = yield* backend.ftsSearch(query, namespace, limit, opts?.topicKeys, modelConfig?.id, opts?.contentType);
     if (opts?.audit !== false) {
       yield* logRetrieval(query, namespace, "fts", rows.length, start);
     }
@@ -4628,7 +4691,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       });
       allowedMemoryIds = new Set(conceptRows.map((r) => r.memoryId));
     }
-    const rows = yield* backend.vectorSearch(query, namespace, limit, modelConfig, opts?.topicKeys);
+    const rows = yield* backend.vectorSearch(query, namespace, limit, modelConfig, opts?.topicKeys, opts?.contentType);
     const allowed = allowedMemoryIds;
     const scopedRows = allowed !== undefined ? rows.filter((row) => allowed.has(row.id)) : rows;
     if (opts?.audit !== false) {
@@ -4963,7 +5026,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     });
     return rows.map((row) => row.id);
   });
-  const flipToSupersededById = async (tx, memoryId, now) => {
+  const flipToSupersededById = async (tx, memoryId, now, reason = "superseded") => {
     const rs = await tx.update(memories2).set({ state: "superseded" }).where(and8(eq8(memories2.id, memoryId), eq8(memories2.state, "active")));
     if (rs.rowsAffected === 0)
       return null;
@@ -4972,11 +5035,106 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       eventType: "superseded",
       fromState: "active",
       toState: "superseded",
-      reason: "superseded",
+      reason,
       createdAt: now
     });
     return memoryId;
   };
+  const reconcile = Effect26.fn("Store.reconcile")(function* (namespace, keyPrefix, keyRoot, walkedRoots, keptKeys) {
+    const inDomain = (key) => {
+      const rel = key.slice(keyPrefix.length).split("#")[0];
+      const filePath = keyRoot === "/" ? `/${rel}` : `${keyRoot}/${rel}`;
+      return walkedRoots.some((root) => filePath === root || filePath.startsWith(`${root}/`));
+    };
+    const owned = (key) => keptKeys.includes(key);
+    const rows = yield* Effect26.tryPromise({
+      try: () => db.select({
+        id: memories2.id,
+        logicalKey: memories2.logicalKey,
+        embedding: memories2.embedding
+      }).from(memories2).where(and8(eq8(memories2.namespace, namespace), eq8(memories2.state, "active"), like(memories2.logicalKey, `${keyPrefix}%`))),
+      catch: (cause) => new StoreError({ message: `Store.reconcile: ${cause}` })
+    });
+    const vanished = rows.filter((r) => inDomain(r.logicalKey) && !owned(r.logicalKey));
+    if (vanished.length > 0) {
+      const now = Date.now();
+      yield* Effect26.tryPromise({
+        try: () => db.transaction(async (tx) => {
+          for (const row of vanished) {
+            await flipToSupersededById(tx, row.id, now, "source_removed");
+          }
+        }),
+        catch: (cause) => new StoreError({ message: `Store.reconcile: ${cause}` })
+      });
+    }
+    return vanished;
+  });
+  const writeSuperseding = Effect26.fn("Store.writeSuperseding")(function* (input) {
+    if (input.content.includes("\x00")) {
+      return yield* new StoreError({
+        message: "Store.writeSuperseding: content contains a NUL byte (libSQL would silently truncate it)"
+      });
+    }
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    const metadataBlob = input.typedMetadata !== undefined ? mergeMetadataBlob(input.metadata, input.typedMetadata) : input.metadata ?? null;
+    const namespace = input.namespace ?? "default";
+    let supersededId;
+    yield* Effect26.tryPromise({
+      try: () => db.transaction(async (tx) => {
+        const existing = await tx.select({ id: memories2.id }).from(memories2).where(and8(eq8(memories2.logicalKey, input.logicalKey), eq8(memories2.namespace, namespace), eq8(memories2.state, "active"))).limit(1);
+        const old = existing[0];
+        if (old !== undefined) {
+          await flipToSupersededById(tx, old.id, now);
+          supersededId = old.id;
+        }
+        await tx.insert(memories2).values({
+          id,
+          logicalKey: input.logicalKey,
+          content: input.content,
+          contentType: input.contentType ?? "text/plain",
+          createdAt: now,
+          ttlSecs: input.ttlSecs === null ? null : input.ttlSecs ?? defaultTtlSecs,
+          namespace,
+          metadata: metadataBlob
+        });
+        await tx.insert(memoryEvents2).values({ memoryId: id, eventType: "created", createdAt: now });
+        if (old !== undefined) {
+          await tx.insert(artifactEdges).values({
+            id: crypto.randomUUID(),
+            fromMemoryId: old.id,
+            toMemoryId: id,
+            edgeKind: "memory_supersedes",
+            weight: 1,
+            status: "confirmed",
+            source: "rule",
+            confidence: 1,
+            validAt: now,
+            expiredAt: null,
+            createdAt: now,
+            updatedAt: now
+          });
+        }
+      }),
+      catch: (cause) => backend.isUniqueViolation(cause) ? new DuplicateActiveKey({ logicalKey: input.logicalKey, namespace }) : new StoreError({ message: `Store.writeSuperseding: ${cause}` })
+    });
+    return {
+      memory: {
+        id,
+        logicalKey: input.logicalKey,
+        content: input.content,
+        contentType: input.contentType ?? "text/plain",
+        state: "active",
+        createdAt: now,
+        ttlSecs: input.ttlSecs === null ? null : input.ttlSecs ?? defaultTtlSecs,
+        namespace,
+        metadata: metadataBlob ?? undefined,
+        embedding: undefined,
+        embeddingModel: undefined
+      },
+      ...supersededId !== undefined ? { supersededId } : {}
+    };
+  });
   const addEdge = Effect26.fn("Store.addEdge")(function* (input) {
     if (input.fromMemoryId === input.toMemoryId) {
       return yield* new StoreError({ message: "Store.addEdge: self-loops are not allowed" });
@@ -5029,7 +5187,12 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       updatedAt: now
     };
     yield* Effect26.tryPromise({
-      try: () => db.insert(artifactEdges).values(row),
+      try: () => db.transaction(async (tx) => {
+        await tx.insert(artifactEdges).values(row);
+        if (input.confirmed && input.edgeKind === "memory_supersedes") {
+          await flipToSupersededById(tx, input.fromMemoryId, now);
+        }
+      }),
       catch: (cause) => {
         if (backend.isUniqueViolation(cause)) {
           return new EdgeExists({
@@ -5168,6 +5331,42 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     }),
     catch: (cause) => new StoreError({ message: `Store.writeCandidateEdge: ${cause}` })
   });
+  const reconcileRenameCandidates = Effect26.fn("Store.reconcileRenameCandidates")(function* (vanished, newUnitIds) {
+    const withVectors = vanished.filter((v) => v.embedding !== null);
+    if (withVectors.length === 0 || newUnitIds.length === 0)
+      return 0;
+    const newRows = yield* Effect26.tryPromise({
+      try: () => db.select({ id: memories2.id, embedding: memories2.embedding }).from(memories2).where(and8(inArray4(memories2.id, newUnitIds))),
+      catch: (cause) => new StoreError({ message: `Store.reconcileRenameCandidates: ${cause}` })
+    });
+    const newWithVectors = newRows.filter((r) => r.embedding !== null);
+    if (newWithVectors.length === 0)
+      return 0;
+    const now = Date.now();
+    let inserted = 0;
+    for (const v of withVectors) {
+      const vVec = Float32Array.from(v.embedding);
+      for (const n of newWithVectors) {
+        if (v.id === n.id)
+          continue;
+        const cosine = cosineSimilarity(vVec, Float32Array.from(n.embedding));
+        if (cosine >= GRAPH_CONFLICT_BANDS.nearDuplicate) {
+          const ok = yield* writeCandidateEdge({
+            fromMemoryId: v.id,
+            toMemoryId: n.id,
+            edgeKind: "memory_supersedes",
+            source: "rule",
+            status: "pending",
+            confidence: cosine,
+            reason: "rename"
+          }, now);
+          if (ok)
+            inserted += 1;
+        }
+      }
+    }
+    return inserted;
+  });
   const scanLeafCandidates = (memoryId, vector, topicKey, model) => Effect26.gen(function* () {
     const memberRows = yield* Effect26.tryPromise({
       try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(and8(eq8(topicMemberships.topicKey, topicKey), eq8(topicMemberships.modelKey, model.id))).orderBy(asc5(topicMemberships.memoryId)),
@@ -5368,12 +5567,16 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
   });
   return {
     write,
+    writeSuperseding,
+    reconcile,
+    reconcileRenameCandidates,
     get,
     getByKey,
     recency,
     searchFts5,
     searchVector,
     logAudit,
+    listSchema: () => backend.listSchema(),
     supersede,
     forget,
     sweep,
@@ -5507,6 +5710,7 @@ __export(exports_graph, {
   farthestPointSeeds: () => farthestPointSeeds,
   dreamStateDefaults: () => dreamStateDefaults,
   dreamState: () => dreamState,
+  cosineSimilarity: () => cosineSimilarity,
   conceptConfidence: () => conceptConfidence,
   conceptClusterHandler: () => conceptClusterHandler,
   clusterMembers: () => clusterMembers,
@@ -6260,7 +6464,7 @@ var MemoryUnit = Schema20.Struct({
   contentType: Schema20.String,
   state: MemoryState,
   createdAt: Schema20.Number,
-  ttlSecs: Schema20.Number,
+  ttlSecs: Schema20.NullOr(Schema20.Number),
   namespace: Schema20.String,
   metadata: Schema20.optional(Schema20.String),
   embedding: Schema20.optional(Schema20.Array(Schema20.Number)),
@@ -6271,7 +6475,7 @@ var WriteMemoryInput = Schema20.Struct({
   content: Schema20.String,
   contentType: Schema20.optional(Schema20.String),
   namespace: Schema20.optional(Schema20.String),
-  ttlSecs: Schema20.optional(Schema20.Number),
+  ttlSecs: Schema20.optional(Schema20.NullOr(Schema20.Number)),
   metadata: Schema20.optional(Schema20.String),
   typedMetadata: Schema20.optional(MemoryMetadata)
 });
@@ -6324,7 +6528,103 @@ class Service9 extends Context9.Service()("@dimple/embedder/EmbeddingModelRegist
 }
 // ../embedder/src/transformers.ts
 import { Config as Config5, Effect as Effect32, Layer as Layer11 } from "effect";
-import { pipeline, env } from "@huggingface/transformers";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// ../embedder/src/auto-install.ts
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+var detectPackageManager = (cwd) => {
+  let dir = cwd;
+  while (true) {
+    if (existsSync(join(dir, "bun.lock")) || existsSync(join(dir, "bun.lockb"))) {
+      return { pm: "bun", root: dir };
+    }
+    if (existsSync(join(dir, "pnpm-lock.yaml")))
+      return { pm: "pnpm", root: dir };
+    if (existsSync(join(dir, "yarn.lock")))
+      return { pm: "yarn", root: dir };
+    if (existsSync(join(dir, "package-lock.json")))
+      return { pm: "npm", root: dir };
+    const parent = join(dir, "..");
+    if (parent === dir)
+      return { pm: "bun", root: cwd };
+    dir = parent;
+  }
+};
+var installCommand = (pm) => {
+  switch (pm) {
+    case "bun":
+      return ["bun", "add", "@huggingface/transformers"];
+    case "npm":
+      return [
+        "npm",
+        "install",
+        "@huggingface/transformers",
+        "--ignore-scripts",
+        "--no-audit",
+        "--no-fund"
+      ];
+    case "pnpm":
+      return ["pnpm", "add", "@huggingface/transformers", "--ignore-scripts"];
+    case "yarn":
+      return ["yarn", "add", "@huggingface/transformers", "--ignore-scripts"];
+  }
+};
+var installTransformers = (cwd) => new Promise((resolve, reject) => {
+  const target = detectPackageManager(cwd);
+  const [cmd, ...args] = installCommand(target.pm);
+  execFile(cmd, args, { cwd: target.root, encoding: "utf8" }, (error) => {
+    if (error) {
+      reject(new Error(`auto-install of @huggingface/transformers failed (${target.pm} add …): ${error.message} — ` + "run it manually or set `autoInstall: false` and configure a hosted embedding provider"));
+      return;
+    }
+    resolve();
+  });
+});
+
+// ../embedder/src/transformers.ts
+var transformersEntryPath = (root) => {
+  let dir = root;
+  while (true) {
+    const pkgJson = join2(dir, "node_modules", "@huggingface", "transformers", "package.json");
+    if (existsSync2(pkgJson)) {
+      let entry;
+      try {
+        const pkg = JSON.parse(readFileSync(pkgJson, "utf8"));
+        const ex = pkg.exports;
+        const dot4 = typeof ex === "object" ? ex["."] : ex;
+        entry = typeof dot4 === "string" ? dot4 : dot4?.import ?? dot4?.default ?? pkg.module ?? pkg.main ?? "index.js";
+      } catch {
+        entry = "index.js";
+      }
+      return join2(dir, "node_modules", "@huggingface", "transformers", entry);
+    }
+    const parent = join2(dir, "..");
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+};
+var importFromDisk = () => new Promise((resolve, reject) => {
+  try {
+    const root = detectPackageManager(process.cwd()).root;
+    const entry = transformersEntryPath(root);
+    if (entry === null) {
+      reject(new Error("@huggingface/transformers not found on disk after install"));
+      return;
+    }
+    import(pathToFileURL(entry).href).then((mod) => {
+      resolve(mod);
+    }).catch((cause) => {
+      reject(cause);
+    });
+  } catch (cause) {
+    reject(cause);
+  }
+});
 var defaults2 = {
   modelId: "Xenova/all-MiniLM-L6-v2",
   device: "cpu",
@@ -6332,14 +6632,31 @@ var defaults2 = {
   pooling: "mean",
   normalize: true
 };
-var make6 = (options) => {
+var make5 = (options) => {
   let pipe = null;
   const getPipeline = Effect32.fnUntraced(function* () {
     if (pipe)
       return pipe;
+    const loadModule = () => Effect32.tryPromise(() => import("@huggingface/transformers"));
+    let transformers = yield* loadModule().pipe(Effect32.catch(() => {
+      if (options.autoInstall === false) {
+        return Effect32.fail(new EmbeddingError({
+          message: "@huggingface/transformers is not installed — run `bun add @huggingface/transformers` " + "to use local embeddings (or configure a hosted embedding provider)"
+        }));
+      }
+      return Effect32.gen(function* () {
+        yield* Effect32.logInfo("auto-installing @huggingface/transformers (first local-embed use — scripts skipped)").pipe(Effect32.annotateLogs({ scope: "@dimple/embedder", event: "embedder.auto-install" }));
+        yield* Effect32.tryPromise(() => installTransformers(process.cwd())).pipe(Effect32.timeout("5 minutes"), Effect32.catch((cause) => Effect32.fail(new EmbeddingError({
+          message: cause._tag === "TimeoutError" ? "auto-install of @huggingface/transformers timed out (5 minutes) — run " + "`bun add @huggingface/transformers` manually" : cause.cause instanceof Error ? cause.cause.message : cause instanceof Error ? cause.message : `auto-install failed: ${String(cause)}`
+        }))));
+        return yield* Effect32.tryPromise(importFromDisk).pipe(Effect32.mapError(() => new EmbeddingError({
+          message: "@huggingface/transformers still unavailable after auto-install — run `bun add " + "@huggingface/transformers` manually (or set `autoInstall: false` and configure a hosted embedding provider)"
+        })));
+      });
+    }));
     if (options.cacheDir)
-      env.cacheDir = options.cacheDir;
-    pipe = yield* Effect32.promise(() => pipeline("feature-extraction", options.modelId ?? defaults2.modelId, {
+      transformers.env.cacheDir = options.cacheDir;
+    pipe = yield* Effect32.tryPromise(() => transformers.pipeline("feature-extraction", options.modelId ?? defaults2.modelId, {
       device: options.device ?? defaults2.device,
       dtype: options.dtype ?? defaults2.dtype
     })).pipe(Effect32.mapError((cause) => new EmbeddingError({ message: `load model: ${cause}` })));
@@ -6385,7 +6702,7 @@ var make6 = (options) => {
   return { embed, embedSingle };
 };
 var makeTransformersModel = (options = {}) => {
-  const impl = make6(options);
+  const impl = make5(options);
   return {
     modelId: options.modelId ?? "local-minilm",
     provider: "transformers",
@@ -6394,46 +6711,72 @@ var makeTransformersModel = (options = {}) => {
     embedSingle: impl.embedSingle
   };
 };
-// ../embedder/src/openai.ts
-import { Effect as Effect33 } from "effect";
-var makeOpenAIModel = (options) => {
-  const embed = Effect33.fn("OpenAIEmbedding.embed")(function* (texts) {
-    const response = yield* Effect33.tryPromise({
-      try: () => fetch("https://api.openai.com/v1/embeddings", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${options.apiKey}`
-        },
-        body: JSON.stringify({
-          input: texts,
-          model: options.model,
-          dimensions: options.dimensions
-        })
-      }).then((r) => {
-        if (!r.ok) {
-          return Promise.reject(new Error(`OpenAI API error: ${r.status} ${r.statusText}`));
+// ../embedder/src/registry.ts
+import { Effect as Effect33, Layer as Layer12 } from "effect";
+// ../core/src/hosted-embedding.ts
+import { embedMany } from "ai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createCohere } from "@ai-sdk/cohere";
+import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+import { Effect as Effect34 } from "effect";
+var makeHostedEmbeddingModel = (options) => {
+  const provider = options.provider ?? "openai";
+  const model = provider === "google" ? createGoogleGenerativeAI({
+    apiKey: options.apiKey,
+    ...options.baseURL !== undefined ? { baseURL: options.baseURL } : {}
+  }).embedding(options.model) : provider === "cohere" ? createCohere({ apiKey: options.apiKey }).embedding(options.model) : provider === "bedrock" ? createAmazonBedrock({
+    ...options.apiKey !== undefined ? { apiKey: options.apiKey } : {}
+  }).embedding(options.model) : createOpenAICompatible({
+    name: "openaiCompatible",
+    baseURL: options.baseURL ?? "https://api.openai.com/v1",
+    apiKey: options.apiKey
+  }).embeddingModel(options.model);
+  const providerOptions = (() => {
+    switch (provider) {
+      case "google":
+        return { google: { outputDimensionality: options.dimensions } };
+      case "bedrock":
+        if (options.model.startsWith("amazon.nova")) {
+          return { bedrock: { embeddingDimension: options.dimensions } };
         }
-        return r.json();
-      }),
-      catch: (cause) => new EmbeddingError({ message: `OpenAI embed: ${cause}` })
+        if (options.model.startsWith("cohere.")) {
+          return { bedrock: { inputType: "search_document" } };
+        }
+        return { bedrock: { dimensions: options.dimensions } };
+      case "cohere":
+        return [256, 512, 1024, 1536].includes(options.dimensions) ? { cohere: { inputType: "search_document", outputDimension: options.dimensions } } : { cohere: { inputType: "search_document" } };
+      default:
+        return { openaiCompatible: { dimensions: options.dimensions } };
+    }
+  })();
+  const embed = Effect34.fn("HostedEmbedding.embed")(function* (texts) {
+    const result = yield* Effect34.tryPromise({
+      try: () => embedMany({ model, values: [...texts], providerOptions }),
+      catch: (cause) => new EmbeddingError({ message: `hosted embedMany: ${cause}` })
     });
-    return response.data.map((d) => new Float32Array(d.embedding));
+    for (const vector of result.embeddings) {
+      if (vector.length !== options.dimensions) {
+        return yield* new EmbeddingError({
+          message: `hosted embedder dimension mismatch: endpoint returned ${vector.length} dims but config declares ${options.dimensions}`
+        });
+      }
+    }
+    return result.embeddings.map((e) => new Float32Array(e));
   });
-  const embedSingle = Effect33.fn("OpenAIEmbedding.embedSingle")(function* (text4) {
+  const embedSingle = Effect34.fn("HostedEmbedding.embedSingle")(function* (text4) {
     const results = yield* embed([text4]);
     return results[0];
   });
   return {
     modelId: options.modelId,
-    provider: "openai",
+    provider,
     dimensions: options.dimensions,
     embed,
     embedSingle
   };
 };
-// ../embedder/src/registry.ts
-import { Effect as Effect34, Layer as Layer12 } from "effect";
+
 // ../retriever/src/hybrid.ts
 import { Context as Context10, Effect as Effect35, Layer as Layer13, Schema as Schema22 } from "effect";
 
@@ -6490,7 +6833,7 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
     const namespace = options2?.namespace ?? "default";
     const limit = options2?.limit ?? defaultLimit;
     const k = options2?.k ?? defaultK;
-    const profile = typeof options2?.profile === "string" ? {} : options2?.profile ?? {};
+    const profile = typeof options2?.profile === "string" ? options2.profile === "keyword" ? { modeWeights: { vector: 0, fts: 1 } } : options2.profile === "semantic" ? { modeWeights: { vector: 1, fts: 0 } } : {} : options2?.profile ?? {};
     const topicKeys = options2?.topics?.topicKeys;
     const fetchMultiplier = 2;
     const start = Date.now();
@@ -6502,21 +6845,24 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
       vectorOpts.conceptIds = profile.conceptFilter;
     const vectorResults = yield* store.searchVector([...embedding], namespace, limit * fetchMultiplier, {
       ...vectorOpts,
+      ...options2?.contentType !== undefined ? { contentType: options2.contentType } : {},
       audit: false
     }).pipe(wrapError("searchVector"));
     const fts5Results = yield* store.searchFts5(query2, namespace, limit * fetchMultiplier, {
       ...topicKeys !== undefined ? { topicKeys } : {},
+      ...options2?.contentType !== undefined ? { contentType: options2.contentType } : {},
       audit: false
     }).pipe(wrapError("searchFts5"));
     const vWeight = profile.modeWeights?.vector ?? 1;
     const fWeight = profile.modeWeights?.fts ?? 1;
+    const mode = vWeight === 0 && fWeight > 0 ? "keyword" : fWeight === 0 && vWeight > 0 ? "semantic" : "hybrid";
     const denseRanks = vectorResults.length > 0 ? vectorResults.map((s) => [s.memory.id, s.score * vWeight]) : null;
     const fts5Ranks = fts5Results.length > 0 ? fts5Results.map((s) => [s.memory.id, s.score * fWeight]) : null;
     if (!denseRanks && !fts5Ranks) {
       yield* store.logAudit({
         query: query2,
         namespace,
-        mode: "hybrid",
+        mode,
         resultCount: 0,
         startTime: start,
         queryProfile: JSON.stringify({
@@ -6524,6 +6870,7 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
           recencyBoost: profile.recencyBoost ?? 0,
           conceptFilter: profile.conceptFilter,
           topicKeys,
+          contentType: options2?.contentType,
           legs: { vector: { count: 0, topScores: [] }, fts: { count: 0, topScores: [] } }
         }),
         sources: JSON.stringify({ vector: [], fts: [] })
@@ -6566,7 +6913,7 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
     yield* store.logAudit({
       query: query2,
       namespace,
-      mode: "hybrid",
+      mode,
       resultCount: results.length,
       startTime: start,
       queryProfile: JSON.stringify({
@@ -6574,6 +6921,7 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
         recencyBoost: profile.recencyBoost ?? 0,
         conceptFilter: profile.conceptFilter,
         topicKeys,
+        contentType: options2?.contentType,
         legs: {
           vector: {
             count: vectorResults.length,
@@ -6590,9 +6938,10 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
         fts: fts5Results.map((s) => s.memory.id)
       })
     }).pipe(wrapError("logAudit"));
-    yield* Effect35.logDebug("hybrid.search").pipe(Effect35.annotateLogs({
+    yield* Effect35.logInfo("hybrid.search").pipe(Effect35.annotateLogs({
       scope: "@dimple/retriever",
       event: "hybrid.search",
+      mode,
       namespace,
       query: query2,
       resultCount: results.length
@@ -6730,9 +7079,9 @@ ${schemaJson}`,
   return { generateText, generateObject };
 };
 // ../llm/src/provider.ts
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createOpenAICompatible as createOpenAICompatible2 } from "@ai-sdk/openai-compatible";
 var openAICompatible = (options) => {
-  const provider = createOpenAICompatible({
+  const provider = createOpenAICompatible2({
     baseURL: options.baseURL,
     apiKey: options.apiKey,
     name: options.name ?? "openai-compatible"
@@ -6834,12 +7183,15 @@ var embedderFromConfig = (model) => model.provider === "transformers" ? Effect39
   ...model.dtype !== undefined ? { dtype: model.dtype } : {},
   ...model.pooling !== undefined ? { pooling: model.pooling } : {},
   ...model.normalize !== undefined ? { normalize: model.normalize } : {},
-  ...model.cacheDir !== undefined ? { cacheDir: model.cacheDir } : {}
-})) : model.provider === "openai" ? model.apiKey === undefined ? Effect39.fail(new EmbeddingError({ message: `OpenAI model ${model.id} requires an apiKey` })) : Effect39.succeed(makeOpenAIModel({
+  ...model.cacheDir !== undefined ? { cacheDir: model.cacheDir } : {},
+  ...model.autoInstall !== undefined ? { autoInstall: model.autoInstall } : {}
+})) : model.provider === "openai" ? model.apiKey === undefined ? Effect39.fail(new EmbeddingError({ message: `OpenAI model ${model.id} requires an apiKey` })) : Effect39.succeed(makeHostedEmbeddingModel({
   modelId: model.id,
   model: model.model,
   dimensions: model.dimensions,
-  apiKey: model.apiKey
+  apiKey: model.apiKey,
+  ...model.provider !== "openai" ? { provider: model.provider } : {},
+  ...model.baseURL !== undefined ? { baseURL: model.baseURL } : {}
 })) : Effect39.fail(new EmbeddingError({ message: `Unknown provider: ${model.provider}` }));
 var layer13 = (options) => {
   const topicConfig = Schema24.decodeUnknownSync(TopicConfig)(options.topics?.config ?? {});
@@ -7013,7 +7365,8 @@ var ExtractedChunk = Schema25.Struct({
   startLine: Schema25.Number,
   endLine: Schema25.Number,
   language: Schema25.String,
-  docstring: Schema25.optional(Schema25.String)
+  docstring: Schema25.optional(Schema25.String),
+  calls: Schema25.optional(Schema25.Array(Schema25.Struct({ name: Schema25.String, line: Schema25.Number })))
 });
 var ImportInfo = Schema25.Struct({
   source: Schema25.String,
@@ -7097,6 +7450,7 @@ function emit(source, semantic, filePath, lang, chunks) {
 }
 function makeChunk(source, _semantic, filePath, lang, kind, name, docstring, parentClass) {
   const id = parentClass ? `${filePath}:${parentClass}.${name}:${source.startPosition.row + 1}` : `${filePath}:${name}:${source.startPosition.row + 1}`;
+  const calls = callsOf(source);
   return {
     id,
     filePath,
@@ -7106,9 +7460,49 @@ function makeChunk(source, _semantic, filePath, lang, kind, name, docstring, par
     startLine: source.startPosition.row + 1,
     endLine: source.endPosition.row + 1,
     language: lang,
-    docstring
+    docstring,
+    ...calls.length > 0 ? { calls } : {}
   };
 }
+function callsOf(node) {
+  const out = [];
+  const calleeName = (n) => {
+    let cur = n;
+    for (let guard = 0;guard < 4; guard++) {
+      if (cur.type === "identifier")
+        return cur.text;
+      if (cur.type === "member_expression") {
+        const prop = cur.childForFieldName("property");
+        if (prop === null)
+          return;
+        cur = prop;
+        continue;
+      }
+      if (cur.type === "non_null_expression" || cur.type === "parenthesized_expression") {
+        const inner = cur.namedChildren[0];
+        if (inner === undefined)
+          return;
+        cur = inner;
+        continue;
+      }
+      return;
+    }
+    return;
+  };
+  const visit = (n) => {
+    if (n.type === "call_expression") {
+      const callee = n.childForFieldName("function");
+      const name = callee === null ? undefined : calleeName(callee);
+      if (name !== undefined && name.length > 0) {
+        out.push({ name, line: n.startPosition.row + 1 });
+      }
+    }
+    for (const child of n.namedChildren)
+      visit(child);
+  };
+  visit(node);
+  return out;
+}
 function unwrap2(node) {
   for (const child of node.namedChildren) {
     if (child.type !== "decorator" && child.type !== "comment")
@@ -7584,11 +7978,11 @@ class Service15 extends Context15.Service()("@dimple/wasm/WasmDownloader") {
 }
 // ../wasm/src/wasm-cache.ts
 import { Context as Context16, Effect as Effect43, Layer as Layer20 } from "effect";
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, renameSync, writeFileSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync3, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { join as join3 } from "node:path";
 
 // ../../node_modules/.bun/env-paths@4.0.0/node_modules/env-paths/index.js
-import path2 from "node:path";
+import path from "node:path";
 import os from "node:os";
 import process2 from "node:process";
 
@@ -7628,36 +8022,36 @@ function assertSafeFilename(filename) {
 // ../../node_modules/.bun/env-paths@4.0.0/node_modules/env-paths/index.js
 var homedir = os.homedir();
 var tmpdir = os.tmpdir();
-var { env: env2 } = process2;
+var { env } = process2;
 var macos = (name) => {
-  const library = path2.join(homedir, "Library");
+  const library = path.join(homedir, "Library");
   return {
-    data: path2.join(library, "Application Support", name),
-    config: path2.join(library, "Preferences", name),
-    cache: path2.join(library, "Caches", name),
-    log: path2.join(library, "Logs", name),
-    temp: path2.join(tmpdir, name)
+    data: path.join(library, "Application Support", name),
+    config: path.join(library, "Preferences", name),
+    cache: path.join(library, "Caches", name),
+    log: path.join(library, "Logs", name),
+    temp: path.join(tmpdir, name)
   };
 };
 var windows = (name) => {
-  const appData = env2.APPDATA || path2.join(homedir, "AppData", "Roaming");
-  const localAppData = env2.LOCALAPPDATA || path2.join(homedir, "AppData", "Local");
+  const appData = env.APPDATA || path.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path.join(homedir, "AppData", "Local");
   return {
-    data: path2.join(localAppData, name, "Data"),
-    config: path2.join(appData, name, "Config"),
-    cache: path2.join(localAppData, name, "Cache"),
-    log: path2.join(localAppData, name, "Log"),
-    temp: path2.join(tmpdir, name)
+    data: path.join(localAppData, name, "Data"),
+    config: path.join(appData, name, "Config"),
+    cache: path.join(localAppData, name, "Cache"),
+    log: path.join(localAppData, name, "Log"),
+    temp: path.join(tmpdir, name)
   };
 };
 var linux = (name) => {
-  const username = path2.basename(homedir);
+  const username = path.basename(homedir);
   return {
-    data: path2.join(env2.XDG_DATA_HOME || path2.join(homedir, ".local", "share"), name),
-    config: path2.join(env2.XDG_CONFIG_HOME || path2.join(homedir, ".config"), name),
-    cache: path2.join(env2.XDG_CACHE_HOME || path2.join(homedir, ".cache"), name),
-    log: path2.join(env2.XDG_STATE_HOME || path2.join(homedir, ".local", "state"), name),
-    temp: path2.join(tmpdir, username, name)
+    data: path.join(env.XDG_DATA_HOME || path.join(homedir, ".local", "share"), name),
+    config: path.join(env.XDG_CONFIG_HOME || path.join(homedir, ".config"), name),
+    cache: path.join(env.XDG_CACHE_HOME || path.join(homedir, ".cache"), name),
+    log: path.join(env.XDG_STATE_HOME || path.join(homedir, ".local", "state"), name),
+    temp: path.join(tmpdir, username, name)
   };
 };
 function envPaths(name, { suffix = "nodejs" } = {}) {
@@ -7682,19 +8076,19 @@ class Service16 extends Context16.Service()("@dimple/wasm/WasmCache") {
 }
 var layer16 = Layer20.effect(Service16, Effect43.succeed(Service16.of({
   ensure: Effect43.fn("WasmCache.ensure")(function* (lang, version, download) {
-    const versionDir = join2(paths.cache, "tree-sitter", lang, version);
-    const finalPath = join2(versionDir, "parser.wasm");
+    const versionDir = join3(paths.cache, "tree-sitter", lang, version);
+    const finalPath = join3(versionDir, "parser.wasm");
     const exists = yield* Effect43.try({
-      try: () => existsSync2(finalPath),
+      try: () => existsSync3(finalPath),
       catch: (cause) => new WasmCacheError({ message: `Failed to stat ${finalPath}`, cause })
     });
     if (exists)
       return finalPath;
     yield* Effect43.try({
-      try: () => mkdirSync3(versionDir, { recursive: true }),
+      try: () => mkdirSync(versionDir, { recursive: true }),
       catch: (cause) => new WasmCacheError({ message: `Failed to create ${versionDir}`, cause })
     });
-    const tempPath = join2(versionDir, `.tmp-${process.pid}`);
+    const tempPath = join3(versionDir, `.tmp-${process.pid}`);
     const wasm = yield* download;
     yield* Effect43.try({
       try: () => writeFileSync(tempPath, wasm),
@@ -7709,7 +8103,7 @@ var layer16 = Layer20.effect(Service16, Effect43.succeed(Service16.of({
     }).pipe(Effect43.catchCause(() => Effect43.succeed(false)));
     if (!renamed) {
       const existsAfter = yield* Effect43.try({
-        try: () => existsSync2(finalPath),
+        try: () => existsSync3(finalPath),
         catch: (cause) => new WasmCacheError({ message: `Failed to stat ${finalPath}`, cause })
       });
       if (!existsAfter) {
@@ -7740,12 +8134,12 @@ var layer17 = Layer21.effect(Service17, Effect44.gen(function* () {
       message: `Failed to download grammar for: ${lang}`,
       cause
     })));
-    const path3 = yield* cache.ensure(lang, metadata.version, Effect44.succeed(wasmBytes)).pipe(Effect44.mapError((cause) => new GrammarProvisionError({
+    const path2 = yield* cache.ensure(lang, metadata.version, Effect44.succeed(wasmBytes)).pipe(Effect44.mapError((cause) => new GrammarProvisionError({
       language: lang,
       message: `Failed to provision grammar for: ${lang}`,
       cause
     })));
-    return path3;
+    return path2;
   });
   return Service17.of({ ensure });
 }));
@@ -7864,11 +8258,27 @@ class DuplicateEdgeError extends Schema33.TaggedErrorClass()("Sdk.DuplicateEdge"
 }) {
 }
 
+class EdgeNotFoundError extends Schema33.TaggedErrorClass()("Sdk.EdgeNotFound", {
+  id: Schema33.optional(Schema33.String),
+  message: Schema33.String
+}) {
+}
+
 class StoreFailure extends Schema33.TaggedErrorClass()("Sdk.StoreFailure", {
   message: Schema33.String
 }) {
 }
 
+class ReloadError extends Schema33.TaggedErrorClass()("Sdk.Reload", {
+  message: Schema33.String
+}) {
+}
+
+class EmbeddingFailure extends Schema33.TaggedErrorClass()("Sdk.Embedding", {
+  message: Schema33.String
+}) {
+}
+
 class InputError extends Schema33.TaggedErrorClass()("Sdk.InputError", {
   message: Schema33.String
 }) {
@@ -7890,12 +8300,14 @@ var messageOf = (error) => {
   }
 };
 var remapError = (error) => {
-  if (error instanceof ConfigError || error instanceof NotFoundError || error instanceof DuplicateKeyError || error instanceof DuplicateEdgeError || error instanceof LLMNotConfiguredError || error instanceof JobFailedError || error instanceof StoreFailure || error instanceof InputError) {
+  if (error instanceof ConfigError || error instanceof NotFoundError || error instanceof DuplicateKeyError || error instanceof DuplicateEdgeError || error instanceof EdgeNotFoundError || error instanceof LLMNotConfiguredError || error instanceof JobFailedError || error instanceof EmbeddingFailure || error instanceof StoreFailure || error instanceof ReloadError || error instanceof InputError) {
     return error;
   }
   const message = messageOf(error);
   if (error instanceof CoreConfigError)
     return new ConfigError({ message });
+  if (error instanceof EmbeddingError)
+    return new EmbeddingFailure({ message });
   if (error instanceof NotFound) {
     return new NotFoundError({
       ...error.id !== undefined ? { id: error.id } : {},
@@ -7917,6 +8329,12 @@ var remapError = (error) => {
       message: `Edge already exists: ${error.fromMemoryId} → ${error.toMemoryId} (${error.edgeKind})`
     });
   }
+  if (error instanceof exports_graph.EdgeNotFound) {
+    return new EdgeNotFoundError({
+      ...error.id !== undefined ? { id: error.id } : {},
+      message: `Edge not found: ${error.id ?? "unknown id"}`
+    });
+  }
   if (error instanceof JobFailed || error instanceof JobTimeout || error instanceof JobCancelled) {
     return message.includes("LLM not configured") ? new LLMNotConfiguredError({ message }) : new JobFailedError({ message });
   }
@@ -7933,8 +8351,9 @@ var configLayerFromInput = (input) => Layer25.effect(Service4, resolveConfigInpu
 import { Cause as Cause5, Effect as Effect49, Exit as Exit6 } from "effect";
 
 // src/indexer.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import { basename, dirname as dirname4, extname, join as join3, resolve, sep } from "node:path";
+import { execFileSync } from "node:child_process";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { basename, dirname, extname, join as join4, resolve, sep } from "node:path";
 var INDEXABLE_EXTENSIONS = [
   ".ts",
   ".mts",
@@ -7971,52 +8390,68 @@ var LANGUAGE_BY_EXTENSION = {
   ".cjs": "javascript",
   ".jsx": "jsx"
 };
-var languageForPath = (path3) => LANGUAGE_BY_EXTENSION[extname(path3)];
+var languageForPath = (path2) => LANGUAGE_BY_EXTENSION[extname(path2)];
 var walkFiles = (paths2, extensions) => {
   const extensionSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const files = [];
   const errors3 = [];
   let unsupported = 0;
-  const root = commonRoot([...paths2, process.cwd()]);
-  const visit = (path3) => {
+  const resolved = paths2.map((p) => resolve(p));
+  const root = commonRoot([...resolved, process.cwd()]);
+  const visit = (path2) => {
     let stat;
     try {
-      stat = statSync2(path3);
+      stat = statSync(path2);
     } catch (cause) {
-      errors3.push({ filePath: path3, message: `stat failed: ${messageOf2(cause)}` });
+      errors3.push({ filePath: path2, message: `stat failed: ${messageOf2(cause)}` });
       return;
     }
     if (stat.isDirectory()) {
-      const name = basename(path3);
+      const name = basename(path2);
       if (EXCLUDED_DIRS.has(name))
         return;
       let entries;
       try {
-        entries = readdirSync(path3);
+        entries = readdirSync(path2);
       } catch (cause) {
-        errors3.push({ filePath: path3, message: `readdir failed: ${messageOf2(cause)}` });
+        errors3.push({ filePath: path2, message: `readdir failed: ${messageOf2(cause)}` });
         return;
       }
       for (const entry of entries)
-        visit(join3(path3, entry));
+        visit(join4(path2, entry));
       return;
     }
     if (!stat.isFile())
       return;
-    if (!extensionSet.has(extname(path3))) {
+    if (!extensionSet.has(extname(path2))) {
       unsupported += 1;
       return;
     }
-    files.push(path3);
+    files.push(path2);
   };
-  for (const path3 of paths2)
-    visit(resolve(path3));
-  return { files, unsupported, errors: errors3, root };
+  for (const path2 of resolved)
+    visit(path2);
+  return { files, unsupported, errors: errors3, root, roots: resolved };
 };
-var readCapped = (path3, maxBytes) => {
-  const text4 = readFileSync2(path3, "utf8");
+var readCapped = (path2, maxBytes) => {
+  const text4 = readFileSync2(path2, "utf8");
   return text4.length > maxBytes ? text4.slice(0, maxBytes) : text4;
 };
+var currentCommit = (firstFile) => {
+  if (firstFile === undefined)
+    return null;
+  try {
+    const out = execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd: dirname(firstFile),
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const sha = out.trim();
+    return /^[0-9a-f]{7,40}$/.test(sha) ? sha : null;
+  } catch {
+    return null;
+  }
+};
 var resolveImportTarget = (fromDir, specifier, extensions) => {
   if (!specifier.startsWith("."))
     return;
@@ -8024,11 +8459,11 @@ var resolveImportTarget = (fromDir, specifier, extensions) => {
   const candidates2 = [
     base,
     ...extensions.map((e) => base + e),
-    ...extensions.map((e) => join3(base, `index${e}`))
+    ...extensions.map((e) => join4(base, `index${e}`))
   ];
   for (const candidate of candidates2) {
     try {
-      if (existsSync3(candidate) && statSync2(candidate).isFile())
+      if (existsSync4(candidate) && statSync(candidate).isFile())
         return candidate;
     } catch {
       return;
@@ -8039,7 +8474,7 @@ var resolveImportTarget = (fromDir, specifier, extensions) => {
 var resolveImports = (filePath, sources, extensions) => {
   const targets = [];
   for (const source of sources) {
-    const target = resolveImportTarget(dirname4(filePath), source, extensions);
+    const target = resolveImportTarget(dirname(filePath), source, extensions);
     if (target !== undefined)
       targets.push(target);
   }
@@ -8069,16 +8504,11 @@ var keyForPath = (root, filePath) => {
 var messageOf2 = (cause) => cause instanceof Error ? cause.message : String(cause);
 
 // src/dimple.ts
-var makeFacade = (runtime, core, parser, extractor, dispose) => {
-  let disposed = false;
-  const run = (effect) => {
-    if (disposed) {
-      return Promise.reject(new StoreFailure({ message: "SDK disposed" }));
-    }
-    return runtime.runPromise(effect.pipe(Effect49.mapError(remapError))).catch((cause) => {
-      return Promise.reject(remapError(cause));
-    });
-  };
+var makeFacade = (state, reload, dispose) => {
+  const run = state.run;
+  const core = () => state.core();
+  const parser = () => state.parser();
+  const extractor = () => state.extractor();
   const validateQueryOptions = (options) => {
     const limit = options?.limit;
     if (limit !== undefined && (!Number.isInteger(limit) || limit < 0)) {
@@ -8090,6 +8520,23 @@ var makeFacade = (runtime, core, parser, extractor, dispose) => {
     if (k !== undefined && (!Number.isInteger(k) || k < 0)) {
       return new InputError({ message: `query: k must be a non-negative integer (got ${k})` });
     }
+    const budget = options?.budget;
+    if (budget !== undefined) {
+      if (budget === null || typeof budget !== "object" || Array.isArray(budget)) {
+        return new InputError({ message: "query: budget must be an object" });
+      }
+      for (const [name, v] of [
+        ["maxUnits", budget.maxUnits],
+        ["maxChars", budget.maxChars],
+        ["maxMs", budget.maxMs]
+      ]) {
+        if (v !== undefined && (!Number.isInteger(v) || v <= 0)) {
+          return new InputError({
+            message: `query: budget.${name} must be a positive integer (got ${String(v)})`
+          });
+        }
+      }
+    }
     const profile = options?.profile;
     if (profile !== undefined) {
       if (typeof profile === "string") {
@@ -8130,13 +8577,57 @@ var makeFacade = (runtime, core, parser, extractor, dispose) => {
     if (topicKeys !== undefined && (!Array.isArray(topicKeys) || topicKeys.some((t) => typeof t !== "string"))) {
       return new InputError({ message: "query: topics.topicKeys must be a string array" });
     }
+    const contentType = options?.contentType;
+    if (contentType !== undefined) {
+      const kinds = typeof contentType === "string" ? [contentType] : contentType;
+      if (kinds.length === 0 || kinds.some((k2) => typeof k2 !== "string" || k2.length === 0)) {
+        return new InputError({
+          message: "query: contentType must be a non-empty string or a non-empty string array"
+        });
+      }
+    }
     return;
   };
   const runQuery = (text4, options) => run(Effect49.gen(function* () {
+    if (typeof text4 !== "string") {
+      return yield* new InputError({ message: "query: text must be a string" });
+    }
     const invalid = validateQueryOptions(options);
     if (invalid !== undefined)
       return yield* invalid;
-    return yield* core.hybrid.hybrid(text4, options).pipe(Effect49.map((rows) => [...rows]));
+    const { budget, ...rest } = options ?? {};
+    const started = Date.now();
+    const capLimit = budget?.maxUnits !== undefined && (rest.limit === undefined || rest.limit > budget.maxUnits) ? budget.maxUnits : rest.limit;
+    let rows = yield* core().hybrid.hybrid(text4, {
+      ...rest,
+      ...capLimit !== undefined ? { limit: capLimit } : {}
+    }).pipe(Effect49.map((r) => [...r]));
+    let truncated = false;
+    if (budget?.maxChars !== undefined && budget.maxChars > 0) {
+      let used = 0;
+      rows = rows.map((row) => {
+        const content = row.memory.content;
+        const room = budget.maxChars - used;
+        if (room <= 0) {
+          truncated = true;
+          return { ...row, memory: { ...row.memory, content: "" } };
+        }
+        if (content.length > room) {
+          truncated = true;
+          used += room;
+          return { ...row, memory: { ...row.memory, content: content.slice(0, room) } };
+        }
+        used += content.length;
+        return row;
+      });
+    }
+    if (budget?.maxMs !== undefined && Date.now() - started > budget.maxMs) {
+      truncated = true;
+    }
+    const out = rows;
+    if (truncated)
+      out.truncated = true;
+    return out;
   }));
   const validateWriteInput = (input) => {
     if (input === null || typeof input !== "object" || Array.isArray(input)) {
@@ -8155,9 +8646,9 @@ var makeFacade = (runtime, core, parser, extractor, dispose) => {
       return new InputError({ message: "write: namespace must be a string" });
     }
     const ttl = input.ttlSecs;
-    if (ttl !== undefined && (!Number.isInteger(ttl) || ttl < 0)) {
+    if (typeof ttl === "number" && (!Number.isInteger(ttl) || ttl < 0)) {
       return new InputError({
-        message: `write: ttlSecs must be a non-negative integer (got ${String(ttl)})`
+        message: `write: ttlSecs must be a non-negative integer or null (got ${String(ttl)})`
       });
     }
     if (input.metadata !== undefined && typeof input.metadata !== "string") {
@@ -8201,15 +8692,47 @@ var makeFacade = (runtime, core, parser, extractor, dispose) => {
     return;
   };
   const writeUnit = (input, embed) => Effect49.gen(function* () {
-    const mem = yield* core.store.write(input);
+    const mem = yield* core().store.write(input);
     if (embed) {
-      yield* core.store.ensureTopicTree(core.defaultModel.id);
-      const vector = yield* core.defaultEmbedder.embedSingle(input.content);
-      yield* core.store.updateEmbedding(mem.id, [...vector], core.defaultModel.id);
-      return yield* core.store.get(mem.id);
+      yield* core().store.ensureTopicTree(core().defaultModel.id);
+      const vector = yield* core().defaultEmbedder.embedSingle(input.content);
+      yield* core().store.updateEmbedding(mem.id, [...vector], core().defaultModel.id);
+      return yield* core().store.get(mem.id);
     }
     return mem;
   });
+  const upsertUnit = (input, embed) => Effect49.gen(function* () {
+    const existing = yield* core().store.getByKey(input.logicalKey, input.namespace ?? "default").pipe(Effect49.catchTag("Store.NotFound", () => Effect49.succeed(undefined)));
+    if (existing !== undefined && existing.content === input.content) {
+      const stamp = codeVersionOf(input.metadata);
+      if (stamp !== undefined && codeVersionOf(existing.metadata) === undefined) {
+        yield* core().store.setMemoryMetadata(existing.id, { codeVersion: stamp });
+      }
+      if (embed && (existing.embedding === null || existing.embedding === undefined)) {
+        yield* core().store.ensureTopicTree(core().defaultModel.id);
+        const vector = yield* core().defaultEmbedder.embedSingle(input.content);
+        yield* core().store.updateEmbedding(existing.id, [...vector], core().defaultModel.id);
+        return { kind: "updated", id: existing.id };
+      }
+      return { kind: "skipped", id: existing.id };
+    }
+    if (existing !== undefined) {
+      const { memory: memory2 } = yield* core().store.writeSuperseding(input);
+      if (embed) {
+        yield* core().store.ensureTopicTree(core().defaultModel.id);
+        const vector = yield* core().defaultEmbedder.embedSingle(input.content);
+        yield* core().store.updateEmbedding(memory2.id, [...vector], core().defaultModel.id);
+      }
+      return { kind: "updated", id: memory2.id };
+    }
+    const memory = yield* core().store.write(input);
+    if (embed) {
+      yield* core().store.ensureTopicTree(core().defaultModel.id);
+      const vector = yield* core().defaultEmbedder.embedSingle(input.content);
+      yield* core().store.updateEmbedding(memory.id, [...vector], core().defaultModel.id);
+    }
+    return { kind: "indexed", id: memory.id };
+  });
   const validateIndexOptions = (options) => {
     if (options === null || typeof options !== "object" || Array.isArray(options)) {
       return new InputError({ message: "index: options must be an object" });
@@ -8244,16 +8767,32 @@ var makeFacade = (runtime, core, parser, extractor, dispose) => {
     return;
   };
   const messageOf3 = (cause) => cause instanceof Error ? cause.message : String(cause);
+  const resolveMemory = (idOrKey) => core().store.get(idOrKey).pipe(Effect49.catchTag("Store.NotFound", () => core().store.getByKey(idOrKey, "default").pipe(Effect49.catchTag("Store.NotFound", () => Effect49.fail(new NotFoundError({ id: idOrKey, message: `Memory not found: ${idOrKey}` }))))));
+  const codeVersionOf = (blob) => {
+    if (blob === undefined || blob === null)
+      return;
+    try {
+      const parsed = JSON.parse(blob);
+      if (parsed !== null && typeof parsed === "object") {
+        const v = parsed["codeVersion"];
+        return typeof v === "string" ? v : undefined;
+      }
+    } catch {}
+    return;
+  };
   return {
+    get defaultModelId() {
+      return core().defaultModel.id;
+    },
     write: (input, options) => run(Effect49.gen(function* () {
       const invalid = validateWriteInput(input);
       if (invalid !== undefined)
         return yield* invalid;
       return yield* writeUnit(input, options?.embed !== false);
     })),
-    get: (id) => run(core.store.get(id)),
+    get: (id) => run(resolveMemory(id)),
     query: runQuery,
-    forget: (id) => run(core.store.forget(id)),
+    forget: (id) => run(resolveMemory(id).pipe(Effect49.flatMap((memory) => core().store.forget(memory.id)))),
     index: (options) => run(Effect49.gen(function* () {
       const invalid = validateIndexOptions(options);
       if (invalid !== undefined)
@@ -8271,13 +8810,19 @@ var makeFacade = (runtime, core, parser, extractor, dispose) => {
         })
       });
       const failed = [...walk.errors];
+      const commit = currentCommit(walk.files[0]);
       let indexed = 0;
+      let updated = 0;
+      let reconciled = 0;
       let skipped = 0;
       const unitIds = new Map;
+      const freshIds = [];
       const pendingEdges = [];
+      const pendingCallEdges = [];
+      const stableChunkId = (chunkId) => chunkId.replace(/:\d+$/, "");
       const parentClassOf = (chunkId) => {
-        const parts = chunkId.split(":");
-        const parentAndMethod = parts[parts.length - 2];
+        const parts = stableChunkId(chunkId).split(":");
+        const parentAndMethod = parts[parts.length - 1];
         if (parentAndMethod === undefined || !parentAndMethod.includes("."))
           return;
         return parentAndMethod.split(".")[0];
@@ -8287,49 +8832,59 @@ var makeFacade = (runtime, core, parser, extractor, dispose) => {
         const language = languageForPath(filePath);
         if (language === undefined)
           continue;
+        const chunkKeyOf = (chunkId) => `${keyPrefix}${relative}#${stableChunkId(chunkId)}`;
         const exit = yield* Effect49.exit(Effect49.gen(function* () {
           const source = yield* Effect49.try({
             try: () => readCapped(filePath, maxFileBytes),
             catch: (cause) => new InputError({ message: `read failed: ${messageOf3(cause)}` })
           });
-          const handle = yield* parser.parse({ lang: language, source });
-          const extracted = yield* extractor.extract({ filePath: relative, tree: handle });
+          const handle = yield* parser().parse({ lang: language, source });
+          const extracted = yield* extractor().extract({ filePath: relative, tree: handle });
           let units = 0;
+          let upd = 0;
           let dups = 0;
           const fileKey = `${keyPrefix}${relative}`;
-          const fileOutcome = yield* writeUnit({
+          const fileOutcome = yield* upsertUnit({
             logicalKey: fileKey,
             content: source,
             ...namespace !== undefined ? { namespace } : {},
+            ttlSecs: null,
             metadata: JSON.stringify({
               filePath,
               language,
               kind: "file",
-              imports: extracted.imports ?? []
+              imports: extracted.imports ?? [],
+              ...commit !== null ? { codeVersion: commit } : {}
             }),
             contentType: `text/x-${language}`
-          }, embed).pipe(Effect49.catchTag("Store.DuplicateActiveKey", () => Effect49.succeed("duplicate")));
-          if (fileOutcome === "duplicate")
+          }, embed);
+          if (fileOutcome.kind === "skipped") {
             dups += 1;
-          else {
-            units += 1;
             unitIds.set(fileKey, fileOutcome.id);
+          } else {
+            if (fileOutcome.kind === "updated")
+              upd += 1;
+            else
+              units += 1;
+            unitIds.set(fileKey, fileOutcome.id);
+            freshIds.push(fileOutcome.id);
           }
           const classKeys = new Map;
           for (const chunk of extracted.chunks) {
             if (chunk.kind === "class" || chunk.kind.endsWith("class")) {
-              classKeys.set(chunk.name, `${keyPrefix}${relative}#${chunk.id}`);
+              classKeys.set(chunk.name, chunkKeyOf(chunk.id));
             }
           }
           for (const chunk of extracted.chunks) {
-            const chunkKey = `${keyPrefix}${relative}#${chunk.id}`;
+            const chunkKey = chunkKeyOf(chunk.id);
             const content = [chunk.docstring, chunk.sourceText].filter((c) => c !== undefined && c.length > 0).join(`
 
 `).slice(0, maxChunkBytes);
-            const chunkOutcome = yield* writeUnit({
+            const chunkOutcome = yield* upsertUnit({
               logicalKey: chunkKey,
               content,
               ...namespace !== undefined ? { namespace } : {},
+              ttlSecs: null,
               metadata: JSON.stringify({
                 filePath,
                 language,
@@ -8337,17 +8892,23 @@ var makeFacade = (runtime, core, parser, extractor, dispose) => {
                 name: chunk.name,
                 startLine: chunk.startLine,
                 endLine: chunk.endLine,
-                ...chunk.docstring !== undefined ? { docstring: chunk.docstring } : {}
+                ...chunk.docstring !== undefined ? { docstring: chunk.docstring } : {},
+                ...commit !== null ? { codeVersion: commit } : {}
               }),
               contentType: `text/x-${language}`
-            }, embed).pipe(Effect49.catchTag("Store.DuplicateActiveKey", () => Effect49.succeed("duplicate")));
-            if (chunkOutcome === "duplicate") {
+            }, embed);
+            if (chunkOutcome.kind === "skipped") {
               dups += 1;
+              unitIds.set(chunkKey, chunkOutcome.id);
             } else {
-              units += 1;
+              if (chunkOutcome.kind === "updated")
+                upd += 1;
+              else
+                units += 1;
               unitIds.set(chunkKey, chunkOutcome.id);
+              freshIds.push(chunkOutcome.id);
             }
-            if (chunkOutcome !== "duplicate" && chunk.kind === "method") {
+            if (chunkOutcome.kind !== "skipped" && chunk.kind === "method") {
               const parent = parentClassOf(chunk.id);
               const classKey = parent === undefined ? undefined : classKeys.get(parent);
               if (classKey !== undefined) {
@@ -8361,37 +8922,68 @@ var makeFacade = (runtime, core, parser, extractor, dispose) => {
               to: fileKey
             });
           }
-          return { units, dups };
+          const importRels = resolveImports(filePath, (extracted.imports ?? []).map((imp) => imp.source), extensions).map((target) => keyForPath(walk.root, target));
+          for (const chunk of extracted.chunks) {
+            const callerKey = chunkKeyOf(chunk.id);
+            if (!unitIds.has(callerKey))
+              continue;
+            for (const call of chunk.calls ?? []) {
+              const candidates2 = [
+                `${keyPrefix}${relative}#${relative}:${call.name}`,
+                ...importRels.map((rel) => `${keyPrefix}${rel}#${rel}:${call.name}`)
+              ];
+              const first = candidates2.find((key) => unitIds.has(key));
+              if (first !== undefined) {
+                pendingCallEdges.push({ from: callerKey, to: first });
+              }
+            }
+          }
+          return { units, upd, dups };
         }));
         if (Exit6.isFailure(exit)) {
           failed.push({ filePath, message: Cause5.pretty(exit.cause) });
         } else {
           indexed += exit.value.units;
+          updated += exit.value.upd;
           skipped += exit.value.dups;
         }
       }
-      const edgeEffect = (edge) => {
-        const from = unitIds.get(edge.from);
-        const to = unitIds.get(edge.to);
+      const vanished = yield* core().store.reconcile(namespace ?? "default", keyPrefix, walk.root, walk.roots, [...unitIds.keys()]);
+      reconciled = vanished.length;
+      yield* core().store.reconcileRenameCandidates(vanished, freshIds);
+      const resolveKey = (key) => {
+        const fromMap = unitIds.get(key);
+        if (fromMap !== undefined)
+          return Effect49.succeed(fromMap);
+        return core().store.getByKey(key, namespace ?? "default").pipe(Effect49.map((m) => m.id), Effect49.catchTag("Store.NotFound", () => Effect49.succeed(undefined)));
+      };
+      const edgeEffect = (edge) => Effect49.gen(function* () {
+        const [from, to] = yield* Effect49.all([resolveKey(edge.from), resolveKey(edge.to)]);
         if (from === undefined || to === undefined || from === to)
-          return Effect49.void;
-        return core.store.addEdge({
+          return;
+        yield* Effect49.exit(core().store.addEdge({
           fromMemoryId: from,
           toMemoryId: to,
-          edgeKind: "memory_supports",
+          edgeKind: edge.edgeKind,
           source: "rule",
           confidence: 1,
           confirmed: true
-        });
-      };
+        }));
+      });
       for (const edge of pendingEdges) {
-        yield* Effect49.exit(edgeEffect(edge));
+        yield* Effect49.exit(edgeEffect({ ...edge, edgeKind: "memory_supports" }));
+      }
+      for (const edge of pendingCallEdges) {
+        yield* Effect49.exit(edgeEffect({ ...edge, edgeKind: "code_calls" }));
       }
       return {
         files: walk.files.length,
         indexed,
+        updated,
+        reconciled,
         skipped,
         unsupported: walk.unsupported,
+        commit,
         failed
       };
     })),
@@ -8401,57 +8993,232 @@ var makeFacade = (runtime, core, parser, extractor, dispose) => {
           message: "updateEmbedding: embedding must be a non-empty array of finite numbers"
         });
       }
-      const key = modelKey ?? core.defaultModel.id;
-      yield* core.store.ensureTopicTree(key);
-      yield* core.store.updateEmbedding(id, [...embedding], key);
+      const key = modelKey ?? core().defaultModel.id;
+      const memory = yield* resolveMemory(id);
+      yield* core().store.ensureTopicTree(key);
+      yield* core().store.updateEmbedding(memory.id, [...embedding], key);
     })),
-    embed: (text4) => run(core.defaultEmbedder.embedSingle(text4).pipe(Effect49.map((vector) => [...vector]))),
-    dream: (modelKey) => run(core.runtime.enqueue(MemoryDream, { modelKey, runId: crypto.randomUUID() }).pipe(Effect49.flatMap((jobId) => core.runtime.wait(jobId)), Effect49.asVoid)),
-    repair: (modelKey) => run(core.runtime.enqueue(GraphRepair, { modelKey, runId: crypto.randomUUID() }).pipe(Effect49.flatMap((jobId) => core.runtime.wait(jobId)), Effect49.asVoid)),
-    explain: (input) => run(core.store.explain(input)),
-    health: (modelKey) => run(core.store.topicHealth(modelKey)),
+    embed: (text4) => run(core().defaultEmbedder.embedSingle(text4).pipe(Effect49.map((vector) => [...vector]))),
+    dream: (modelKey) => run(core().runtime.enqueue(MemoryDream, { modelKey, runId: crypto.randomUUID() }).pipe(Effect49.flatMap((jobId) => core().runtime.wait(jobId)), Effect49.asVoid)),
+    dbSchema: () => run(core().store.listSchema()),
+    repair: (modelKey) => run(core().runtime.enqueue(GraphRepair, { modelKey, runId: crypto.randomUUID() }).pipe(Effect49.flatMap((jobId) => core().runtime.wait(jobId)), Effect49.asVoid)),
+    explain: (input, options) => run(core().store.explain(input, {
+      ...options?.edgeKinds !== undefined ? { edgeKinds: options.edgeKinds } : {},
+      ...options?.maxDepth !== undefined ? { maxDepth: options.maxDepth } : {},
+      ...options?.maxNeighbors !== undefined ? { maxNeighbors: options.maxNeighbors } : {},
+      ...options?.maxTotal !== undefined ? { maxTotal: options.maxTotal } : {},
+      ...options?.includePending !== undefined ? { includePending: options.includePending } : {}
+    })),
+    health: (modelKey) => run(core().store.topicHealth(modelKey)),
     graph: {
       addEdge: (input) => run(Effect49.gen(function* () {
         const invalid = validateAddEdgeInput(input);
         if (invalid !== undefined)
           return yield* invalid;
-        return yield* core.store.addEdge(input);
+        return yield* core().store.addEdge(input);
       })),
-      candidates: () => run(core.store.graphCandidates()),
-      coverage: (modelKey) => run(core.store.graphCoverage(modelKey))
+      candidates: () => run(core().store.graphCandidates()),
+      coverage: (modelKey) => run(core().store.graphCoverage(modelKey)),
+      confirm: (id) => run(core().store.confirmEdge(id)),
+      reject: (id) => run(core().store.rejectEdge(id)),
+      expire: (id) => run(core().store.expireEdge(id))
     },
-    dispose: () => dispose().finally(() => {
-      disposed = true;
-    })
+    reload: (input) => reload(input),
+    dispose: () => dispose()
   };
 };
 
 // src/make.ts
-var makeDimple = async (options) => {
+var stableKey = (value2) => {
+  if (Array.isArray(value2))
+    return `[${value2.map(stableKey).join(",")}]`;
+  if (value2 !== null && typeof value2 === "object") {
+    const entries = Object.entries(value2).filter(([, v]) => v !== undefined).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableKey(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(value2);
+};
+var diffConfig = (oldC, newC) => {
+  if (oldC === undefined)
+    return { storeUrl: true, jobsUrl: true, rest: true };
+  const oldJobsUrl = oldC.jobs?.dbUrl;
+  const newJobsUrl = newC.jobs?.dbUrl;
+  const restOld = { ...oldC, storeUrl: "", jobs: { ...oldC.jobs, dbUrl: "" } };
+  const restNew = { ...newC, storeUrl: "", jobs: { ...newC.jobs, dbUrl: "" } };
+  return {
+    storeUrl: oldC.storeUrl !== newC.storeUrl,
+    jobsUrl: oldJobsUrl !== newJobsUrl,
+    rest: stableKey(restOld) !== stableKey(restNew)
+  };
+};
+var RELOAD_DRAIN_MS = 30000;
+var bootStack = async (options) => {
   const scope = await Effect50.runPromise(Scope5.make());
   let runtime;
   try {
     const layer21 = ("core" in options ? layer13(options.core) : layerConfig7(options.migrationFolder !== undefined ? { migrationFolder: options.migrationFolder } : {}).pipe(Layer26.provide(configLayerFromInput(options.config)))).pipe(Layer26.provide(Layer26.succeed(Scope5.Scope, scope)));
     const appLayer = Layer26.mergeAll(layer21, layer20, layer14);
-    const rt = ManagedRuntime2.make(appLayer);
+    const rt = ManagedRuntime.make(appLayer);
     runtime = rt;
     const [core, parser, extractor] = await rt.runPromise(Effect50.all([Service, Service19, Service12]));
-    return makeFacade(rt, core, parser, extractor, () => Effect50.runPromise(Scope5.close(scope, Exit7.void).pipe(Effect50.andThen(rt.disposeEffect))));
+    return {
+      runPromise: (effect) => rt.runPromise(effect),
+      disposeEffect: rt.disposeEffect,
+      core,
+      parser,
+      extractor,
+      dispose: () => Effect50.runPromise(Scope5.close(scope, Exit7.void).pipe(Effect50.andThen(rt.disposeEffect)))
+    };
   } catch (cause) {
     await Effect50.runPromise(Scope5.close(scope, Exit7.void).pipe(Effect50.andThen(runtime?.disposeEffect ?? Effect50.void))).catch(() => {
       return;
     });
-    return Promise.reject(remapError(cause));
+    return Promise.reject(cause);
   }
 };
+var makeDimple = async (options) => {
+  const configSource = "config" in options ? options.config : undefined;
+  const migrationFolder = "config" in options ? options.migrationFolder : undefined;
+  let currentConfig;
+  if (configSource !== undefined) {
+    currentConfig = await Effect50.runPromise(resolveConfigInput(configSource)).catch((cause) => Promise.reject(remapError(cause)));
+  }
+  let current = await bootStack(configSource !== undefined && currentConfig !== undefined ? {
+    config: currentConfig,
+    ...migrationFolder !== undefined ? { migrationFolder } : {}
+  } : options).then((stack) => stack, (cause) => Promise.reject(remapError(cause)));
+  let disposed = false;
+  let gate = Promise.resolve();
+  let releaseGate;
+  let inflight = 0;
+  let drainWaiters = [];
+  let reloadChain = Promise.resolve();
+  const run = (effect) => {
+    if (disposed) {
+      return Promise.reject(new StoreFailure({ message: "SDK disposed" }));
+    }
+    return gate.then(() => {
+      if (disposed) {
+        return Promise.reject(new StoreFailure({ message: "SDK disposed" }));
+      }
+      const stack = current;
+      inflight += 1;
+      return stack.runPromise(effect.pipe(Effect50.mapError(remapError))).catch((cause) => {
+        return Promise.reject(remapError(cause));
+      }).finally(() => {
+        inflight -= 1;
+        if (inflight === 0 && drainWaiters.length > 0) {
+          const waiters = drainWaiters;
+          drainWaiters = [];
+          for (const wake of waiters)
+            wake();
+        }
+      });
+    });
+  };
+  const pause = () => {
+    gate = new Promise((resolve2) => {
+      releaseGate = resolve2;
+    });
+  };
+  const resume = () => {
+    const release = releaseGate;
+    releaseGate = undefined;
+    gate = Promise.resolve();
+    release?.();
+  };
+  const drain = () => {
+    if (inflight === 0)
+      return Promise.resolve();
+    return new Promise((resolve2) => {
+      drainWaiters.push(resolve2);
+    });
+  };
+  const drainWithTimeout = () => new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      reject(new ReloadError({
+        message: `reload: drain timeout after ${RELOAD_DRAIN_MS}ms — in-flight calls still running`
+      }));
+    }, RELOAD_DRAIN_MS);
+    drain().then(() => {
+      clearTimeout(timer);
+      resolve2();
+    }, (cause) => {
+      clearTimeout(timer);
+      reject(cause);
+    });
+  });
+  const reload = (input) => {
+    const task = reloadChain.then(async () => {
+      if (disposed) {
+        return Promise.reject(new ReloadError({ message: "SDK disposed — reload unavailable" }));
+      }
+      if (configSource === undefined) {
+        return Promise.reject(new ReloadError({
+          message: "reload: no config source — this dimple was built from `core` options"
+        }));
+      }
+      const nextInput = input ?? configSource;
+      const resolved = await Effect50.runPromise(resolveConfigInput(nextInput));
+      if (currentConfig !== undefined && stableKey(resolved) === stableKey(currentConfig)) {
+        return {
+          config: resolved,
+          changed: { storeUrl: false, jobsUrl: false, rest: false },
+          reloaded: false
+        };
+      }
+      const changes = diffConfig(currentConfig, resolved);
+      pause();
+      try {
+        const next = await bootStack({
+          config: resolved,
+          ...migrationFolder !== undefined ? { migrationFolder } : {}
+        });
+        await drainWithTimeout();
+        const oldStoreUrl = currentConfig?.storeUrl;
+        const oldJobsUrl = currentConfig?.jobs?.dbUrl;
+        const old = current;
+        current = next;
+        currentConfig = resolved;
+        await old.dispose();
+        if (changes.storeUrl) {
+          await Effect50.runPromise(Effect50.logWarning(`reload: store database switched "${oldStoreUrl}" → "${resolved.storeUrl}" — ` + "the old db is preserved but no longer served (nothing was migrated)").pipe(Effect50.annotateLogs({ scope: "@dimple/sdk", event: "reload.store.switch" })));
+        }
+        if (changes.jobsUrl) {
+          await Effect50.runPromise(Effect50.logWarning(`reload: jobs database switched "${oldJobsUrl}" → "${resolved.jobs?.dbUrl}" — ` + "pending jobs remain durable in the old db").pipe(Effect50.annotateLogs({ scope: "@dimple/sdk", event: "reload.jobs.switch" })));
+        }
+        return { config: resolved, changed: changes, reloaded: true };
+      } finally {
+        resume();
+      }
+    });
+    reloadChain = task.catch(() => {
+      return;
+    });
+    return task.then((config) => config, (cause) => Promise.reject(remapError(cause)));
+  };
+  const dispose = () => {
+    disposed = true;
+    return reloadChain.then(() => current.dispose());
+  };
+  return makeFacade({
+    run,
+    core: () => current.core,
+    parser: () => current.parser,
+    extractor: () => current.extractor
+  }, reload, dispose);
+};
 export {
   remapError,
   makeDimple,
   StoreFailure,
+  ReloadError,
   NotFoundError,
   LLMNotConfiguredError,
   JobFailedError,
   InputError,
+  EmbeddingFailure,
+  EdgeNotFoundError,
   DuplicateKeyError,
   DuplicateEdgeError,
   ConfigError