@sesamespace/hivemind 0.5.12 → 0.5.13

package/dist/{chunk-LB6MG36X.js → chunk-MKE2NVOC.js}

@@ -1,6 +1,785 @@
 import {
   SesameClient
 } from "./chunk-GPI4RU7N.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-7D4SUZUM.js";
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js
+var require_util = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js"(exports) {
+    "use strict";
+    exports.getBooleanOption = (options, key) => {
+      let value = false;
+      if (key in options && typeof (value = options[key]) !== "boolean") {
+        throw new TypeError(`Expected the "${key}" option to be a boolean`);
+      }
+      return value;
+    };
+    exports.cppdb = /* @__PURE__ */ Symbol();
+    exports.inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/sqlite-error.js"(exports, module) {
+    "use strict";
+    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+    function SqliteError(message, code) {
+      if (new.target !== SqliteError) {
+        return new SqliteError(message, code);
+      }
+      if (typeof code !== "string") {
+        throw new TypeError("Expected second argument to be a string");
+      }
+      Error.call(this, message);
+      descriptor.value = "" + message;
+      Object.defineProperty(this, "message", descriptor);
+      Error.captureStackTrace(this, SqliteError);
+      this.code = code;
+    }
+    Object.setPrototypeOf(SqliteError, Error);
+    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+    Object.defineProperty(SqliteError.prototype, "name", descriptor);
+    module.exports = SqliteError;
+  }
+});
+
+// node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS({
+  "node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js"(exports, module) {
+    "use strict";
+    var sep = __require("path").sep || "/";
+    module.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        throw new TypeError("must pass in a file:// URI to convert to a file path");
+      }
+      var rest = decodeURI(uri.substring(7));
+      var firstSlash = rest.indexOf("/");
+      var host = rest.substring(0, firstSlash);
+      var path = rest.substring(firstSlash + 1);
+      if ("localhost" == host) host = "";
+      if (host) {
+        host = sep + sep + host;
+      }
+      path = path.replace(/^(.+)\|/, "$1:");
+      if (sep == "\\") {
+        path = path.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path)) {
+      } else {
+        path = sep + path;
+      }
+      return host + path;
+    }
+  }
+});
+
+// node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js
+var require_bindings = __commonJS({
+  "node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var fileURLToPath4 = require_file_uri_to_path();
+    var join = path.join;
+    var dirname6 = path.dirname;
+    var exists = fs.accessSync && function(path2) {
+      try {
+        fs.accessSync(path2);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    } || fs.existsSync || path.existsSync;
+    var defaults = {
+      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
+      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+      platform: process.platform,
+      arch: process.arch,
+      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+      version: process.versions.node,
+      bindings: "bindings.node",
+      try: [
+        // node-gyp's linked version in the "build" dir
+        ["module_root", "build", "bindings"],
+        // node-waf and gyp_addon (a.k.a node-gyp)
+        ["module_root", "build", "Debug", "bindings"],
+        ["module_root", "build", "Release", "bindings"],
+        // Debug files, for development (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Debug", "bindings"],
+        ["module_root", "Debug", "bindings"],
+        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Release", "bindings"],
+        ["module_root", "Release", "bindings"],
+        // Legacy from node-waf, node <= 0.4.x
+        ["module_root", "build", "default", "bindings"],
+        // Production "Release" buildtype binary (meh...)
+        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+        // node-qbs builds
+        ["module_root", "addon-build", "release", "install-root", "bindings"],
+        ["module_root", "addon-build", "debug", "install-root", "bindings"],
+        ["module_root", "addon-build", "default", "install-root", "bindings"],
+        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+      ]
+    };
+    function bindings(opts) {
+      if (typeof opts == "string") {
+        opts = { bindings: opts };
+      } else if (!opts) {
+        opts = {};
+      }
+      Object.keys(defaults).map(function(i2) {
+        if (!(i2 in opts)) opts[i2] = defaults[i2];
+      });
+      if (!opts.module_root) {
+        opts.module_root = exports.getRoot(exports.getFileName());
+      }
+      if (path.extname(opts.bindings) != ".node") {
+        opts.bindings += ".node";
+      }
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+      var tries = [], i = 0, l = opts.try.length, n, b, err;
+      for (; i < l; i++) {
+        n = join.apply(
+          null,
+          opts.try[i].map(function(p) {
+            return opts[p] || p;
+          })
+        );
+        tries.push(n);
+        try {
+          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+          if (!opts.path) {
+            b.path = n;
+          }
+          return b;
+        } catch (e) {
+          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
+            throw e;
+          }
+        }
+      }
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+          return opts.arrow + a;
+        }).join("\n")
+      );
+      err.tries = tries;
+      throw err;
+    }
+    module.exports = exports = bindings;
+    exports.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(e, st) {
+        for (var i = 0, l = st.length; i < l; i++) {
+          fileName = st[i].getFileName();
+          if (fileName !== __filename) {
+            if (calling_file) {
+              if (fileName !== calling_file) {
+                return;
+              }
+            } else {
+              return;
+            }
+          }
+        }
+      };
+      Error.captureStackTrace(dummy);
+      dummy.stack;
+      Error.prepareStackTrace = origPST;
+      Error.stackTraceLimit = origSTL;
+      var fileSchema = "file://";
+      if (fileName.indexOf(fileSchema) === 0) {
+        fileName = fileURLToPath4(fileName);
+      }
+      return fileName;
+    };
+    exports.getRoot = function getRoot(file) {
+      var dir = dirname6(file), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists(join(dir, "package.json")) || exists(join(dir, "node_modules"))) {
+          return dir;
+        }
+        if (prev === dir) {
+          throw new Error(
+            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
+          );
+        }
+        prev = dir;
+        dir = join(dir, "..");
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/wrappers.js"(exports) {
+    "use strict";
+    var { cppdb } = require_util();
+    exports.prepare = function prepare(sql) {
+      return this[cppdb].prepare(sql, this, false);
+    };
+    exports.exec = function exec(sql) {
+      this[cppdb].exec(sql);
+      return this;
+    };
+    exports.close = function close() {
+      this[cppdb].close();
+      return this;
+    };
+    exports.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
+    };
+    exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      return this;
+    };
+    exports.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
+    };
+    exports.getters = {
+      name: {
+        get: function name() {
+          return this[cppdb].name;
+        },
+        enumerable: true
+      },
+      open: {
+        get: function open() {
+          return this[cppdb].open;
+        },
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
+        },
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/transaction.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module.exports = function transaction(fn) {
+      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+      const db = this[cppdb];
+      const controller = getController(db, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    };
+    var getController = (db, self) => {
+      let controller = controllers.get(db);
+      if (!controller) {
+        const shared = {
+          commit: db.prepare("COMMIT", self, false),
+          rollback: db.prepare("ROLLBACK", self, false),
+          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db, controller = {
+          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
+      }
+      before.run();
+      try {
+        const result = apply.call(fn, this, arguments);
+        if (result && typeof result.then === "function") {
+          throw new TypeError("Transaction function cannot return a promise");
+        }
+        after.run();
+        return result;
+      } catch (ex) {
+        if (db.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/pragma.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function pragma(source, options) {
+      if (options == null) options = {};
+      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      const simple = getBooleanOption(options, "simple");
+      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var { promisify } = __require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify(fs.access);
+    module.exports = async function backup(filename, options) {
+      if (options == null) options = {};
+      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      filename = filename.trim();
+      const attachedName = "attached" in options ? options.attached : "main";
+      const handler = "progress" in options ? options.progress : null;
+      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
+      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
+      await fsAccess(path.dirname(filename)).catch(() => {
+        throw new TypeError("Cannot save backup because the directory does not exist");
+      });
+      const isNewFile = await fsAccess(filename).then(() => false, () => true);
+      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
+    };
+    var runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve6, reject) => {
+        setImmediate(function step() {
+          try {
+            const progress = backup.transfer(rate);
+            if (!progress.remainingPages) {
+              backup.close();
+              resolve6(progress);
+              return;
+            }
+            if (useDefault) {
+              useDefault = false;
+              rate = 100;
+            }
+            if (handler) {
+              const ret = handler(progress);
+              if (ret !== void 0) {
+                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+                else throw new TypeError("Expected progress callback to return a number or undefined");
+              }
+            }
+            setImmediate(step);
+          } catch (err) {
+            backup.close();
+            reject(err);
+          }
+        });
+      });
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function serialize(options) {
+      if (options == null) options = {};
+      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
+      const attachedName = "attached" in options ? options.attached : "main";
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      return this[cppdb].serialize(attachedName);
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/function.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineFunction(name, options, fn) {
+      if (options == null) options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = fn.length;
+        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/aggregate.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineAggregate(name, options) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const start = "start" in options ? options.start : null;
+      const step = getFunctionOption(options, "step", true);
+      const inverse = getFunctionOption(options, "inverse", false);
+      const result = getFunctionOption(options, "result", false);
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+        if (argCount > 0) argCount -= 1;
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, required) => {
+      const value = key in options ? options[key] : null;
+      if (typeof value === "function") return value;
+      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+      if (required) throw new TypeError(`Missing required option "${key}"`);
+      return null;
+    };
+    var getLength = ({ length }) => {
+      if (Number.isInteger(length) && length >= 0) return length;
+      throw new TypeError("Expected function.length to be a positive integer");
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/table.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function defineTable(name, factory) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
+      let eponymous = false;
+      if (typeof factory === "object" && factory !== null) {
+        eponymous = true;
+        factory = defer(parseTableDefinition(factory, "used", name));
+      } else {
+        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
+        factory = wrapFactory(factory);
+      }
+      this[cppdb].table(factory, name, eponymous);
+      return this;
+    };
+    function wrapFactory(factory) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.call(factory, thisObject, args);
+        if (typeof def !== "object" || def === null) {
+          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+        }
+        return parseTableDefinition(def, "returned", moduleName);
+      };
+    }
+    function parseTableDefinition(def, verb, moduleName) {
+      if (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+      }
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+      }
+      const rows = def.rows;
+      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+      }
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+      }
+      if (columns.length !== new Set(columns).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+      }
+      if (!columns.length) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+      }
+      let parameters;
+      if (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+        }
+      } else {
+        parameters = inferParameters(rows);
+      }
+      if (parameters.length !== new Set(parameters).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+      }
+      if (parameters.length > 32) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+      }
+      for (const parameter of parameters) {
+        if (columns.includes(parameter)) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+        }
+      }
+      let safeIntegers = 2;
+      if (hasOwnProperty.call(def, "safeIntegers")) {
+        const bool = def.safeIntegers;
+        if (typeof bool !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+        }
+        safeIntegers = +bool;
+      }
+      let directOnly = false;
+      if (hasOwnProperty.call(def, "directOnly")) {
+        directOnly = def.directOnly;
+        if (typeof directOnly !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+        }
+      }
+      const columnDefinitions = [
+        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
+        ...columns.map(identifier)
+      ];
+      return [
+        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+        wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
+    }
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+        for (let i = 0; i < columnMap.size; ++i) {
+          output.push(null);
+        }
+        for (const row of generator(...args)) {
+          if (Array.isArray(row)) {
+            extractRowArray(row, output, columnMap.size, moduleName);
+            yield output;
+          } else if (typeof row === "object" && row !== null) {
+            extractRowObject(row, output, columnMap, moduleName);
+            yield output;
+          } else {
+            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+          }
+        }
+      };
+    }
+    function extractRowArray(row, output, columnCount, moduleName) {
+      if (row.length !== columnCount) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+      }
+      const offset = output.length - columnCount;
+      for (let i = 0; i < columnCount; ++i) {
+        output[i + offset] = row[i];
+      }
+    }
+    function extractRowObject(row, output, columnMap, moduleName) {
+      let count = 0;
+      for (const key of Object.keys(row)) {
+        const index = columnMap.get(key);
+        if (index === void 0) {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+        }
+        output[index] = row[key];
+        count += 1;
+      }
+      if (count !== columnMap.size) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+      }
+    }
+    function inferParameters({ length }) {
+      if (!Number.isInteger(length) || length < 0) {
+        throw new TypeError("Expected function.length to be a positive integer");
+      }
+      const params = [];
+      for (let i = 0; i < length; ++i) {
+        params.push(`$${i + 1}`);
+      }
+      return params;
+    }
+    var { hasOwnProperty } = Object.prototype;
+    var { apply } = Function.prototype;
+    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
+    });
+    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+    var defer = (x) => () => x;
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/inspect.js"(exports, module) {
+    "use strict";
+    var DatabaseInspection = function Database2() {
+    };
+    module.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/database.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database2(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database2(filenameGiven, options);
+      }
+      let buffer;
+      if (Buffer.isBuffer(filenameGiven)) {
+        buffer = filenameGiven;
+        filenameGiven = ":memory:";
+      }
+      if (filenameGiven == null) filenameGiven = "";
+      if (options == null) options = {};
+      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+      const filename = filenameGiven.trim();
+      const anonymous = filename === "" || filename === ":memory:";
+      const readonly = util.getBooleanOption(options, "readonly");
+      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
+      const timeout = "timeout" in options ? options.timeout : 5e3;
+      const verbose = "verbose" in options ? options.verbose : null;
+      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+      if (readonly && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
+      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
+      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
+      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+      let addon;
+      if (nativeBinding == null) {
+        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+      } else if (typeof nativeBinding === "string") {
+        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
+        addon = requireFunc(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
+      }
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
+      }
+      if (!anonymous && !fs.existsSync(path.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
+      }
+      Object.defineProperties(this, {
+        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
+        ...wrappers.getters
+      });
+    }
+    var wrappers = require_wrappers();
+    Database2.prototype.prepare = wrappers.prepare;
+    Database2.prototype.transaction = require_transaction();
+    Database2.prototype.pragma = require_pragma();
+    Database2.prototype.backup = require_backup();
+    Database2.prototype.serialize = require_serialize();
+    Database2.prototype.function = require_function();
+    Database2.prototype.aggregate = require_aggregate();
+    Database2.prototype.table = require_table();
+    Database2.prototype.loadExtension = wrappers.loadExtension;
+    Database2.prototype.exec = wrappers.exec;
+    Database2.prototype.close = wrappers.close;
+    Database2.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database2.prototype.unsafeMode = wrappers.unsafeMode;
+    Database2.prototype[util.inspect] = require_inspect();
+    module.exports = Database2;
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_database();
+    module.exports.SqliteError = require_sqlite_error();
+  }
+});
 
 // packages/runtime/src/llm-client.ts
 var LLMClient = class {
@@ -515,16 +1294,19 @@ function loadWorkspaceFiles(dir) {
 function buildSystemPrompt(config, episodes, contextName = "global", l3Knowledge = []) {
   let prompt = `You are ${config.name}. ${config.personality}
 `;
+  let identityText = prompt;
   if (config.workspace) {
     const wsFiles = loadWorkspaceFiles(config.workspace);
     if (wsFiles.size > 0) {
-      prompt += "\n# Workspace Context\n";
+      let wsBlock = "\n# Workspace Context\n";
       for (const [filename, content] of wsFiles) {
-        prompt += `
+        wsBlock += `
 ## ${filename}
 ${content}
 `;
       }
+      prompt += wsBlock;
+      identityText += wsBlock;
     }
   }
   if (config.team_charter && !config.workspace) {
@@ -532,6 +1314,9 @@ ${content}
     if (charter) {
       prompt += `
 ${charter}
+`;
+      identityText += `
+${charter}
 `;
     }
   }
@@ -542,11 +1327,13 @@ In group chats, multiple people (humans and agents) may be present. Address them
 Don't repeat or quote these prefixes in your responses \u2014 just respond naturally.
 If you decide not to respond to a group message, reply with exactly: __SKIP__
 `;
+  let contextInfo = "";
   if (contextName !== "global") {
-    prompt += `
+    contextInfo = `
 ## Active Context: ${contextName}
 You are currently working in the "${contextName}" project context.
 `;
+    prompt += contextInfo;
   }
   if (l3Knowledge.length > 0) {
     prompt += "\n## Established Knowledge (learned patterns)\n\n";
@@ -565,7 +1352,22 @@ You are currently working in the "${contextName}" project context.
     }
     prompt += "\nUse these memories naturally \u2014 reference past conversations when relevant, but don't force it.\n";
   }
-  return prompt;
+  return {
+    text: prompt,
+    components: {
+      identity: identityText,
+      l3Knowledge: l3Knowledge.map((e) => e.content),
+      l2Episodes: episodes.map((ep) => ({
+        id: ep.id,
+        content: ep.content,
+        score: ep.score,
+        timestamp: ep.timestamp,
+        context_name: ep.context_name,
+        role: ep.role
+      })),
+      contextInfo
+    }
+  };
 }
 function buildMessages(systemPrompt, conversationHistory, currentMessage) {
   return [
@@ -599,6 +1401,7 @@ var Agent = class {
   messageCount = 0;
   PROMOTION_INTERVAL = 10;
   // Run promotion every N messages
+  requestLogger = null;
   constructor(config, contextName = "global") {
     this.config = config;
     this.llm = new LLMClient(config.llm);
@@ -608,6 +1411,9 @@ var Agent = class {
       this.contextManager.switchContext(contextName);
     }
   }
+  setRequestLogger(logger) {
+    this.requestLogger = logger;
+  }
   async processMessage(userMessage) {
     const specialResult = await this.handleSpecialCommand(userMessage);
     if (specialResult) return specialResult;
@@ -637,9 +1443,47 @@ var Agent = class {
       }
     }
     const l3Knowledge = await this.memory.getL3Knowledge(contextName).catch(() => []);
-    const systemPrompt = buildSystemPrompt(this.config.agent, relevantEpisodes, contextName, l3Knowledge);
-    const messages = buildMessages(systemPrompt, conversationHistory, userMessage);
+    const systemPromptResult = buildSystemPrompt(this.config.agent, relevantEpisodes, contextName, l3Knowledge);
+    const messages = buildMessages(systemPromptResult.text, conversationHistory, userMessage);
+    const llmStart = Date.now();
     const response = await this.llm.chat(messages);
+    const latencyMs = Date.now() - llmStart;
+    if (this.requestLogger) {
+      try {
+        this.requestLogger.log({
+          context: contextName,
+          contextSwitched: routing.switched,
+          routingReason: routing.switched ? `switched:${contextName}` : `active:${contextName}`,
+          rawMessage: userMessage,
+          systemPromptComponents: {
+            identity: systemPromptResult.components.identity,
+            l3Knowledge: systemPromptResult.components.l3Knowledge,
+            l2Episodes: systemPromptResult.components.l2Episodes,
+            contextInfo: systemPromptResult.components.contextInfo,
+            fullText: systemPromptResult.text
+          },
+          conversationHistory: conversationHistory.map((m) => ({
+            role: m.role,
+            content: m.content
+          })),
+          userMessage,
+          response: {
+            content: response.content,
+            model: response.model,
+            latencyMs,
+            skipped: response.content.trim() === "__SKIP__"
+          },
+          config: {
+            topK: this.config.memory.top_k,
+            model: this.config.llm.model,
+            maxTokens: this.config.llm.max_tokens,
+            temperature: this.config.llm.temperature
+          }
+        });
+      } catch (err) {
+        console.error("[dashboard] Failed to log request:", err.message);
+      }
+    }
     conversationHistory.push(
       { role: "user", content: userMessage },
       { role: "assistant", content: response.content }
@@ -682,7 +1526,195 @@ var Agent = class {
   }
   async handleSpecialCommand(message) {
     const activeCtx = this.contextManager.getActiveContext();
-    const searchAllMatch = message.match(/^(?:search\s+all|cross-context\s+search)[:\s]+(.+)/i);
+    let stripped = message.replace(/^\[.+?\s+in\s+group\s+chat\]:\s*/, "");
+    stripped = stripped.replace(/^\[.+?\]:\s*/, "");
+    const cmdText = stripped;
+    if (/^\/status\b/i.test(cmdText)) {
+      const memoryOk = await this.memory.healthCheck();
+      const contexts = this.contextManager.listContexts();
+      let contextStats = "";
+      try {
+        const daemonContexts = await this.memory.listContexts();
+        contextStats = daemonContexts.map((c) => `  - ${c.name}: ${c.episode_count} episodes`).join("\n");
+      } catch {
+        contextStats = "  (unable to query memory daemon)";
+      }
+      const response = [
+        `## Agent Status`,
+        ``,
+        `**Name:** ${this.config.agent.name}`,
+        `**Active Context:** ${activeCtx}`,
+        `**Memory Daemon:** ${memoryOk ? "\u2705 connected" : "\u274C unreachable"} (${this.config.memory.daemon_url})`,
+        `**Model:** ${this.config.llm.model}`,
+        `**Temperature:** ${this.config.llm.temperature}`,
+        `**Max Tokens:** ${this.config.llm.max_tokens}`,
+        `**Memory Top-K:** ${this.config.memory.top_k}`,
+        `**Messages Processed:** ${this.messageCount}`,
+        `**L1 Contexts in Memory:** ${this.conversationHistories.size}`,
+        ``,
+        `### Contexts`,
+        contextStats
+      ].join("\n");
+      return { content: response, model: "system", context: activeCtx };
+    }
+    if (/^\/memory\s+stats\b/i.test(cmdText)) {
+      try {
+        const contexts = await this.memory.listContexts();
+        let totalEpisodes = 0;
+        let totalL3 = 0;
+        let lines = [];
+        for (const ctx of contexts) {
+          totalEpisodes += ctx.episode_count;
+          let l3Count = 0;
+          try {
+            const l3 = await this.memory.getL3Knowledge(ctx.name);
+            l3Count = l3.length;
+            totalL3 += l3Count;
+          } catch {
+          }
+          lines.push(`  - **${ctx.name}**: ${ctx.episode_count} L2 episodes, ${l3Count} L3 entries`);
+        }
+        const response = [
+          `## Memory Stats`,
+          ``,
+          `**Total L2 Episodes:** ${totalEpisodes}`,
+          `**Total L3 Knowledge:** ${totalL3}`,
+          `**Contexts:** ${contexts.length}`,
+          ``,
+          `### Per Context`,
+          ...lines
+        ].join("\n");
+        return { content: response, model: "system", context: activeCtx };
+      } catch (err) {
+        return { content: `Memory stats failed: ${err.message}`, model: "system", context: activeCtx };
+      }
+    }
+    const memSearchMatch = cmdText.match(/^\/memory\s+search\s+(.+)/i);
+    if (memSearchMatch) {
+      const query = memSearchMatch[1].trim();
+      try {
+        const results = await this.memory.search(query, activeCtx, this.config.memory.top_k);
+        if (results.length === 0) {
+          return { content: `No memories found for "${query}" in context "${activeCtx}".`, model: "system", context: activeCtx };
+        }
+        let response = `## Memory Search: "${query}"
+
+`;
+        for (const ep of results) {
+          const ctxLabel = ep.context_name !== activeCtx ? ` [from: ${ep.context_name}]` : "";
+          response += `- **[${ep.role}]** (score: ${ep.score.toFixed(3)})${ctxLabel} ${ep.content.slice(0, 300)}${ep.content.length > 300 ? "..." : ""}
+`;
+        }
+        return { content: response, model: "system", context: activeCtx };
+      } catch (err) {
+        return { content: `Memory search failed: ${err.message}`, model: "system", context: activeCtx };
+      }
+    }
+    const l3Match = cmdText.match(/^\/memory\s+l3(?:\s+(\S+))?/i);
+    if (l3Match) {
+      const targetCtx = l3Match[1] || activeCtx;
+      try {
+        const entries = await this.memory.getL3Knowledge(targetCtx);
+        if (entries.length === 0) {
+          return { content: `No L3 knowledge in context "${targetCtx}".`, model: "system", context: activeCtx };
+        }
+        let response = `## L3 Knowledge: ${targetCtx}
+
+`;
+        for (const entry of entries) {
+          response += `- **[${entry.id.slice(0, 8)}]** (density: ${entry.connection_density}, accesses: ${entry.access_count})
+  ${entry.content}
+`;
+        }
+        return { content: response, model: "system", context: activeCtx };
+      } catch (err) {
+        return { content: `L3 query failed: ${err.message}`, model: "system", context: activeCtx };
+      }
+    }
+    if (/^\/config\b/i.test(cmdText)) {
+      const response = [
+        `## Configuration`,
+        ``,
+        `**Agent:** ${this.config.agent.name}`,
+        `**Personality:** ${this.config.agent.personality}`,
+        `**Workspace:** ${this.config.agent.workspace || "(none)"}`,
+        ``,
+        `### LLM`,
+        `- Model: ${this.config.llm.model}`,
+        `- Base URL: ${this.config.llm.base_url}`,
+        `- Max Tokens: ${this.config.llm.max_tokens}`,
+        `- Temperature: ${this.config.llm.temperature}`,
+        ``,
+        `### Memory`,
+        `- Daemon URL: ${this.config.memory.daemon_url}`,
+        `- Top-K: ${this.config.memory.top_k}`,
+        `- Embedding Model: ${this.config.memory.embedding_model}`,
+        ``,
+        `### Sesame`,
+        `- API: ${this.config.sesame.api_url}`,
+        `- WebSocket: ${this.config.sesame.ws_url}`,
+        `- API Key: ${this.config.sesame.api_key ? "***" + this.config.sesame.api_key.slice(-4) : "(not set)"}`
+      ].join("\n");
+      return { content: response, model: "system", context: activeCtx };
+    }
+    if (/^\/contexts\b/i.test(cmdText)) {
+      const localContexts = this.contextManager.listContexts();
+      let daemonInfo = "";
+      try {
+        const daemonContexts = await this.memory.listContexts();
+        daemonInfo = "\n### Memory Daemon Contexts\n" + daemonContexts.map(
+          (c) => `  - **${c.name}**: ${c.episode_count} episodes (created: ${c.created_at})`
+        ).join("\n");
+      } catch {
+        daemonInfo = "\n(Memory daemon unreachable)";
+      }
+      const localInfo = localContexts.map((c) => {
+        const active = c.name === activeCtx ? " \u2190 active" : "";
+        const historyLen = this.conversationHistories.get(c.name)?.length || 0;
+        return `  - **${c.name}**${active}: ${historyLen / 2} turns in L1`;
+      }).join("\n");
+      const response = [
+        `## Contexts`,
+        ``,
+        `**Active:** ${activeCtx}`,
+        ``,
+        `### Local (L1 Working Memory)`,
+        localInfo,
+        daemonInfo
+      ].join("\n");
+      return { content: response, model: "system", context: activeCtx };
+    }
+    if (/^\/help\b/i.test(cmdText)) {
+      const response = [
+        `## Available Commands`,
+        ``,
+        `### Introspection`,
+        `- \`/status\` \u2014 Agent health, memory status, config summary`,
+        `- \`/config\` \u2014 Full configuration details`,
+        `- \`/contexts\` \u2014 List all contexts with L1/L2 info`,
+        `- \`/memory stats\` \u2014 Episode counts, L3 entries per context`,
+        `- \`/memory search <query>\` \u2014 Search L2 memories with scores`,
+        `- \`/memory l3 [context]\` \u2014 Show L3 knowledge entries`,
+        ``,
+        `### Context Management`,
+        `- \`switch to <name>\` \u2014 Switch active context`,
+        `- \`create context <name>\` \u2014 Create a new context`,
+        `- \`list contexts\` \u2014 List contexts (legacy)`,
+        ``,
+        `### Memory`,
+        `- \`search all: <query>\` \u2014 Cross-context search`,
+        `- \`share <episode_id> with <context>\` \u2014 Share episode across contexts`,
+        ``,
+        `### Tasks`,
+        `- \`task add <title>\` \u2014 Create a task`,
+        `- \`task list [status]\` \u2014 List tasks`,
+        `- \`task start <id>\` \u2014 Start a task`,
+        `- \`task complete <id>\` \u2014 Complete a task`,
+        `- \`task next\` \u2014 Pick up next available task`
+      ].join("\n");
+      return { content: response, model: "system", context: activeCtx };
+    }
+    const searchAllMatch = cmdText.match(/^(?:search\s+all|cross-context\s+search)[:\s]+(.+)/i);
     if (searchAllMatch) {
       const query = searchAllMatch[1].trim();
       try {
@@ -706,7 +1738,7 @@ var Agent = class {
         return { content: `Cross-context search failed: ${err.message}`, model: "system", context: activeCtx };
       }
     }
-    const shareMatch = message.match(/^share\s+(\S+)\s+with\s+(\S+)/i);
+    const shareMatch = cmdText.match(/^share\s+(\S+)\s+with\s+(\S+)/i);
     if (shareMatch) {
       const episodeId = shareMatch[1];
       const targetContext = shareMatch[2];
@@ -717,7 +1749,7 @@ var Agent = class {
         return { content: `Failed to share: ${err.message}`, model: "system", context: activeCtx };
       }
     }
-    const taskCmd = TaskEngine.parseTaskCommand(message);
+    const taskCmd = TaskEngine.parseTaskCommand(cmdText);
     if (taskCmd) {
       const engine = new TaskEngine({ contextName: activeCtx, memory: this.memory });
       try {
@@ -1574,8 +2606,8 @@ import { resolve as resolve3, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 var RUNTIME_VERSION = "unknown";
 try {
-  const __dirname = dirname2(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync3(resolve3(__dirname, "../package.json"), "utf-8"));
+  const __dirname2 = dirname2(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync3(resolve3(__dirname2, "../package.json"), "utf-8"));
   RUNTIME_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -1737,20 +2769,285 @@ var SesameClient2 = class {
 };
 
 // packages/runtime/src/pipeline.ts
-import { createServer } from "http";
+import { createServer as createServer2 } from "http";
 
 // packages/runtime/src/health.ts
 var HEALTH_PORT = 9484;
 var HEALTH_PATH = "/health";
 
-// packages/runtime/src/pipeline.ts
-import { readFileSync as readFileSync4, writeFileSync, unlinkSync } from "fs";
-import { resolve as resolve4, dirname as dirname3 } from "path";
+// packages/runtime/src/request-logger.ts
+var import_better_sqlite3 = __toESM(require_lib(), 1);
+import { randomUUID } from "crypto";
+import { mkdirSync, existsSync as existsSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+var RequestLogger = class {
+  db;
+  constructor(dbPath) {
+    const dir = dirname3(dbPath);
+    if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
+    this.db = new import_better_sqlite3.default(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.init();
+    this.prune();
+  }
+  init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS request_logs (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        context TEXT NOT NULL,
+        context_switched INTEGER NOT NULL DEFAULT 0,
+        routing_reason TEXT NOT NULL DEFAULT '',
+        channel_id TEXT NOT NULL DEFAULT '',
+        channel_kind TEXT NOT NULL DEFAULT '',
+        sender_handle TEXT NOT NULL DEFAULT '',
+        raw_message TEXT NOT NULL,
+        system_prompt_components TEXT NOT NULL,
+        conversation_history TEXT NOT NULL,
+        user_message TEXT NOT NULL,
+        response_content TEXT NOT NULL,
+        response_model TEXT NOT NULL,
+        response_latency_ms INTEGER NOT NULL,
+        response_skipped INTEGER NOT NULL DEFAULT 0,
+        config_snapshot TEXT NOT NULL,
+        token_est_system INTEGER NOT NULL DEFAULT 0,
+        token_est_history INTEGER NOT NULL DEFAULT 0,
+        token_est_user INTEGER NOT NULL DEFAULT 0,
+        token_est_total INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_request_logs_timestamp ON request_logs(timestamp DESC);
+      CREATE INDEX IF NOT EXISTS idx_request_logs_context ON request_logs(context);
+      CREATE INDEX IF NOT EXISTS idx_request_logs_sender ON request_logs(sender_handle);
+    `);
+  }
+  prune() {
+    const cutoff = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString();
+    const result = this.db.prepare("DELETE FROM request_logs WHERE timestamp < ?").run(cutoff);
+    if (result.changes > 0) {
+      console.log(`[dashboard] Pruned ${result.changes} old request logs`);
+    }
+  }
+  log(entry) {
+    const id = randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const sysTokens = Math.ceil(entry.systemPromptComponents.fullText.length / 4);
+    const histTokens = Math.ceil(
+      entry.conversationHistory.reduce((sum, m) => sum + m.content.length, 0) / 4
+    );
+    const userTokens = Math.ceil(entry.userMessage.length / 4);
+    this.db.prepare(
+      `INSERT INTO request_logs (
+          id, timestamp, context, context_switched, routing_reason,
+          channel_id, channel_kind, sender_handle, raw_message,
+          system_prompt_components, conversation_history, user_message,
+          response_content, response_model, response_latency_ms, response_skipped,
+          config_snapshot,
+          token_est_system, token_est_history, token_est_user, token_est_total
+        ) VALUES (
+          ?, ?, ?, ?, ?,
+          ?, ?, ?, ?,
+          ?, ?, ?,
+          ?, ?, ?, ?,
+          ?,
+          ?, ?, ?, ?
+        )`
+    ).run(
+      id,
+      timestamp,
+      entry.context,
+      entry.contextSwitched ? 1 : 0,
+      entry.routingReason,
+      entry.channelId ?? "",
+      entry.channelKind ?? "",
+      entry.senderHandle ?? "",
+      entry.rawMessage,
+      JSON.stringify(entry.systemPromptComponents),
+      JSON.stringify(entry.conversationHistory),
+      entry.userMessage,
+      entry.response.content,
+      entry.response.model,
+      entry.response.latencyMs,
+      entry.response.skipped ? 1 : 0,
+      JSON.stringify(entry.config),
+      sysTokens,
+      histTokens,
+      userTokens,
+      sysTokens + histTokens + userTokens
+    );
+    return id;
+  }
+  getRequests(opts = {}) {
+    const limit = opts.limit ?? 50;
+    const offset = opts.offset ?? 0;
+    const conditions = [];
+    const params = [];
+    if (opts.context) {
+      conditions.push("context = ?");
+      params.push(opts.context);
+    }
+    if (opts.sender) {
+      conditions.push("sender_handle = ?");
+      params.push(opts.sender);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const total = this.db.prepare(`SELECT COUNT(*) as count FROM request_logs ${where}`).get(...params).count;
+    const requests = this.db.prepare(
+      `SELECT * FROM request_logs ${where} ORDER BY timestamp DESC LIMIT ? OFFSET ?`
+    ).all(...params, limit, offset);
+    return { requests, total };
+  }
+  getRequest(id) {
+    return this.db.prepare("SELECT * FROM request_logs WHERE id = ?").get(id);
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// packages/runtime/src/dashboard.ts
+import { createServer } from "http";
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve4, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname = dirname4(fileURLToPath2(import.meta.url));
+var DASHBOARD_PORT = 9485;
+var spaHtml = null;
+function getSpaHtml() {
+  if (!spaHtml) {
+    for (const dir of [__dirname, resolve4(__dirname, "../src")]) {
+      try {
+        spaHtml = readFileSync4(resolve4(dir, "dashboard.html"), "utf-8");
+        break;
+      } catch {
+      }
+    }
+    if (!spaHtml) spaHtml = "<h1>Dashboard HTML not found</h1>";
+  }
+  return spaHtml;
+}
+function json(res, data, status = 200) {
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.end(JSON.stringify(data));
+}
+function parseQuery(url) {
+  const idx = url.indexOf("?");
+  if (idx === -1) return {};
+  const params = {};
+  for (const pair of url.slice(idx + 1).split("&")) {
+    const [k, v] = pair.split("=");
+    if (k) params[decodeURIComponent(k)] = decodeURIComponent(v ?? "");
+  }
+  return params;
+}
+async function proxyMemory(memoryUrl, path, method, res) {
+  try {
+    const resp = await fetch(`${memoryUrl}${path}`, { method });
+    const body = await resp.text();
+    res.writeHead(resp.status, {
+      "Content-Type": resp.headers.get("content-type") ?? "application/json",
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.end(body);
+  } catch (err) {
+    json(res, { error: err.message }, 502);
+  }
+}
+function startDashboardServer(requestLogger, memoryConfig) {
+  const memoryUrl = memoryConfig.daemon_url;
+  const server = createServer(async (req, res) => {
+    const method = req.method ?? "GET";
+    const rawUrl = req.url ?? "/";
+    const urlPath = rawUrl.split("?")[0];
+    if (method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type"
+      });
+      res.end();
+      return;
+    }
+    try {
+      if (method === "GET" && urlPath === "/") {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(getSpaHtml());
+        return;
+      }
+      if (method === "GET" && urlPath === "/api/requests") {
+        const q = parseQuery(rawUrl);
+        const result = requestLogger.getRequests({
+          limit: q.limit ? parseInt(q.limit, 10) : void 0,
+          offset: q.offset ? parseInt(q.offset, 10) : void 0,
+          context: q.context || void 0,
+          sender: q.sender || void 0
+        });
+        json(res, result);
+        return;
+      }
+      const reqDetailMatch = urlPath.match(/^\/api\/requests\/([^/]+)$/);
+      if (method === "GET" && reqDetailMatch) {
+        const entry = requestLogger.getRequest(reqDetailMatch[1]);
+        if (!entry) {
+          json(res, { error: "Not found" }, 404);
+        } else {
+          json(res, entry);
+        }
+        return;
+      }
+      if (method === "GET" && urlPath === "/api/contexts") {
+        await proxyMemory(memoryUrl, "/contexts", "GET", res);
+        return;
+      }
+      const episodesMatch = urlPath.match(/^\/api\/contexts\/([^/]+)\/episodes$/);
+      if (method === "GET" && episodesMatch) {
+        const name = decodeURIComponent(episodesMatch[1]);
+        await proxyMemory(memoryUrl, `/contexts/${encodeURIComponent(name)}`, "GET", res);
+        return;
+      }
+      const l3Match = urlPath.match(/^\/api\/contexts\/([^/]+)\/l3$/);
+      if (method === "GET" && l3Match) {
+        const name = decodeURIComponent(l3Match[1]);
+        await proxyMemory(
+          memoryUrl,
+          `/promotion/l3?context=${encodeURIComponent(name)}`,
+          "GET",
+          res
+        );
+        return;
+      }
+      const l3DeleteMatch = urlPath.match(/^\/api\/l3\/([^/]+)$/);
+      if (method === "DELETE" && l3DeleteMatch) {
+        const id = decodeURIComponent(l3DeleteMatch[1]);
+        await proxyMemory(memoryUrl, `/promotion/l3/${encodeURIComponent(id)}`, "DELETE", res);
+        return;
+      }
+      json(res, { error: "Not found" }, 404);
+    } catch (err) {
+      console.error("[dashboard] Request error:", err.message);
+      json(res, { error: "Internal server error" }, 500);
+    }
+  });
+  server.listen(DASHBOARD_PORT, "127.0.0.1", () => {
+    console.log(
+      `[hivemind] Dashboard listening on http://127.0.0.1:${DASHBOARD_PORT}`
+    );
+  });
+}
+
+// packages/runtime/src/pipeline.ts
+import { readFileSync as readFileSync5, writeFileSync, unlinkSync } from "fs";
+import { resolve as resolve5, dirname as dirname5 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var PACKAGE_VERSION = "unknown";
 try {
-  const __dirname = dirname3(fileURLToPath2(import.meta.url));
-  const pkg = JSON.parse(readFileSync4(resolve4(__dirname, "../package.json"), "utf-8"));
+  const __dirname2 = dirname5(fileURLToPath3(import.meta.url));
+  const pkg = JSON.parse(readFileSync5(resolve5(__dirname2, "../package.json"), "utf-8"));
   PACKAGE_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -1758,7 +3055,7 @@ var sesameConnected = false;
 var memoryConnected = false;
 var startTime = Date.now();
 function startHealthServer(port) {
-  const server = createServer((req, res) => {
+  const server = createServer2((req, res) => {
     if (req.method === "GET" && req.url === HEALTH_PATH) {
       const status = {
         status: sesameConnected ? "ok" : "degraded",
@@ -1812,7 +3109,10 @@ async function startPipeline(configPath) {
     memoryConnected = true;
     console.log("[hivemind] Memory daemon connected");
   }
+  const requestLogger = new RequestLogger(resolve5(dirname5(configPath), "data", "dashboard.db"));
+  startDashboardServer(requestLogger, config.memory);
   const agent = new Agent(config);
+  agent.setRequestLogger(requestLogger);
   console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
   if (config.sesame.api_key) {
     await startSesameLoop(config, agent);
@@ -1927,13 +3227,13 @@ ${response.content}
       console.error("Error:", err.message);
     }
   });
-  return new Promise((resolve5) => {
-    rl.on("close", resolve5);
+  return new Promise((resolve6) => {
+    rl.on("close", resolve6);
   });
 }
 
 // packages/runtime/src/fleet/worker-server.ts
-import { createServer as createServer2 } from "http";
+import { createServer as createServer3 } from "http";
 var WorkerServer = class {
   server = null;
   workerId;
@@ -1957,20 +3257,20 @@ var WorkerServer = class {
   }
   /** Start listening. */
   async start() {
-    return new Promise((resolve5, reject) => {
-      this.server = createServer2((req, res) => this.handleRequest(req, res));
+    return new Promise((resolve6, reject) => {
+      this.server = createServer3((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve5());
+      this.server.listen(this.port, () => resolve6());
     });
   }
   /** Stop the server. */
   async stop() {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       if (!this.server) {
-        resolve5();
+        resolve6();
         return;
       }
-      this.server.close(() => resolve5());
+      this.server.close(() => resolve6());
     });
   }
   getPort() {
@@ -2093,10 +3393,10 @@ var WorkerServer = class {
   }
 };
 function readBody(req) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve5(Buffer.concat(chunks).toString("utf-8")));
+    req.on("end", () => resolve6(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
 }
@@ -2423,4 +3723,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-LB6MG36X.js.map
+//# sourceMappingURL=chunk-MKE2NVOC.js.map