apsolut-cortex 0.1.0

package/dist/cli.js

@@ -0,0 +1,1364 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// 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 = "D:\\sites\\git\\apsolut-cortex\\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 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 || " → ",
+    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 (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/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS((exports) => {
+  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/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();
+});
+
+// src/db.ts
+var exports_db = {};
+__export(exports_db, {
+  upsertSession: () => upsertSession,
+  upsertProject: () => upsertProject,
+  updateWeight: () => updateWeight,
+  searchVector: () => searchVector,
+  searchBM25: () => searchBM25,
+  mergeRRF: () => mergeRRF,
+  markObservationsPromoted: () => markObservationsPromoted,
+  insertObservation: () => insertObservation,
+  insertMemory: () => insertMemory,
+  getSessionObservations: () => getSessionObservations,
+  getRecentSummaries: () => getRecentSummaries,
+  getDb: () => getDb,
+  decayAndPrune: () => decayAndPrune,
+  cosineSimilarity: () => cosineSimilarity,
+  applyMMR: () => applyMMR,
+  REGISTRY_PATH: () => REGISTRY_PATH,
+  MODELS_DIR: () => MODELS_DIR,
+  DB_PATH: () => DB_PATH,
+  CORTEX_DIR: () => CORTEX_DIR
+});
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getDb() {
+  if (_db)
+    return _db;
+  if (!existsSync(CORTEX_DIR))
+    mkdirSync(CORTEX_DIR, { recursive: true });
+  if (!existsSync(MODELS_DIR))
+    mkdirSync(MODELS_DIR, { recursive: true });
+  _db = new import_better_sqlite3.default(DB_PATH);
+  _db.pragma("journal_mode = WAL");
+  _db.pragma("synchronous = NORMAL");
+  _db.pragma("foreign_keys = ON");
+  _db.pragma("cache_size = -32000");
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id           TEXT PRIMARY KEY,
+      name         TEXT NOT NULL,
+      path         TEXT,
+      created_at   INTEGER NOT NULL,
+      last_session INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id                 TEXT PRIMARY KEY,
+      project_id         TEXT NOT NULL REFERENCES projects(id),
+      started_at         INTEGER NOT NULL,
+      ended_at           INTEGER,
+      summary            TEXT,
+      memories_injected  INTEGER NOT NULL DEFAULT 0,
+      memories_stored    INTEGER NOT NULL DEFAULT 0,
+      tool_failures      INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_project
+      ON sessions(project_id, started_at DESC);
+
+    CREATE TABLE IF NOT EXISTS observations (
+      id          TEXT PRIMARY KEY,
+      session_id  TEXT NOT NULL REFERENCES sessions(id),
+      project_id  TEXT NOT NULL,
+      tool_name   TEXT,
+      content     TEXT NOT NULL,
+      category    TEXT,
+      created_at  INTEGER NOT NULL,
+      promoted    INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_obs_session ON observations(session_id);
+    CREATE INDEX IF NOT EXISTS idx_obs_project ON observations(project_id, created_at DESC);
+
+    CREATE TABLE IF NOT EXISTS memories (
+      id           TEXT PRIMARY KEY,
+      project_id   TEXT NOT NULL,
+      tier         TEXT NOT NULL DEFAULT 'semantic',
+      category     TEXT NOT NULL DEFAULT 'insight',
+      trust        TEXT NOT NULL DEFAULT 'observed',
+      content      TEXT NOT NULL,
+      context      TEXT,
+      source       TEXT NOT NULL DEFAULT 'manual',
+      embedding    BLOB,
+      weight       REAL NOT NULL DEFAULT 1.0,
+      used_count   INTEGER NOT NULL DEFAULT 0,
+      last_used    INTEGER,
+      created_at   INTEGER NOT NULL,
+      session_id   TEXT REFERENCES sessions(id),
+      flagged      INTEGER NOT NULL DEFAULT 0,
+      flag_reason  TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mem_project ON memories(project_id);
+    CREATE INDEX IF NOT EXISTS idx_mem_weight  ON memories(project_id, weight DESC);
+    CREATE INDEX IF NOT EXISTS idx_mem_tier    ON memories(project_id, tier);
+    CREATE INDEX IF NOT EXISTS idx_mem_trust   ON memories(project_id, trust);
+    CREATE INDEX IF NOT EXISTS idx_mem_flagged ON memories(project_id, flagged)
+      WHERE flagged = 1;
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      content, context,
+      content='memories',
+      content_rowid='rowid',
+      tokenize='porter ascii'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+      INSERT INTO memories_fts(rowid, content, context)
+      VALUES (new.rowid, new.content, COALESCE(new.context, ''));
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, content, context)
+      VALUES ('delete', old.rowid, old.content, COALESCE(old.context, ''));
+      INSERT INTO memories_fts(rowid, content, context)
+      VALUES (new.rowid, new.content, COALESCE(new.context, ''));
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, content, context)
+      VALUES ('delete', old.rowid, old.content, COALESCE(old.context, ''));
+    END;
+  `);
+  return _db;
+}
+function upsertProject(db, project) {
+  const existing = db.prepare("SELECT id FROM projects WHERE id = ?").get(project.id);
+  if (existing) {
+    db.prepare("UPDATE projects SET last_session = ? WHERE id = ?").run(Date.now(), project.id);
+  } else {
+    db.prepare("INSERT INTO projects (id, name, path, created_at) VALUES (?, ?, ?, ?)").run(project.id, project.name, project.path ?? null, Date.now());
+  }
+}
+function upsertSession(db, s) {
+  const existing = db.prepare("SELECT id FROM sessions WHERE id = ?").get(s.id);
+  if (existing) {
+    const sets = [];
+    const vals = [];
+    if (s.ended_at !== undefined) {
+      sets.push("ended_at = ?");
+      vals.push(s.ended_at);
+    }
+    if (s.summary !== undefined) {
+      sets.push("summary = ?");
+      vals.push(s.summary);
+    }
+    if (s.memories_stored !== undefined) {
+      sets.push("memories_stored = ?");
+      vals.push(s.memories_stored);
+    }
+    if (s.tool_failures !== undefined) {
+      sets.push("tool_failures = ?");
+      vals.push(s.tool_failures);
+    }
+    if (sets.length) {
+      vals.push(s.id);
+      db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
+    }
+  } else {
+    db.prepare("INSERT INTO sessions (id, project_id, started_at) VALUES (?, ?, ?)").run(s.id, s.project_id, Date.now());
+  }
+}
+function getRecentSummaries(db, projectId, limit = 3) {
+  const rows = db.prepare(`
+    SELECT summary FROM sessions
+    WHERE project_id = ? AND summary IS NOT NULL AND summary != ''
+    ORDER BY started_at DESC LIMIT ?
+  `).all(projectId, limit);
+  return rows.map((r) => r.summary);
+}
+function insertObservation(db, obs) {
+  db.prepare(`
+    INSERT INTO observations (id, session_id, project_id, tool_name, content, category, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(crypto.randomUUID(), obs.session_id, obs.project_id, obs.tool_name ?? null, obs.content, obs.category ?? null, Date.now());
+}
+function getSessionObservations(db, sessionId) {
+  return db.prepare("SELECT tool_name, content, category FROM observations WHERE session_id = ? AND promoted = 0 ORDER BY created_at ASC").all(sessionId);
+}
+function markObservationsPromoted(db, sessionId) {
+  db.prepare("UPDATE observations SET promoted = 1 WHERE session_id = ?").run(sessionId);
+}
+function insertMemory(db, m) {
+  const id = crypto.randomUUID();
+  db.prepare(`
+    INSERT INTO memories
+      (id, project_id, tier, category, trust, content, context,
+       source, embedding, weight, used_count, created_at, session_id)
+    VALUES
+      (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+  `).run(id, m.project_id, m.tier, m.category, m.trust, m.content, m.context ?? null, m.source, m.embedding ?? null, m.weight, Date.now(), m.session_id ?? null);
+  return id;
+}
+function searchBM25(db, projectId, query, limit) {
+  return db.prepare(`
+    SELECT m.* FROM memories_fts
+    JOIN memories m ON m.rowid = memories_fts.rowid
+    WHERE memories_fts MATCH ? AND m.project_id = ?
+    ORDER BY bm25(memories_fts) LIMIT ?
+  `).all(query, projectId, limit);
+}
+function cosineSimilarity(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0;i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  const d = Math.sqrt(na) * Math.sqrt(nb);
+  return d === 0 ? 0 : dot / d;
+}
+function searchVector(db, projectId, queryEmb, limit) {
+  const candidates = db.prepare("SELECT * FROM memories WHERE project_id = ? AND embedding IS NOT NULL").all(projectId);
+  return candidates.map((m) => ({
+    ...m,
+    similarity: cosineSimilarity(queryEmb, new Float32Array(m.embedding.buffer))
+  })).sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+}
+function mergeRRF(list1, list2, limit, allItems) {
+  const k = 60;
+  const scores = new Map;
+  list1.forEach((r, i) => scores.set(r.id, (scores.get(r.id) ?? 0) + 1 / (i + k)));
+  list2.forEach((r, i) => scores.set(r.id, (scores.get(r.id) ?? 0) + 1 / (i + k)));
+  return [...scores.entries()].sort(([, a], [, b]) => b - a).slice(0, limit).map(([id]) => allItems.get(id)).filter(Boolean);
+}
+function applyMMR(candidates, queryEmb, limit, lambda = 0.7) {
+  if (!queryEmb || candidates.length <= limit)
+    return candidates.slice(0, limit);
+  const selected = [];
+  const remaining = [...candidates];
+  while (selected.length < limit && remaining.length > 0) {
+    let bestIdx = 0;
+    let bestScore = -Infinity;
+    for (let i = 0;i < remaining.length; i++) {
+      const cand = remaining[i];
+      const candEmb = cand.embedding ? new Float32Array(cand.embedding.buffer) : null;
+      if (!candEmb) {
+        bestIdx = i;
+        break;
+      }
+      const relevance = cand.similarity ?? cosineSimilarity(queryEmb, candEmb);
+      const maxSim = selected.reduce((max, s) => {
+        if (!s.embedding)
+          return max;
+        const sim = cosineSimilarity(candEmb, new Float32Array(s.embedding.buffer));
+        return Math.max(max, sim);
+      }, 0);
+      const score = lambda * relevance - (1 - lambda) * maxSim;
+      if (score > bestScore) {
+        bestScore = score;
+        bestIdx = i;
+      }
+    }
+    selected.push(remaining[bestIdx]);
+    remaining.splice(bestIdx, 1);
+  }
+  return selected;
+}
+function updateWeight(db, id, score) {
+  const mem = db.prepare("SELECT weight, used_count FROM memories WHERE id = ?").get(id);
+  if (!mem)
+    return;
+  const alpha = 0.3;
+  const newWeight = alpha * (score / 3) + (1 - alpha) * mem.weight;
+  const newTrust = newWeight > 1.4 || mem.used_count + 1 >= 3 ? "validated" : undefined;
+  if (newTrust) {
+    db.prepare("UPDATE memories SET weight = ?, used_count = used_count + 1, last_used = ?, trust = CASE WHEN trust = 'observed' THEN ? ELSE trust END WHERE id = ?").run(newWeight, Date.now(), newTrust, id);
+  } else {
+    db.prepare("UPDATE memories SET weight = ?, used_count = used_count + 1, last_used = ? WHERE id = ?").run(newWeight, Date.now(), id);
+  }
+}
+function decayAndPrune(db, projectId) {
+  const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+  const decayed = db.prepare(`
+    UPDATE memories
+    SET weight = weight * CASE
+      WHEN trust IN ('proven', 'canonical') THEN 1.0
+      WHEN trust = 'validated' THEN 0.98
+      ELSE 0.95
+    END
+    WHERE project_id = ?
+      AND trust NOT IN ('canonical')
+      AND (last_used IS NULL OR last_used < ?)
+  `).run(projectId, cutoff).changes;
+  const pruned = db.prepare(`
+    DELETE FROM memories
+    WHERE project_id = ? AND weight < 0.1 AND used_count > 3
+      AND trust NOT IN ('proven', 'canonical')
+  `).run(projectId).changes;
+  return { decayed, pruned };
+}
+var import_better_sqlite3, CORTEX_DIR, DB_PATH, REGISTRY_PATH, MODELS_DIR, _db = null;
+var init_db = __esm(() => {
+  import_better_sqlite3 = __toESM(require_lib(), 1);
+  CORTEX_DIR = join(homedir(), ".apsolut");
+  DB_PATH = join(CORTEX_DIR, "memory.db");
+  REGISTRY_PATH = join(CORTEX_DIR, "registry.json");
+  MODELS_DIR = join(CORTEX_DIR, "models");
+});
+
+// src/cli.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join2, resolve, dirname } from "path";
+import { homedir as homedir2 } from "os";
+import { fileURLToPath } from "url";
+
+// src/registry.ts
+init_db();
+import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+function readRegistry() {
+  if (!existsSync2(REGISTRY_PATH))
+    return { projects: {} };
+  try {
+    return JSON.parse(readFileSync(REGISTRY_PATH, "utf-8"));
+  } catch {
+    return { projects: {} };
+  }
+}
+function writeRegistry(reg) {
+  writeFileSync(REGISTRY_PATH, JSON.stringify(reg, null, 2));
+}
+function registerProject(id, name, path) {
+  const reg = readRegistry();
+  reg.projects[id] = { name, path, registered_at: Date.now() };
+  writeRegistry(reg);
+}
+
+// src/cli.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var PACKAGE_ROOT = resolve(__dirname2, "..");
+var IS_DIST = __dirname2.endsWith("dist") || __dirname2.includes(`${process.sep}dist${process.sep}`);
+var PROJECT_ROOT = process.cwd();
+var CLAUDE_SETTINGS = join2(homedir2(), ".claude", "settings.json");
+var MCP_JSON = join2(PROJECT_ROOT, ".mcp.json");
+var PROJECT_APSOLUT = join2(PROJECT_ROOT, ".apsolut");
+var PROJECT_CONFIG = join2(PROJECT_APSOLUT, "project.json");
+var cmd = process.argv[2];
+switch (cmd) {
+  case "init":
+    await init();
+    break;
+  case "status":
+    await status();
+    break;
+  case "uninstall":
+    uninstall();
+    break;
+  case "hook:session-start":
+    await runHook("session-start");
+    break;
+  case "hook:post-tool-use":
+    await runHook("post-tool-use");
+    break;
+  case "hook:stop":
+    await runHook("stop");
+    break;
+  case "hook:session-end":
+    await runHook("session-end");
+    break;
+  default:
+    console.log(`
+apsolut-cortex v0.1.0
+
+Commands:
+  init        Set up memory for this Claude Code project
+  status      Show memory stats for this project
+  uninstall   Remove hooks and MCP config (keeps DB)
+
+DB:     ~/.apsolut/memory.db
+Models: ~/.apsolut/models/
+`);
+}
+async function runHook(name) {
+  const hookPath = IS_DIST ? join2(__dirname2, "hooks", `${name}.js`) : join2(__dirname2, "hooks", `${name}.ts`);
+  if (!existsSync3(hookPath)) {
+    process.stderr.write(`[apsolut-cortex] hook not found: ${hookPath}
+`);
+    process.exit(0);
+  }
+  await import(hookPath);
+}
+async function init() {
+  console.log(`
+apsolut-cortex init
+`);
+  if (!existsSync3(PROJECT_APSOLUT)) {
+    mkdirSync2(PROJECT_APSOLUT, { recursive: true });
+  }
+  let projectId;
+  let projectName;
+  if (existsSync3(PROJECT_CONFIG)) {
+    const existing = JSON.parse(readFileSync2(PROJECT_CONFIG, "utf-8"));
+    projectId = existing.id;
+    projectName = existing.name;
+    console.log(`✓ Project already initialised: ${projectName}`);
+  } else {
+    projectId = crypto.randomUUID();
+    projectName = PROJECT_ROOT.split(/[\\/]/).filter(Boolean).pop() ?? "project";
+    writeFileSync2(PROJECT_CONFIG, JSON.stringify({
+      id: projectId,
+      name: projectName,
+      created_at: new Date().toISOString()
+    }, null, 2));
+    console.log(`✓ Created .apsolut/project.json`);
+    console.log(`  ID:   ${projectId}`);
+    console.log(`  Name: ${projectName}`);
+  }
+  registerProject(projectId, projectName, PROJECT_ROOT);
+  console.log(`✓ Registered in ~/.apsolut/registry.json`);
+  const mcpServerPath = IS_DIST ? join2(__dirname2, "mcp", "server.js") : join2(__dirname2, "mcp", "server.ts");
+  const mcpCommand = IS_DIST ? "node" : "bun";
+  const mcpArgs = [mcpServerPath];
+  let mcp = {};
+  if (existsSync3(MCP_JSON)) {
+    try {
+      mcp = JSON.parse(readFileSync2(MCP_JSON, "utf-8"));
+    } catch {}
+  }
+  const servers = mcp.mcpServers ?? {};
+  servers["apsolut-cortex"] = {
+    command: mcpCommand,
+    args: mcpArgs,
+    env: { APSOLUT_PROJECT_PATH: PROJECT_ROOT }
+  };
+  mcp.mcpServers = servers;
+  writeFileSync2(MCP_JSON, JSON.stringify(mcp, null, 2));
+  console.log(`✓ Written .mcp.json`);
+  const hookCmd = IS_DIST ? "apsolut-cortex" : `bun run ${join2(__dirname2, "cli.ts")}`;
+  const hookEntries = {
+    SessionStart: [{ command: `${hookCmd} hook:session-start` }],
+    PostToolUse: [{ command: `${hookCmd} hook:post-tool-use` }],
+    Stop: [{ command: `${hookCmd} hook:stop` }],
+    SessionEnd: [{ command: `${hookCmd} hook:session-end` }]
+  };
+  let settings = {};
+  const settingsDir = dirname(CLAUDE_SETTINGS);
+  if (!existsSync3(settingsDir))
+    mkdirSync2(settingsDir, { recursive: true });
+  if (existsSync3(CLAUDE_SETTINGS)) {
+    try {
+      settings = JSON.parse(readFileSync2(CLAUDE_SETTINGS, "utf-8"));
+    } catch {}
+  }
+  const existingHooks = settings.hooks ?? {};
+  let added = 0;
+  for (const [event, entries] of Object.entries(hookEntries)) {
+    const current = existingHooks[event] ?? [];
+    const alreadyRegistered = current.some((e) => typeof e === "object" && e.command?.includes("apsolut-cortex"));
+    if (!alreadyRegistered) {
+      existingHooks[event] = [...current, ...entries];
+      added++;
+    }
+  }
+  settings.hooks = existingHooks;
+  writeFileSync2(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
+  console.log(added > 0 ? `✓ Registered ${added} hooks in ~/.claude/settings.json` : `✓ Hooks already registered`);
+  const gitignore = join2(PROJECT_ROOT, ".gitignore");
+  if (existsSync3(gitignore)) {
+    const content = readFileSync2(gitignore, "utf-8");
+    if (!content.includes(".apsolut/")) {
+      writeFileSync2(gitignore, content + `
+# apsolut-cortex
+.apsolut/
+`);
+      console.log(`✓ Added .apsolut/ to .gitignore`);
+    }
+  }
+  const BANNER = `
+  ┌─────────────────────────────────────────────────────────┐
+  │                                                         │
+  │   █████╗ ██████╗ ███████╗ ██████╗ ██╗     ██╗   ██╗████████╗ │
+  │  ██╔══██╗██╔══██╗██╔════╝██╔═══██╗██║     ██║   ██║╚══██╔══╝ │
+  │  ███████║██████╔╝███████╗██║   ██║██║     ██║   ██║   ██║    │
+  │  ██╔══██║██╔═══╝ ╚════██║██║   ██║██║     ██║   ██║   ██║    │
+  │  ██║  ██║██║     ███████║╚██████╔╝███████╗╚██████╔╝   ██║    │
+  │  ╚═╝  ╚═╝╚═╝     ╚══════╝ ╚═════╝ ╚══════╝ ╚═════╝    ╚═╝    │
+  │                                                         │
+  │            c o r t e x  ·  v 0 . 1 . 0                 │
+  │                                                         │
+  └─────────────────────────────────────────────────────────┘
+
+  ✓  project    ${projectName}
+  ✓  id         ${projectId.slice(0, 18)}...
+  ✓  memory     ~/.apsolut/memory.db
+  ✓  models     ~/.apsolut/models/
+
+  ──────────────────────────────────────────────────────────
+
+  Restart Claude Code, then say "remember <topic>" to search.
+  compression: ANTHROPIC_API_KEY → ollama fallback → loud error
+
+`;
+  console.log(BANNER);
+}
+async function status() {
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  if (!existsSync3(PROJECT_CONFIG)) {
+    console.log("No project found. Run: apsolut-cortex init");
+    process.exit(1);
+  }
+  const project = JSON.parse(readFileSync2(PROJECT_CONFIG, "utf-8"));
+  const db = getDb2();
+  const total = db.prepare("SELECT COUNT(*) as n FROM memories WHERE project_id = ?").get(project.id).n;
+  const sessions = db.prepare("SELECT COUNT(*) as n FROM sessions WHERE project_id = ?").get(project.id).n;
+  const byTrust = db.prepare(`
+    SELECT trust, COUNT(*) as n FROM memories
+    WHERE project_id = ? GROUP BY trust
+  `).all(project.id);
+  const recent = db.prepare(`
+    SELECT summary, started_at FROM sessions
+    WHERE project_id = ? AND summary IS NOT NULL
+    ORDER BY started_at DESC LIMIT 3
+  `).all(project.id);
+  console.log(`
+apsolut-cortex — ${project.name}
+`);
+  console.log(`Memories : ${total} across ${sessions} sessions`);
+  byTrust.forEach((r) => console.log(`  ${r.trust}: ${r.n}`));
+  if (recent.length) {
+    console.log(`
+Recent sessions:`);
+    recent.forEach((r) => {
+      const age = Math.round((Date.now() - r.started_at) / 86400000);
+      console.log(`  ${age}d ago: ${r.summary}`);
+    });
+  }
+  console.log(`
+DB: ~/.apsolut/memory.db
+`);
+}
+function uninstall() {
+  if (existsSync3(MCP_JSON)) {
+    try {
+      const mcp = JSON.parse(readFileSync2(MCP_JSON, "utf-8"));
+      if (mcp.mcpServers?.["apsolut-cortex"]) {
+        delete mcp.mcpServers["apsolut-cortex"];
+        writeFileSync2(MCP_JSON, JSON.stringify(mcp, null, 2));
+        console.log("✓ Removed from .mcp.json");
+      }
+    } catch {}
+  }
+  if (existsSync3(CLAUDE_SETTINGS)) {
+    try {
+      const settings = JSON.parse(readFileSync2(CLAUDE_SETTINGS, "utf-8"));
+      const hooks = settings.hooks;
+      if (hooks) {
+        for (const event of ["SessionStart", "PostToolUse", "Stop", "SessionEnd"]) {
+          if (hooks[event]) {
+            hooks[event] = hooks[event].filter((e) => !(typeof e === "object" && e.command?.includes("apsolut-cortex")));
+          }
+        }
+        writeFileSync2(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
+        console.log("✓ Removed hooks from ~/.claude/settings.json");
+      }
+    } catch {}
+  }
+  console.log(`
+Uninstalled. DB at ~/.apsolut/memory.db kept.
+`);
+}