@hasna/brains 0.0.1 → 0.0.2

package/dist/cli/index.js

@@ -2062,771 +2062,6 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
-// node_modules/better-sqlite3/lib/util.js
-var require_util = __commonJS((exports) => {
-  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 = Symbol();
-  exports.inspect = Symbol.for("nodejs.util.inspect.custom");
-});
-
-// node_modules/better-sqlite3/lib/sqlite-error.js
-var require_sqlite_error = __commonJS((exports, module) => {
-  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/file-uri-to-path/index.js
-var require_file_uri_to_path = __commonJS((exports, module) => {
-  var sep = __require("path").sep || "/";
-  module.exports = fileUriToPath;
-  function fileUriToPath(uri) {
-    if (typeof uri != "string" || uri.length <= 7 || uri.substring(0, 7) != "file://") {
-      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 (host == "localhost")
-      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/bindings/bindings.js
-var require_bindings = __commonJS((exports, module) => {
-  var __filename = "/Users/hasna/Workspace/hasna/opensource/opensourcedev/open-brains/node_modules/bindings/bindings.js";
-  var fs = __require("fs");
-  var path = __require("path");
-  var fileURLToPath = require_file_uri_to_path();
-  var join = path.join;
-  var dirname = path.dirname;
-  var exists2 = 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: [
-      ["module_root", "build", "bindings"],
-      ["module_root", "build", "Debug", "bindings"],
-      ["module_root", "build", "Release", "bindings"],
-      ["module_root", "out", "Debug", "bindings"],
-      ["module_root", "Debug", "bindings"],
-      ["module_root", "out", "Release", "bindings"],
-      ["module_root", "Release", "bindings"],
-      ["module_root", "build", "default", "bindings"],
-      ["module_root", "compiled", "version", "platform", "arch", "bindings"],
-      ["module_root", "addon-build", "release", "install-root", "bindings"],
-      ["module_root", "addon-build", "debug", "install-root", "bindings"],
-      ["module_root", "addon-build", "default", "install-root", "bindings"],
-      ["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:
-` + tries.map(function(a) {
-      return opts.arrow + a;
-    }).join(`
-`));
-    err.tries = tries;
-    throw err;
-  }
-  module.exports = exports = bindings;
-  exports.getFileName = function getFileName(calling_file) {
-    var { prepareStackTrace: origPST, stackTraceLimit: origSTL } = Error, 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 = fileURLToPath(fileName);
-    }
-    return fileName;
-  };
-  exports.getRoot = function getRoot(file) {
-    var dir = dirname(file), prev;
-    while (true) {
-      if (dir === ".") {
-        dir = process.cwd();
-      }
-      if (exists2(join(dir, "package.json")) || exists2(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/better-sqlite3/lib/methods/wrappers.js
-var require_wrappers = __commonJS((exports) => {
-  var { cppdb } = require_util();
-  exports.prepare = function prepare(sql2) {
-    return this[cppdb].prepare(sql2, this, false);
-  };
-  exports.exec = function exec(sql2) {
-    this[cppdb].exec(sql2);
-    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/better-sqlite3/lib/methods/transaction.js
-var require_transaction = __commonJS((exports, module) => {
-  var { cppdb } = require_util();
-  var controllers = 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 `\t_bs3.\t`", self, false),
-        release: db.prepare("RELEASE `\t_bs3.\t`", self, false),
-        rollbackTo: db.prepare("ROLLBACK TO `\t_bs3.\t`", 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/better-sqlite3/lib/methods/pragma.js
-var require_pragma = __commonJS((exports, module) => {
-  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/better-sqlite3/lib/methods/backup.js
-var require_backup = __commonJS((exports, module) => {
-  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((resolve, reject) => {
-      setImmediate(function step() {
-        try {
-          const progress = backup.transfer(rate);
-          if (!progress.remainingPages) {
-            backup.close();
-            resolve(progress);
-            return;
-          }
-          if (useDefault) {
-            useDefault = false;
-            rate = 100;
-          }
-          if (handler) {
-            const ret = handler(progress);
-            if (ret !== undefined) {
-              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/better-sqlite3/lib/methods/serialize.js
-var require_serialize = __commonJS((exports, module) => {
-  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/better-sqlite3/lib/methods/function.js
-var require_function = __commonJS((exports, module) => {
-  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/better-sqlite3/lib/methods/aggregate.js
-var require_aggregate = __commonJS((exports, module) => {
-  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/better-sqlite3/lib/methods/table.js
-var require_table = __commonJS((exports, module) => {
-  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 === undefined) {
-        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/better-sqlite3/lib/methods/inspect.js
-var require_inspect = __commonJS((exports, module) => {
-  var DatabaseInspection = function Database() {};
-  module.exports = function inspect(depth, opts) {
-    return Object.assign(new DatabaseInspection, this);
-  };
-});
-
-// node_modules/better-sqlite3/lib/database.js
-var require_database = __commonJS((exports, module) => {
-  var fs = __require("fs");
-  var path = __require("path");
-  var util = require_util();
-  var SqliteError = require_sqlite_error();
-  var DEFAULT_ADDON;
-  function Database(filenameGiven, options) {
-    if (new.target == null) {
-      return new Database(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 : 5000;
-    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();
-  Database.prototype.prepare = wrappers.prepare;
-  Database.prototype.transaction = require_transaction();
-  Database.prototype.pragma = require_pragma();
-  Database.prototype.backup = require_backup();
-  Database.prototype.serialize = require_serialize();
-  Database.prototype.function = require_function();
-  Database.prototype.aggregate = require_aggregate();
-  Database.prototype.table = require_table();
-  Database.prototype.loadExtension = wrappers.loadExtension;
-  Database.prototype.exec = wrappers.exec;
-  Database.prototype.close = wrappers.close;
-  Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
-  Database.prototype.unsafeMode = wrappers.unsafeMode;
-  Database.prototype[util.inspect] = require_inspect();
-  module.exports = Database;
-});
-
-// node_modules/better-sqlite3/lib/index.js
-var require_lib = __commonJS((exports, module) => {
-  module.exports = require_database();
-  module.exports.SqliteError = require_sqlite_error();
-});
-
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -4201,12 +3436,12 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
 
 // src/cli/index.ts
 import { randomUUID } from "crypto";
-import { readFileSync as readFileSync2, existsSync, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir6 } from "os";
 
-// node_modules/drizzle-orm/better-sqlite3/driver.js
-var import_better_sqlite3 = __toESM(require_lib(), 1);
+// node_modules/drizzle-orm/bun-sqlite/driver.js
+import { Database } from "bun:sqlite";
 
 // node_modules/drizzle-orm/selection-proxy.js
 class SelectionProxyHandler {
@@ -6334,32 +5569,39 @@ class SQLiteTransaction extends BaseSQLiteDatabase {
   }
 }
 
-// node_modules/drizzle-orm/better-sqlite3/session.js
-class BetterSQLiteSession extends SQLiteSession {
+// node_modules/drizzle-orm/bun-sqlite/session.js
+class SQLiteBunSession extends SQLiteSession {
   constructor(client, dialect, schema, options = {}) {
     super(dialect);
     this.client = client;
     this.schema = schema;
     this.logger = options.logger ?? new NoopLogger;
   }
-  static [entityKind] = "BetterSQLiteSession";
+  static [entityKind] = "SQLiteBunSession";
   logger;
+  exec(query) {
+    this.client.exec(query);
+  }
   prepareQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper) {
     const stmt = this.client.prepare(query.sql);
     return new PreparedQuery(stmt, query, this.logger, fields, executeMethod, isResponseInArrayMode, customResultMapper);
   }
   transaction(transaction, config = {}) {
-    const tx = new BetterSQLiteTransaction("sync", this.dialect, this, this.schema);
-    const nativeTx = this.client.transaction(transaction);
-    return nativeTx[config.behavior ?? "deferred"](tx);
+    const tx = new SQLiteBunTransaction("sync", this.dialect, this, this.schema);
+    let result;
+    const nativeTx = this.client.transaction(() => {
+      result = transaction(tx);
+    });
+    nativeTx[config.behavior ?? "deferred"]();
+    return result;
   }
 }
 
-class BetterSQLiteTransaction extends SQLiteTransaction {
-  static [entityKind] = "BetterSQLiteTransaction";
+class SQLiteBunTransaction extends SQLiteTransaction {
+  static [entityKind] = "SQLiteBunTransaction";
   transaction(transaction) {
     const savepointName = `sp${this.nestedIndex}`;
-    const tx = new BetterSQLiteTransaction("sync", this.dialect, this.session, this.schema, this.nestedIndex + 1);
+    const tx = new SQLiteBunTransaction("sync", this.dialect, this.session, this.schema, this.nestedIndex + 1);
     this.session.run(sql.raw(`savepoint ${savepointName}`));
     try {
       const result = transaction(tx);
@@ -6381,14 +5623,14 @@ class PreparedQuery extends SQLitePreparedQuery {
     this._isResponseInArrayMode = _isResponseInArrayMode;
     this.customResultMapper = customResultMapper;
   }
-  static [entityKind] = "BetterSQLitePreparedQuery";
+  static [entityKind] = "SQLiteBunPreparedQuery";
   run(placeholderValues) {
     const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
     this.logger.logQuery(this.query.sql, params);
     return this.stmt.run(...params);
   }
   all(placeholderValues) {
-    const { fields, joinsNotNullableMap, query, logger, stmt, customResultMapper } = this;
+    const { fields, query, logger, joinsNotNullableMap, stmt, customResultMapper } = this;
     if (!fields && !customResultMapper) {
       const params = fillPlaceholders(query.params, placeholderValues ?? {});
       logger.logQuery(query.sql, params);
@@ -6403,14 +5645,14 @@ class PreparedQuery extends SQLitePreparedQuery {
   get(placeholderValues) {
     const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
     this.logger.logQuery(this.query.sql, params);
-    const { fields, stmt, joinsNotNullableMap, customResultMapper } = this;
-    if (!fields && !customResultMapper) {
-      return stmt.get(...params);
-    }
-    const row = stmt.raw().get(...params);
+    const row = this.stmt.values(...params)[0];
     if (!row) {
       return;
     }
+    const { fields, joinsNotNullableMap, customResultMapper } = this;
+    if (!fields && !customResultMapper) {
+      return row;
+    }
     if (customResultMapper) {
       return customResultMapper([row]);
     }
@@ -6419,16 +5661,16 @@ class PreparedQuery extends SQLitePreparedQuery {
   values(placeholderValues) {
     const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
     this.logger.logQuery(this.query.sql, params);
-    return this.stmt.raw().all(...params);
+    return this.stmt.values(...params);
   }
   isResponseInArrayMode() {
     return this._isResponseInArrayMode;
   }
 }
 
-// node_modules/drizzle-orm/better-sqlite3/driver.js
-class BetterSQLite3Database extends BaseSQLiteDatabase {
-  static [entityKind] = "BetterSQLite3Database";
+// node_modules/drizzle-orm/bun-sqlite/driver.js
+class BunSQLiteDatabase extends BaseSQLiteDatabase {
+  static [entityKind] = "BunSQLiteDatabase";
 }
 function construct(client, config = {}) {
   const dialect = new SQLiteSyncDialect({ casing: config.casing });
@@ -6447,14 +5689,14 @@ function construct(client, config = {}) {
       tableNamesMap: tablesConfig.tableNamesMap
     };
   }
-  const session = new BetterSQLiteSession(client, dialect, schema, { logger });
-  const db = new BetterSQLite3Database("sync", dialect, session, schema);
+  const session = new SQLiteBunSession(client, dialect, schema, { logger });
+  const db = new BunSQLiteDatabase("sync", dialect, session, schema);
   db.$client = client;
   return db;
 }
 function drizzle(...params) {
   if (params[0] === undefined || typeof params[0] === "string") {
-    const instance = params[0] === undefined ? new import_better_sqlite3.default : new import_better_sqlite3.default(params[0]);
+    const instance = params[0] === undefined ? new Database : new Database(params[0]);
     return construct(instance, params[1]);
   }
   if (isConfig(params[0])) {
@@ -6462,11 +5704,12 @@ function drizzle(...params) {
     if (client)
       return construct(client, drizzleConfig);
     if (typeof connection === "object") {
-      const { source, ...options } = connection;
-      const instance2 = new import_better_sqlite3.default(source, options);
+      const { source, ...opts } = connection;
+      const options = Object.values(opts).filter((v) => v !== undefined).length ? opts : undefined;
+      const instance2 = new Database(source, options);
       return construct(instance2, drizzleConfig);
     }
-    const instance = new import_better_sqlite3.default(connection);
+    const instance = new Database(connection);
     return construct(instance, drizzleConfig);
   }
   return construct(params[0], params[1]);
@@ -6479,7 +5722,7 @@ function drizzle(...params) {
 })(drizzle || (drizzle = {}));
 
 // src/db/index.ts
-var import_better_sqlite33 = __toESM(require_lib(), 1);
+import { Database as Database2 } from "bun:sqlite";
 import { mkdirSync } from "fs";
 import { dirname, join } from "path";
 import { homedir } from "os";
@@ -6500,6 +5743,10 @@ var fineTunedModels = sqliteTable("fine_tuned_models", {
     enum: ["pending", "running", "succeeded", "failed", "cancelled"]
   }).notNull().default("pending"),
   fineTuneJobId: text("fine_tune_job_id"),
+  displayName: text("display_name"),
+  description: text("description"),
+  collection: text("collection"),
+  tags: text("tags"),
   createdAt: integer("created_at").notNull(),
   updatedAt: integer("updated_at").notNull()
 });
@@ -6538,6 +5785,10 @@ function createTables(sqlite) {
       provider TEXT NOT NULL,
       status TEXT NOT NULL DEFAULT 'pending',
       fine_tune_job_id TEXT,
+      display_name TEXT,
+      description TEXT,
+      collection TEXT,
+      tags TEXT,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL
     );
@@ -6566,9 +5817,9 @@ function createTables(sqlite) {
 function getDb(dbPath) {
   const resolvedPath = dbPath ?? DEFAULT_DB_PATH;
   ensureDir(resolvedPath);
-  const sqlite = new import_better_sqlite33.default(resolvedPath);
-  sqlite.pragma("journal_mode = WAL");
-  sqlite.pragma("foreign_keys = ON");
+  const sqlite = new Database2(resolvedPath);
+  sqlite.run("PRAGMA journal_mode = WAL");
+  sqlite.run("PRAGMA foreign_keys = ON");
   createTables(sqlite);
   return drizzle(sqlite, { schema: exports_schema });
 }
@@ -12256,6 +11507,352 @@ function printInfo(message) {
   console.log(chalk.dim("  " + message));
 }
 
+// src/lib/gatherers/todos.ts
+import { Database as Database3 } from "bun:sqlite";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var SYSTEM_PROMPT = "You are a task management assistant that helps users create, update, search, and manage tasks and projects.";
+function taskToCreateExample(task) {
+  const userMsg = `Create a task: ${task.title}${task.description ? `
+
+Description: ${task.description}` : ""}`;
+  const taskDetails = {
+    id: task.short_id ?? task.id,
+    title: task.title,
+    description: task.description ?? "",
+    status: task.status,
+    priority: task.priority,
+    tags: JSON.parse(task.tags ?? "[]"),
+    created_at: task.created_at
+  };
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: userMsg },
+      { role: "assistant", content: `Created task: ${JSON.stringify(taskDetails, null, 2)}` }
+    ]
+  };
+}
+function taskToStatusUpdateExample(task) {
+  if (!task.completed_at && task.status === "pending")
+    return null;
+  const id = task.short_id ?? task.id;
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: `Mark task ${id} as ${task.status}` },
+      { role: "assistant", content: `Task ${id} has been updated to status: ${task.status}. ${task.completed_at ? `Completed at: ${task.completed_at}` : ""}`.trim() }
+    ]
+  };
+}
+function taskToSearchExample(tasks, query) {
+  const matched = tasks.filter((t) => t.title.toLowerCase().includes(query.toLowerCase())).slice(0, 5);
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: `Search tasks for: "${query}"` },
+      {
+        role: "assistant",
+        content: matched.length > 0 ? `Found ${matched.length} task(s):
+${matched.map((t) => `- [${t.short_id ?? t.id}] ${t.title} (${t.status})`).join(`
+`)}` : `No tasks found matching "${query}".`
+      }
+    ]
+  };
+}
+async function gatherFromTodos(options = {}) {
+  const dbPath = join2(homedir2(), ".todos", "todos.db");
+  const db = new Database3(dbPath, { readonly: true, create: false });
+  try {
+    let query = "SELECT * FROM tasks WHERE 1=1";
+    const params = [];
+    if (options.since) {
+      query += " AND created_at >= ?";
+      params.push(options.since.toISOString());
+    }
+    query += " ORDER BY created_at DESC";
+    if (options.limit) {
+      query += " LIMIT ?";
+      params.push(options.limit * 2);
+    }
+    const tasks = db.query(query).all(...params);
+    const examples = [];
+    for (const task of tasks) {
+      examples.push(taskToCreateExample(task));
+      const statusEx = taskToStatusUpdateExample(task);
+      if (statusEx)
+        examples.push(statusEx);
+    }
+    const searchTerms = ["urgent", "fix", "implement", "create", "update", "review"];
+    for (const term of searchTerms) {
+      examples.push(taskToSearchExample(tasks, term));
+    }
+    const finalExamples = options.limit ? examples.slice(0, options.limit) : examples;
+    return {
+      source: "todos",
+      examples: finalExamples,
+      count: finalExamples.length
+    };
+  } finally {
+    db.close();
+  }
+}
+
+// src/lib/gatherers/mementos.ts
+import { Database as Database4 } from "bun:sqlite";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var SYSTEM_PROMPT2 = "You are an AI assistant with persistent memory. You can remember and recall information across sessions to provide better, more personalized assistance.";
+function memoryToRecallExample(memory) {
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT2 },
+      { role: "user", content: `What do you remember about "${memory.key}"?` },
+      {
+        role: "assistant",
+        content: memory.summary ? `${memory.value}
+
+Summary: ${memory.summary}` : memory.value
+      }
+    ]
+  };
+}
+function memoryToSaveExample(memory) {
+  const tags = JSON.parse(memory.tags ?? "[]");
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT2 },
+      {
+        role: "user",
+        content: `Remember this for me: ${memory.key} = ${memory.value}${tags.length ? ` (tags: ${tags.join(", ")})` : ""}`
+      },
+      {
+        role: "assistant",
+        content: `Saved to memory: "${memory.key}" with ${memory.category} category, importance ${memory.importance}/10, scope: ${memory.scope}.`
+      }
+    ]
+  };
+}
+function memoryToSearchExample(memories, category) {
+  const matched = memories.filter((m) => m.category === category && m.status === "active").slice(0, 5);
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT2 },
+      { role: "user", content: `What ${category} memories do you have?` },
+      {
+        role: "assistant",
+        content: matched.length > 0 ? `Here are my ${category} memories:
+${matched.map((m) => `- ${m.key}: ${m.value.slice(0, 120)}${m.value.length > 120 ? "..." : ""}`).join(`
+`)}` : `I don't have any ${category} memories stored yet.`
+      }
+    ]
+  };
+}
+async function gatherFromMementos(options = {}) {
+  const dbPath = join3(homedir3(), ".mementos", "mementos.db");
+  const db = new Database4(dbPath, { readonly: true, create: false });
+  try {
+    let query = "SELECT * FROM memories WHERE status = 'active'";
+    const params = [];
+    if (options.since) {
+      query += " AND created_at >= ?";
+      params.push(options.since.toISOString());
+    }
+    query += " ORDER BY importance DESC, created_at DESC";
+    if (options.limit) {
+      query += " LIMIT ?";
+      params.push(options.limit * 3);
+    }
+    const memories = db.query(query).all(...params);
+    const examples = [];
+    for (const memory of memories) {
+      examples.push(memoryToRecallExample(memory));
+      examples.push(memoryToSaveExample(memory));
+    }
+    const categories = [...new Set(memories.map((m) => m.category))];
+    for (const category of categories) {
+      examples.push(memoryToSearchExample(memories, category));
+    }
+    const finalExamples = options.limit ? examples.slice(0, options.limit) : examples;
+    return {
+      source: "mementos",
+      examples: finalExamples,
+      count: finalExamples.length
+    };
+  } finally {
+    db.close();
+  }
+}
+
+// src/lib/gatherers/conversations.ts
+import { Database as Database5 } from "bun:sqlite";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+var SYSTEM_PROMPT3 = "You are a helpful AI assistant participating in multi-agent conversations. You communicate clearly and collaboratively with other agents and users.";
+function windowToExample(window2) {
+  if (window2.length < 2)
+    return null;
+  const messages = [
+    { role: "system", content: SYSTEM_PROMPT3 }
+  ];
+  for (let i = 0;i < window2.length - 1; i++) {
+    const msg = window2[i];
+    if (!msg)
+      continue;
+    const role = i % 2 === 0 ? "user" : "assistant";
+    messages.push({
+      role,
+      content: `[${msg.from_agent} \u2192 ${msg.to_agent ?? msg.space ?? "all"}]: ${msg.content}`
+    });
+  }
+  const last = window2[window2.length - 1];
+  if (!last)
+    return null;
+  messages.push({
+    role: "assistant",
+    content: `[${last.from_agent} \u2192 ${last.to_agent ?? last.space ?? "all"}]: ${last.content}`
+  });
+  return { messages };
+}
+async function gatherFromConversations(options = {}) {
+  const dbPath = join4(homedir4(), ".conversations", "messages.db");
+  const db = new Database5(dbPath, { readonly: true, create: false });
+  try {
+    let query = "SELECT * FROM messages WHERE 1=1";
+    const params = [];
+    if (options.since) {
+      query += " AND created_at >= ?";
+      params.push(options.since.toISOString());
+    }
+    query += " ORDER BY session_id, created_at ASC";
+    const allMessages = db.query(query).all(...params);
+    const sessions = new Map;
+    for (const msg of allMessages) {
+      const msgs = sessions.get(msg.session_id) ?? [];
+      msgs.push(msg);
+      sessions.set(msg.session_id, msgs);
+    }
+    const examples = [];
+    const windowSize = 4;
+    for (const [, sessionMsgs] of sessions) {
+      if (sessionMsgs.length < 2)
+        continue;
+      for (let start = 0;start <= sessionMsgs.length - 2; start++) {
+        const end = Math.min(start + windowSize, sessionMsgs.length);
+        const window2 = sessionMsgs.slice(start, end);
+        const example = windowToExample(window2);
+        if (example)
+          examples.push(example);
+      }
+    }
+    const finalExamples = options.limit ? examples.slice(0, options.limit) : examples;
+    return {
+      source: "conversations",
+      examples: finalExamples,
+      count: finalExamples.length
+    };
+  } finally {
+    db.close();
+  }
+}
+
+// src/lib/gatherers/sessions.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+var SYSTEM_PROMPT4 = "You are Claude Code, an AI assistant built by Anthropic that helps developers with coding, architecture, debugging, and software engineering tasks.";
+function extractText(content) {
+  if (typeof content === "string")
+    return content;
+  return content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join(`
+`).trim();
+}
+async function gatherFromSessions(options = {}) {
+  const { limit: limit2 = 1000 } = options;
+  const examples = [];
+  const claudeDir = join5(homedir5(), ".claude", "projects");
+  if (!existsSync(claudeDir)) {
+    return { source: "sessions", examples: [], count: 0 };
+  }
+  const projectDirs = await readdir(claudeDir).catch(() => []);
+  for (const projectDir of projectDirs) {
+    if (examples.length >= limit2)
+      break;
+    const projectPath = join5(claudeDir, projectDir);
+    const files = await readdir(projectPath).catch(() => []);
+    for (const file of files) {
+      if (examples.length >= limit2)
+        break;
+      if (!file.endsWith(".jsonl"))
+        continue;
+      const filePath = join5(projectPath, file);
+      if (options.since) {
+        const fileStat = await stat(filePath).catch(() => null);
+        if (fileStat && fileStat.mtime < options.since)
+          continue;
+      }
+      const content = await readFile(filePath, "utf-8").catch(() => "");
+      if (!content.trim())
+        continue;
+      const lines = content.trim().split(`
+`);
+      const turns = [];
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if ((entry.type === "user" || entry.type === "human") && entry.message?.content) {
+            const text2 = extractText(entry.message.content);
+            if (text2.trim())
+              turns.push({ role: "user", content: text2.trim() });
+          } else if (entry.type === "assistant" && entry.message?.content) {
+            const text2 = extractText(entry.message.content);
+            if (text2.trim())
+              turns.push({ role: "assistant", content: text2.trim() });
+          }
+        } catch {}
+      }
+      const windowSize = 6;
+      for (let start = 0;start < turns.length - 1 && examples.length < limit2; start++) {
+        const window2 = turns.slice(start, start + windowSize);
+        if (!window2[0] || window2[0].role !== "user")
+          continue;
+        const lastAssistantIdx = window2.map((t) => t.role).lastIndexOf("assistant");
+        if (lastAssistantIdx < 1)
+          continue;
+        const usedTurns = window2.slice(0, lastAssistantIdx + 1);
+        examples.push({
+          messages: [
+            { role: "system", content: SYSTEM_PROMPT4 },
+            ...usedTurns
+          ]
+        });
+      }
+    }
+  }
+  return { source: "sessions", examples, count: examples.length };
+}
+// src/lib/gatherers/index.ts
+var ALL_SOURCES = ["todos", "mementos", "conversations", "sessions"];
+async function gatherAll(sources, options = {}) {
+  const targets = sources.includes("all") ? [...ALL_SOURCES] : sources;
+  const results = await Promise.allSettled(targets.map((source) => {
+    switch (source) {
+      case "todos":
+        return gatherFromTodos(options);
+      case "mementos":
+        return gatherFromMementos(options);
+      case "conversations":
+        return gatherFromConversations(options);
+      case "sessions":
+        return gatherFromSessions(options);
+      default:
+        return Promise.resolve({ source, examples: [], count: 0 });
+    }
+  }));
+  return results.filter((r) => r.status === "fulfilled").map((r) => r.value);
+}
+
 // src/cli/index.ts
 var program2 = new Command;
 program2.name("brains").description("Fine-tuned model tracker and trainer").version("0.0.1");
@@ -12268,7 +11865,14 @@ modelsCmd.command("list").description("List all tracked fine-tuned models").acti
       printInfo("No models tracked yet. Use 'brains finetune start' to train one.");
       return;
     }
-    printTable(["ID", "Name", "Provider", "Status", "Base Model"], models.map((m) => [m.id, m.name, m.provider, printStatus(m.status), m.baseModel]));
+    printTable(["ID", "Display Name", "Provider", "Status", "Collection", "Base Model"], models.map((m) => [
+      m.id,
+      m.displayName ?? m.name,
+      m.provider,
+      printStatus(m.status),
+      m.collection ?? "",
+      m.baseModel
+    ]));
   } catch (err) {
     printError(err instanceof Error ? err.message : String(err));
     process.exit(1);
@@ -12283,8 +11887,13 @@ modelsCmd.command("show <id>").description("Show details of a specific model").a
       process.exit(1);
     }
     console.log();
+    const tagsList = model.tags ? JSON.parse(model.tags).join(", ") : "(none)";
     console.log(`  ID:            ${model.id}`);
     console.log(`  Name:          ${model.name}`);
+    console.log(`  Display Name:  ${model.displayName ?? "(none)"}`);
+    console.log(`  Description:   ${model.description ?? "(none)"}`);
+    console.log(`  Collection:    ${model.collection ?? "(none)"}`);
+    console.log(`  Tags:          ${tagsList}`);
     console.log(`  Provider:      ${model.provider}`);
     console.log(`  Status:        ${printStatus(model.status)}`);
     console.log(`  Base Model:    ${model.baseModel}`);
@@ -12297,6 +11906,72 @@ modelsCmd.command("show <id>").description("Show details of a specific model").a
     process.exit(1);
   }
 });
+modelsCmd.command("rename <id> <displayName>").description("Set the display name of a model").action(async (id, displayName) => {
+  try {
+    const db = getDb();
+    await db.update(fineTunedModels).set({ displayName, updatedAt: Date.now() }).where(eq(fineTunedModels.id, id));
+    printSuccess(`Display name set to "${displayName}"`);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+modelsCmd.command("describe <id> <description>").description("Set the description of a model").action(async (id, description) => {
+  try {
+    const db = getDb();
+    await db.update(fineTunedModels).set({ description, updatedAt: Date.now() }).where(eq(fineTunedModels.id, id));
+    printSuccess(`Description updated.`);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+modelsCmd.command("tag <id> <tag>").description("Add a tag to a model").action(async (id, tag) => {
+  try {
+    const db = getDb();
+    const [model] = await db.select().from(fineTunedModels).where(eq(fineTunedModels.id, id));
+    if (!model) {
+      printError(`Model not found: ${id}`);
+      process.exit(1);
+    }
+    const existing = model.tags ? JSON.parse(model.tags) : [];
+    if (!existing.includes(tag)) {
+      existing.push(tag);
+    }
+    await db.update(fineTunedModels).set({ tags: JSON.stringify(existing), updatedAt: Date.now() }).where(eq(fineTunedModels.id, id));
+    printSuccess(`Tag "${tag}" added. Tags: ${existing.join(", ")}`);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+modelsCmd.command("untag <id> <tag>").description("Remove a tag from a model").action(async (id, tag) => {
+  try {
+    const db = getDb();
+    const [model] = await db.select().from(fineTunedModels).where(eq(fineTunedModels.id, id));
+    if (!model) {
+      printError(`Model not found: ${id}`);
+      process.exit(1);
+    }
+    const existing = model.tags ? JSON.parse(model.tags) : [];
+    const updated = existing.filter((t) => t !== tag);
+    await db.update(fineTunedModels).set({ tags: JSON.stringify(updated), updatedAt: Date.now() }).where(eq(fineTunedModels.id, id));
+    printSuccess(`Tag "${tag}" removed. Tags: ${updated.join(", ") || "(none)"}`);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+modelsCmd.command("collection <id> <collectionName>").description("Set the collection of a model").action(async (id, collectionName) => {
+  try {
+    const db = getDb();
+    await db.update(fineTunedModels).set({ collection: collectionName, updatedAt: Date.now() }).where(eq(fineTunedModels.id, id));
+    printSuccess(`Collection set to "${collectionName}"`);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
 var finetuneCmd = program2.command("finetune").description("Manage fine-tuning jobs");
 finetuneCmd.command("start").description("Start a fine-tuning job").requiredOption("--provider <provider>", "Provider to use (openai|thinker-labs)").requiredOption("--base-model <model>", "Base model to fine-tune (e.g. gpt-4o-mini-2024-07-18)").requiredOption("--dataset <path>", "Path to the JSONL training dataset").requiredOption("--name <name>", "Human-readable name for this fine-tuned model").action(async (opts) => {
   try {
@@ -12304,7 +11979,7 @@ finetuneCmd.command("start").description("Start a fine-tuning job").requiredOpti
       printError(`Unknown provider: ${opts.provider}. Use 'openai' or 'thinker-labs'.`);
       process.exit(1);
     }
-    if (!existsSync(opts.dataset)) {
+    if (!existsSync2(opts.dataset)) {
       printError(`Dataset file not found: ${opts.dataset}`);
       process.exit(1);
     }
@@ -12411,7 +12086,7 @@ finetuneCmd.command("list").description("List all fine-tuning jobs").option("--p
     process.exit(1);
   }
 });
-var DEFAULT_DATASETS_DIR = join2(homedir2(), ".brains", "datasets");
+var DEFAULT_DATASETS_DIR = join6(homedir6(), ".brains", "datasets");
 var dataCmd = program2.command("data").description("Manage training datasets");
 dataCmd.command("gather").description("Gather training data from agent memory sources").option("--source <source>", "Data source: todos|mementos|conversations|sessions|all", "all").option("--output <dir>", "Output directory", DEFAULT_DATASETS_DIR).option("--limit <n>", "Maximum number of examples to gather", "500").action(async (opts) => {
   const validSources = ["todos", "mementos", "conversations", "sessions", "all"];
@@ -12427,43 +12102,32 @@ dataCmd.command("gather").description("Gather training data from agent memory so
   try {
     mkdirSync2(opts.output, { recursive: true });
     const sources = opts.source === "all" ? ["todos", "mementos", "conversations", "sessions"] : [opts.source];
-    let totalExamples = 0;
     const now = Date.now();
     const db = getDb();
-    for (const source of sources) {
-      printInfo(`Gathering from ${source} \u2026`);
-      try {
-        const gathererPath = new URL(`../lib/gatherers/${source}.js`, import.meta.url);
-        const mod = await import(gathererPath.pathname).catch(() => null);
-        if (!mod || typeof mod.gather !== "function") {
-          printInfo(`  No gatherer found for source '${source}', skipping.`);
-          continue;
-        }
-        const result = await mod.gather({ limit: limit2, outputDir: opts.output });
-        const count = result?.count ?? 0;
-        const examples = result?.examples ?? [];
-        totalExamples += count;
-        if (count === 0) {
-          printInfo(`  No examples gathered from ${source}.`);
-          continue;
-        }
-        const fileName = `${source}-${now}.jsonl`;
-        const filePath = join2(opts.output, fileName);
-        writeFileSync(filePath, examples.map((e) => JSON.stringify(e)).join(`
+    const results = await gatherAll(sources, { limit: limit2 });
+    let totalExamples = 0;
+    for (const result of results) {
+      const { source, examples, count } = result;
+      printInfo(`Gathered from ${source} \u2026`);
+      if (count === 0) {
+        printInfo(`  No examples gathered from ${source}.`);
+        continue;
+      }
+      totalExamples += count;
+      const fileName = `${source}-${now}.jsonl`;
+      const filePath = join6(opts.output, fileName);
+      writeFileSync(filePath, examples.map((e) => JSON.stringify(e)).join(`
 `) + `
 `, "utf8");
-        const datasetId = randomUUID();
-        await db.insert(trainingDatasets).values({
-          id: datasetId,
-          source,
-          filePath,
-          exampleCount: count,
-          createdAt: now
-        });
-        printSuccess(`  ${count} examples \u2192 ${filePath}`);
-      } catch (innerErr) {
-        printError(`  Failed to gather from ${source}: ${innerErr instanceof Error ? innerErr.message : String(innerErr)}`);
-      }
+      const datasetId = randomUUID();
+      await db.insert(trainingDatasets).values({
+        id: datasetId,
+        source,
+        filePath,
+        exampleCount: count,
+        createdAt: now
+      });
+      printSuccess(`  ${count} examples \u2192 ${filePath}`);
     }
     console.log();
     printSuccess(`Total examples gathered: ${totalExamples}`);
@@ -12473,7 +12137,7 @@ dataCmd.command("gather").description("Gather training data from agent memory so
   }
 });
 dataCmd.command("preview <file>").description("Preview a JSONL training file").option("-n, --count <n>", "Number of examples to show", "5").action((file, opts) => {
-  if (!existsSync(file)) {
+  if (!existsSync2(file)) {
     printError(`File not found: ${file}`);
     process.exit(1);
   }
@@ -12528,4 +12192,59 @@ dataCmd.command("list").description("List all gathered datasets").action(async (
     process.exit(1);
   }
 });
+var collectionsCmd = program2.command("collections").description("Manage model collections");
+collectionsCmd.action(async () => {
+  await listCollections();
+});
+async function listCollections() {
+  try {
+    const db = getDb();
+    const rows = await db.select({
+      collection: fineTunedModels.collection,
+      count: sql`count(*)`.as("count"),
+      names: sql`group_concat(coalesce(${fineTunedModels.displayName}, ${fineTunedModels.name}), ', ')`.as("names")
+    }).from(fineTunedModels).groupBy(fineTunedModels.collection);
+    if (rows.length === 0) {
+      printInfo("No collections found. Set a collection with 'brains models set-collection'.");
+      return;
+    }
+    printTable(["Collection", "Model Count", "Models"], rows.map((r) => [
+      r.collection ?? "(none)",
+      String(r.count),
+      r.names ?? ""
+    ]));
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+collectionsCmd.command("list").description("List all collections with model counts").action(async () => {
+  await listCollections();
+});
+collectionsCmd.command("show <name>").description("List all models in a collection").action(async (name) => {
+  try {
+    const db = getDb();
+    const models = await db.select().from(fineTunedModels).where(eq(fineTunedModels.collection, name));
+    if (models.length === 0) {
+      printInfo(`No models found in collection '${name}'.`);
+      return;
+    }
+    printTable(["ID", "Name", "Provider", "Status", "Base Model"], models.map((m) => [m.id, m.name, m.provider, printStatus(m.status), m.baseModel]));
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+collectionsCmd.command("rename <oldName> <newName>").description("Rename a collection across all models").action(async (oldName, newName) => {
+  try {
+    const db = getDb();
+    const affected = await db.select({ id: fineTunedModels.id }).from(fineTunedModels).where(eq(fineTunedModels.collection, oldName));
+    const count = affected.length;
+    await db.update(fineTunedModels).set({ collection: newName, updatedAt: Date.now() }).where(eq(fineTunedModels.collection, oldName));
+    printSuccess(`Renamed collection '${oldName}' \u2192 '${newName}' (${count} models updated)`);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
 program2.parse();