@plur-ai/core 0.3.1 → 0.4.1

package/dist/index.js

@@ -1,4 +1,792 @@
-import "./chunk-2ZDO52B4.js";
+import {
+  atomicWrite,
+  embeddingSearch,
+  engramSearchText,
+  ftsScore,
+  ftsTokenize,
+  getSyncStatus,
+  searchEngrams,
+  sync,
+  withLock
+} from "./chunk-KMVQYBNP.js";
+import {
+  __commonJS,
+  __require
+} from "./chunk-2ZDO52B4.js";
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js
+var require_util = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js"(exports) {
+    "use strict";
+    exports.getBooleanOption = (options, key) => {
+      let value = false;
+      if (key in options && typeof (value = options[key]) !== "boolean") {
+        throw new TypeError(`Expected the "${key}" option to be a boolean`);
+      }
+      return value;
+    };
+    exports.cppdb = /* @__PURE__ */ Symbol();
+    exports.inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/sqlite-error.js"(exports, module) {
+    "use strict";
+    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+    function SqliteError(message, code) {
+      if (new.target !== SqliteError) {
+        return new SqliteError(message, code);
+      }
+      if (typeof code !== "string") {
+        throw new TypeError("Expected second argument to be a string");
+      }
+      Error.call(this, message);
+      descriptor.value = "" + message;
+      Object.defineProperty(this, "message", descriptor);
+      Error.captureStackTrace(this, SqliteError);
+      this.code = code;
+    }
+    Object.setPrototypeOf(SqliteError, Error);
+    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+    Object.defineProperty(SqliteError.prototype, "name", descriptor);
+    module.exports = SqliteError;
+  }
+});
+
+// ../../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS({
+  "../../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js"(exports, module) {
+    "use strict";
+    var sep = __require("path").sep || "/";
+    module.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        throw new TypeError("must pass in a file:// URI to convert to a file path");
+      }
+      var rest = decodeURI(uri.substring(7));
+      var firstSlash = rest.indexOf("/");
+      var host = rest.substring(0, firstSlash);
+      var path2 = rest.substring(firstSlash + 1);
+      if ("localhost" == host) host = "";
+      if (host) {
+        host = sep + sep + host;
+      }
+      path2 = path2.replace(/^(.+)\|/, "$1:");
+      if (sep == "\\") {
+        path2 = path2.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path2)) {
+      } else {
+        path2 = sep + path2;
+      }
+      return host + path2;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js
+var require_bindings = __commonJS({
+  "../../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path2 = __require("path");
+    var fileURLToPath = require_file_uri_to_path();
+    var join3 = path2.join;
+    var dirname = path2.dirname;
+    var exists = fs3.accessSync && function(path3) {
+      try {
+        fs3.accessSync(path3);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    } || fs3.existsSync || path2.existsSync;
+    var defaults = {
+      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
+      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+      platform: process.platform,
+      arch: process.arch,
+      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+      version: process.versions.node,
+      bindings: "bindings.node",
+      try: [
+        // node-gyp's linked version in the "build" dir
+        ["module_root", "build", "bindings"],
+        // node-waf and gyp_addon (a.k.a node-gyp)
+        ["module_root", "build", "Debug", "bindings"],
+        ["module_root", "build", "Release", "bindings"],
+        // Debug files, for development (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Debug", "bindings"],
+        ["module_root", "Debug", "bindings"],
+        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Release", "bindings"],
+        ["module_root", "Release", "bindings"],
+        // Legacy from node-waf, node <= 0.4.x
+        ["module_root", "build", "default", "bindings"],
+        // Production "Release" buildtype binary (meh...)
+        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+        // node-qbs builds
+        ["module_root", "addon-build", "release", "install-root", "bindings"],
+        ["module_root", "addon-build", "debug", "install-root", "bindings"],
+        ["module_root", "addon-build", "default", "install-root", "bindings"],
+        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+      ]
+    };
+    function bindings(opts) {
+      if (typeof opts == "string") {
+        opts = { bindings: opts };
+      } else if (!opts) {
+        opts = {};
+      }
+      Object.keys(defaults).map(function(i2) {
+        if (!(i2 in opts)) opts[i2] = defaults[i2];
+      });
+      if (!opts.module_root) {
+        opts.module_root = exports.getRoot(exports.getFileName());
+      }
+      if (path2.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 = join3.apply(
+          null,
+          opts.try[i].map(function(p) {
+            return opts[p] || p;
+          })
+        );
+        tries.push(n);
+        try {
+          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+          if (!opts.path) {
+            b.path = n;
+          }
+          return b;
+        } catch (e) {
+          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
+            throw e;
+          }
+        }
+      }
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+          return opts.arrow + a;
+        }).join("\n")
+      );
+      err.tries = tries;
+      throw err;
+    }
+    module.exports = exports = bindings;
+    exports.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(e, st) {
+        for (var i = 0, l = st.length; i < l; i++) {
+          fileName = st[i].getFileName();
+          if (fileName !== __filename) {
+            if (calling_file) {
+              if (fileName !== calling_file) {
+                return;
+              }
+            } else {
+              return;
+            }
+          }
+        }
+      };
+      Error.captureStackTrace(dummy);
+      dummy.stack;
+      Error.prepareStackTrace = origPST;
+      Error.stackTraceLimit = origSTL;
+      var fileSchema = "file://";
+      if (fileName.indexOf(fileSchema) === 0) {
+        fileName = fileURLToPath(fileName);
+      }
+      return fileName;
+    };
+    exports.getRoot = function getRoot(file) {
+      var dir = dirname(file), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists(join3(dir, "package.json")) || exists(join3(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 = join3(dir, "..");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/wrappers.js"(exports) {
+    "use strict";
+    var { cppdb } = require_util();
+    exports.prepare = function prepare(sql) {
+      return this[cppdb].prepare(sql, this, false);
+    };
+    exports.exec = function exec(sql) {
+      this[cppdb].exec(sql);
+      return this;
+    };
+    exports.close = function close() {
+      this[cppdb].close();
+      return this;
+    };
+    exports.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
+    };
+    exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      return this;
+    };
+    exports.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
+    };
+    exports.getters = {
+      name: {
+        get: function name() {
+          return this[cppdb].name;
+        },
+        enumerable: true
+      },
+      open: {
+        get: function open() {
+          return this[cppdb].open;
+        },
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
+        },
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/transaction.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module.exports = function transaction(fn) {
+      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+      const db = this[cppdb];
+      const controller = getController(db, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    };
+    var getController = (db, self) => {
+      let controller = controllers.get(db);
+      if (!controller) {
+        const shared = {
+          commit: db.prepare("COMMIT", self, false),
+          rollback: db.prepare("ROLLBACK", self, false),
+          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db, controller = {
+          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
+      }
+      before.run();
+      try {
+        const result = apply.call(fn, this, arguments);
+        if (result && typeof result.then === "function") {
+          throw new TypeError("Transaction function cannot return a promise");
+        }
+        after.run();
+        return result;
+      } catch (ex) {
+        if (db.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/pragma.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function pragma(source, options) {
+      if (options == null) options = {};
+      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      const simple = getBooleanOption(options, "simple");
+      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path2 = __require("path");
+    var { promisify } = __require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify(fs3.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(path2.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 !== void 0) {
+                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+                else throw new TypeError("Expected progress callback to return a number or undefined");
+              }
+            }
+            setImmediate(step);
+          } catch (err) {
+            backup.close();
+            reject(err);
+          }
+        });
+      });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function serialize(options) {
+      if (options == null) options = {};
+      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
+      const attachedName = "attached" in options ? options.attached : "main";
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      return this[cppdb].serialize(attachedName);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/function.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineFunction(name, options, fn) {
+      if (options == null) options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = fn.length;
+        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/aggregate.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineAggregate(name, options) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const start = "start" in options ? options.start : null;
+      const step = getFunctionOption(options, "step", true);
+      const inverse = getFunctionOption(options, "inverse", false);
+      const result = getFunctionOption(options, "result", false);
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+        if (argCount > 0) argCount -= 1;
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, required) => {
+      const value = key in options ? options[key] : null;
+      if (typeof value === "function") return value;
+      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+      if (required) throw new TypeError(`Missing required option "${key}"`);
+      return null;
+    };
+    var getLength = ({ length }) => {
+      if (Number.isInteger(length) && length >= 0) return length;
+      throw new TypeError("Expected function.length to be a positive integer");
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/table.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function defineTable(name, factory) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
+      let eponymous = false;
+      if (typeof factory === "object" && factory !== null) {
+        eponymous = true;
+        factory = defer(parseTableDefinition(factory, "used", name));
+      } else {
+        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
+        factory = wrapFactory(factory);
+      }
+      this[cppdb].table(factory, name, eponymous);
+      return this;
+    };
+    function wrapFactory(factory) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.call(factory, thisObject, args);
+        if (typeof def !== "object" || def === null) {
+          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+        }
+        return parseTableDefinition(def, "returned", moduleName);
+      };
+    }
+    function parseTableDefinition(def, verb, moduleName) {
+      if (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+      }
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+      }
+      const rows = def.rows;
+      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+      }
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+      }
+      if (columns.length !== new Set(columns).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+      }
+      if (!columns.length) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+      }
+      let parameters;
+      if (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+        }
+      } else {
+        parameters = inferParameters(rows);
+      }
+      if (parameters.length !== new Set(parameters).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+      }
+      if (parameters.length > 32) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+      }
+      for (const parameter of parameters) {
+        if (columns.includes(parameter)) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+        }
+      }
+      let safeIntegers = 2;
+      if (hasOwnProperty.call(def, "safeIntegers")) {
+        const bool = def.safeIntegers;
+        if (typeof bool !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+        }
+        safeIntegers = +bool;
+      }
+      let directOnly = false;
+      if (hasOwnProperty.call(def, "directOnly")) {
+        directOnly = def.directOnly;
+        if (typeof directOnly !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+        }
+      }
+      const columnDefinitions = [
+        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
+        ...columns.map(identifier)
+      ];
+      return [
+        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+        wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
+    }
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+        for (let i = 0; i < columnMap.size; ++i) {
+          output.push(null);
+        }
+        for (const row of generator(...args)) {
+          if (Array.isArray(row)) {
+            extractRowArray(row, output, columnMap.size, moduleName);
+            yield output;
+          } else if (typeof row === "object" && row !== null) {
+            extractRowObject(row, output, columnMap, moduleName);
+            yield output;
+          } else {
+            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+          }
+        }
+      };
+    }
+    function extractRowArray(row, output, columnCount, moduleName) {
+      if (row.length !== columnCount) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+      }
+      const offset = output.length - columnCount;
+      for (let i = 0; i < columnCount; ++i) {
+        output[i + offset] = row[i];
+      }
+    }
+    function extractRowObject(row, output, columnMap, moduleName) {
+      let count = 0;
+      for (const key of Object.keys(row)) {
+        const index = columnMap.get(key);
+        if (index === void 0) {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+        }
+        output[index] = row[key];
+        count += 1;
+      }
+      if (count !== columnMap.size) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+      }
+    }
+    function inferParameters({ length }) {
+      if (!Number.isInteger(length) || length < 0) {
+        throw new TypeError("Expected function.length to be a positive integer");
+      }
+      const params = [];
+      for (let i = 0; i < length; ++i) {
+        params.push(`$${i + 1}`);
+      }
+      return params;
+    }
+    var { hasOwnProperty } = Object.prototype;
+    var { apply } = Function.prototype;
+    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
+    });
+    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+    var defer = (x) => () => x;
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/inspect.js"(exports, module) {
+    "use strict";
+    var DatabaseInspection = function Database2() {
+    };
+    module.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/database.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path2 = __require("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database2(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database2(filenameGiven, options);
+      }
+      let buffer;
+      if (Buffer.isBuffer(filenameGiven)) {
+        buffer = filenameGiven;
+        filenameGiven = ":memory:";
+      }
+      if (filenameGiven == null) filenameGiven = "";
+      if (options == null) options = {};
+      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+      const filename = filenameGiven.trim();
+      const anonymous = filename === "" || filename === ":memory:";
+      const readonly = util.getBooleanOption(options, "readonly");
+      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
+      const timeout = "timeout" in options ? options.timeout : 5e3;
+      const verbose = "verbose" in options ? options.verbose : null;
+      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+      if (readonly && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
+      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
+      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
+      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+      let addon;
+      if (nativeBinding == null) {
+        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+      } else if (typeof nativeBinding === "string") {
+        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
+        addon = requireFunc(path2.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
+      }
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
+      }
+      if (!anonymous && !fs3.existsSync(path2.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
+      }
+      Object.defineProperties(this, {
+        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
+        ...wrappers.getters
+      });
+    }
+    var wrappers = require_wrappers();
+    Database2.prototype.prepare = wrappers.prepare;
+    Database2.prototype.transaction = require_transaction();
+    Database2.prototype.pragma = require_pragma();
+    Database2.prototype.backup = require_backup();
+    Database2.prototype.serialize = require_serialize();
+    Database2.prototype.function = require_function();
+    Database2.prototype.aggregate = require_aggregate();
+    Database2.prototype.table = require_table();
+    Database2.prototype.loadExtension = wrappers.loadExtension;
+    Database2.prototype.exec = wrappers.exec;
+    Database2.prototype.close = wrappers.close;
+    Database2.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database2.prototype.unsafeMode = wrappers.unsafeMode;
+    Database2.prototype[util.inspect] = require_inspect();
+    module.exports = Database2;
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_database();
+    module.exports.SqliteError = require_sqlite_error();
+  }
+});
 
 // src/storage.ts
 import { existsSync, mkdirSync } from "fs";
@@ -16,97 +804,70 @@ function detectPlurStorage(explicitPath) {
     candidates: join(root, "candidates.yaml"),
     packs: packsDir,
     exchange: join(root, "exchange"),
-    config: join(root, "config.yaml")
+    config: join(root, "config.yaml"),
+    db: join(root, "engrams.db")
   };
 }
 
-// src/config.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import yaml from "js-yaml";
-
-// src/schemas/config.ts
-import { z } from "zod";
-var PlurConfigSchema = z.object({
-  auto_learn: z.boolean().default(true),
-  auto_capture: z.boolean().default(true),
-  injection_budget: z.number().default(2e3),
-  decay_enabled: z.boolean().default(true),
-  decay_threshold: z.number().default(0.15),
-  packs: z.array(z.string()).default([]),
-  injection: z.object({
-    spread_cap: z.number().default(3),
-    spread_budget: z.number().default(480),
-    co_access: z.boolean().default(true)
-  }).default({})
-}).partial();
-
-// src/config.ts
-function loadConfig(configPath) {
-  if (!existsSync2(configPath)) return PlurConfigSchema.parse({});
-  try {
-    const raw = yaml.load(readFileSync(configPath, "utf8"));
-    return PlurConfigSchema.parse(raw ?? {});
-  } catch {
-    return PlurConfigSchema.parse({});
-  }
-}
+// src/storage-indexed.ts
+import { existsSync as existsSync3 } from "fs";
 
 // src/engrams.ts
 import * as fs from "fs";
-import * as yaml2 from "js-yaml";
+import * as yaml from "js-yaml";
 
 // src/schemas/engram.ts
-import { z as z2 } from "zod";
-var ActivationSchema = z2.object({
-  retrieval_strength: z2.number().min(0).max(1),
-  storage_strength: z2.number().min(0).max(1),
-  frequency: z2.number().int().min(0),
-  last_accessed: z2.string()
+import { z } from "zod";
+var ActivationSchema = z.object({
+  retrieval_strength: z.number().min(0).max(1),
+  storage_strength: z.number().min(0).max(1),
+  frequency: z.number().int().min(0),
+  last_accessed: z.string()
 });
-var KnowledgeTypeSchema = z2.object({
-  memory_class: z2.enum(["semantic", "episodic", "procedural", "metacognitive"]),
-  cognitive_level: z2.enum(["remember", "understand", "apply", "analyze", "evaluate", "create"])
+var KnowledgeTypeSchema = z.object({
+  memory_class: z.enum(["semantic", "episodic", "procedural", "metacognitive"]),
+  cognitive_level: z.enum(["remember", "understand", "apply", "analyze", "evaluate", "create"])
 });
-var KnowledgeAnchorSchema = z2.object({
-  path: z2.string(),
-  relevance: z2.enum(["primary", "supporting", "example"]).default("supporting"),
-  snippet: z2.string().max(200).optional(),
-  snippet_extracted_at: z2.string().optional()
+var KnowledgeAnchorSchema = z.object({
+  path: z.string(),
+  relevance: z.enum(["primary", "supporting", "example"]).default("supporting"),
+  snippet: z.string().max(200).optional(),
+  snippet_extracted_at: z.string().optional()
 });
-var AssociationSchema = z2.object({
-  target_type: z2.enum(["engram", "document"]),
-  target: z2.string(),
-  strength: z2.number().min(0).max(0.95),
-  type: z2.enum(["semantic", "temporal", "causal", "co_accessed"]),
-  updated_at: z2.string().optional()
+var AssociationSchema = z.object({
+  target_type: z.enum(["engram", "document"]),
+  target: z.string(),
+  strength: z.number().min(0).max(0.95),
+  type: z.enum(["semantic", "temporal", "causal", "co_accessed"]),
+  updated_at: z.string().optional()
 });
-var DualCodingSchema = z2.object({
-  example: z2.string().optional(),
-  analogy: z2.string().optional()
+var DualCodingSchema = z.object({
+  example: z.string().optional(),
+  analogy: z.string().optional()
 }).refine(
   (d) => d.example || d.analogy,
   "At least one of example or analogy must be provided"
 );
-var RelationsSchema = z2.object({
-  broader: z2.array(z2.string()).default([]),
-  narrower: z2.array(z2.string()).default([]),
-  related: z2.array(z2.string()).default([]),
-  conflicts: z2.array(z2.string()).default([])
+var RelationsSchema = z.object({
+  broader: z.array(z.string()).default([]),
+  narrower: z.array(z.string()).default([]),
+  related: z.array(z.string()).default([]),
+  conflicts: z.array(z.string()).default([])
 });
-var ProvenanceSchema = z2.object({
-  origin: z2.string(),
-  chain: z2.array(z2.string()).default([]),
-  signature: z2.string().nullable().default(null),
-  license: z2.string().default("cc-by-sa-4.0")
+var ProvenanceSchema = z.object({
+  origin: z.string(),
+  chain: z.array(z.string()).default([]),
+  signature: z.string().nullable().default(null),
+  license: z.string().default("cc-by-sa-4.0")
 });
-var FeedbackSignalsSchema = z2.object({
-  positive: z2.number().int().default(0),
-  negative: z2.number().int().default(0),
-  neutral: z2.number().int().default(0)
+var FeedbackSignalsSchema = z.object({
+  positive: z.number().int().default(0),
+  negative: z.number().int().default(0),
+  neutral: z.number().int().default(0)
 });
-var EntityRefSchema = z2.object({
-  name: z2.string(),
-  type: z2.enum([
+var EntityRefSchema = z.object({
+  name: z.string(),
+  type: z.enum([
     "person",
     "organization",
     "technology",
@@ -118,56 +879,56 @@ var EntityRefSchema = z2.object({
     "standard",
     "other"
   ]),
-  uri: z2.string().url().optional()
+  uri: z.string().url().optional()
 });
-var TemporalSchema = z2.object({
-  learned_at: z2.string(),
-  valid_from: z2.string().optional(),
-  valid_until: z2.string().optional(),
-  ingested_at: z2.string().optional()
+var TemporalSchema = z.object({
+  learned_at: z.string(),
+  valid_from: z.string().optional(),
+  valid_until: z.string().optional(),
+  ingested_at: z.string().optional()
 });
-var UsageStatsSchema = z2.object({
-  injections: z2.number().int().default(0),
-  hits: z2.number().int().default(0),
-  misses: z2.number().int().default(0),
-  last_hit_at: z2.string().optional()
+var UsageStatsSchema = z.object({
+  injections: z.number().int().default(0),
+  hits: z.number().int().default(0),
+  misses: z.number().int().default(0),
+  last_hit_at: z.string().optional()
 });
-var EpisodicFieldsSchema = z2.object({
-  emotional_weight: z2.number().int().min(1).max(10).default(5),
-  confidence: z2.number().int().min(1).max(10).default(5),
-  trigger_context: z2.string().optional(),
-  journal_ref: z2.string().optional()
+var EpisodicFieldsSchema = z.object({
+  emotional_weight: z.number().int().min(1).max(10).default(5),
+  confidence: z.number().int().min(1).max(10).default(5),
+  trigger_context: z.string().optional(),
+  journal_ref: z.string().optional()
 });
-var ExchangeMetadataSchema = z2.object({
-  fitness_score: z2.number().min(0).max(1).optional(),
-  environmental_diversity: z2.number().int().default(0),
-  adoption_count: z2.number().int().default(0),
-  contradiction_rate: z2.number().min(0).max(1).default(0)
+var ExchangeMetadataSchema = z.object({
+  fitness_score: z.number().min(0).max(1).optional(),
+  environmental_diversity: z.number().int().default(0),
+  adoption_count: z.number().int().default(0),
+  contradiction_rate: z.number().min(0).max(1).default(0)
 });
-var EngramSchema = z2.object({
+var EngramSchema = z.object({
   // Identity
-  id: z2.string().regex(/^(ENG|ABS)-[A-Za-z0-9-]+$/),
-  version: z2.number().int().min(1).default(2),
-  status: z2.enum(["active", "dormant", "retired", "candidate"]),
-  consolidated: z2.boolean().default(false),
-  type: z2.enum(["behavioral", "terminological", "procedural", "architectural"]),
-  scope: z2.string(),
-  visibility: z2.enum(["private", "public", "template"]).default("private"),
+  id: z.string().regex(/^(ENG|ABS|META)-[A-Za-z0-9-]+$/),
+  version: z.number().int().min(1).default(2),
+  status: z.enum(["active", "dormant", "retired", "candidate"]),
+  consolidated: z.boolean().default(false),
+  type: z.enum(["behavioral", "terminological", "procedural", "architectural"]),
+  scope: z.string(),
+  visibility: z.enum(["private", "public", "template"]).default("private"),
   // Content
-  statement: z2.string().min(1),
-  rationale: z2.string().optional(),
-  contraindications: z2.array(z2.string()).optional(),
+  statement: z.string().min(1),
+  rationale: z.string().optional(),
+  contraindications: z.array(z.string()).optional(),
   // Lineage
-  source: z2.string().optional(),
-  source_patterns: z2.array(z2.string()).optional(),
-  derivation_count: z2.number().int().min(0).default(1),
-  pack: z2.string().nullable().default(null),
-  abstract: z2.string().nullable().default(null),
-  derived_from: z2.string().nullable().default(null),
+  source: z.string().optional(),
+  source_patterns: z.array(z.string()).optional(),
+  derivation_count: z.number().int().min(0).default(1),
+  pack: z.string().nullable().default(null),
+  abstract: z.string().nullable().default(null),
+  derived_from: z.string().nullable().default(null),
   // Classification
   knowledge_type: KnowledgeTypeSchema.optional(),
-  domain: z2.string().optional(),
-  tags: z2.array(z2.string()).default([]),
+  domain: z.string().optional(),
+  tags: z.array(z.string()).default([]),
   // Activation (ACT-R model)
   activation: ActivationSchema.default({
     retrieval_strength: 0.7,
@@ -177,8 +938,8 @@ var EngramSchema = z2.object({
   }),
   // Relations & grounding
   relations: RelationsSchema.optional(),
-  associations: z2.array(AssociationSchema).default([]),
-  knowledge_anchors: z2.array(KnowledgeAnchorSchema).default([]),
+  associations: z.array(AssociationSchema).default([]),
+  knowledge_anchors: z.array(KnowledgeAnchorSchema).default([]),
   dual_coding: DualCodingSchema.optional(),
   // Provenance
   provenance: ProvenanceSchema.optional(),
@@ -186,7 +947,7 @@ var EngramSchema = z2.object({
   feedback_signals: FeedbackSignalsSchema.default({ positive: 0, negative: 0, neutral: 0 }),
   // === NEW OPTIONAL FIELDS (v2.1) ===
   /** Typed entity references extracted from statement. Enables graph queries. */
-  entities: z2.array(EntityRefSchema).optional(),
+  entities: z.array(EntityRefSchema).optional(),
   /** Temporal validity window. When is this knowledge true? */
   temporal: TemporalSchema.optional(),
   /** Automatic usage tracking. Injections, hits, misses. */
@@ -196,31 +957,33 @@ var EngramSchema = z2.object({
   /** Exchange marketplace metadata: fitness, adoption, diversity. */
   exchange: ExchangeMetadataSchema.optional(),
   /** Extensible key-value data for domain-specific fields. */
-  structured_data: z2.record(z2.string(), z2.unknown()).optional()
+  structured_data: z.record(z.string(), z.unknown()).optional(),
+  /** Polarity classification: 'do' for directives, 'dont' for prohibitions, null for unclassified. */
+  polarity: z.enum(["do", "dont"]).nullable().default(null)
 });
 
 // src/schemas/pack.ts
-import { z as z3 } from "zod";
-var PackManifestSchema = z3.object({
-  name: z3.string(),
-  version: z3.string(),
-  description: z3.string().optional(),
-  creator: z3.string().optional(),
-  license: z3.string().default("cc-by-sa-4.0"),
-  tags: z3.array(z3.string()).default([]),
-  metadata: z3.object({
-    id: z3.string().optional(),
-    injection_policy: z3.enum(["on_match", "on_request", "always"]).default("on_match"),
-    match_terms: z3.array(z3.string()).default([]),
-    domain: z3.string().optional(),
-    engram_count: z3.number().optional()
+import { z as z2 } from "zod";
+var PackManifestSchema = z2.object({
+  name: z2.string(),
+  version: z2.string(),
+  description: z2.string().optional(),
+  creator: z2.string().optional(),
+  license: z2.string().default("cc-by-sa-4.0"),
+  tags: z2.array(z2.string()).default([]),
+  metadata: z2.object({
+    id: z2.string().optional(),
+    injection_policy: z2.enum(["on_match", "on_request", "always"]).default("on_match"),
+    match_terms: z2.array(z2.string()).default([]),
+    domain: z2.string().optional(),
+    engram_count: z2.number().optional()
   }).optional(),
-  "x-datacore": z3.object({
-    id: z3.string(),
-    injection_policy: z3.enum(["on_match", "on_request"]),
-    match_terms: z3.array(z3.string()).default([]),
-    domain: z3.string().optional(),
-    engram_count: z3.number().int().min(0)
+  "x-datacore": z2.object({
+    id: z2.string(),
+    injection_policy: z2.enum(["on_match", "on_request"]),
+    match_terms: z2.array(z2.string()).default([]),
+    domain: z2.string().optional(),
+    engram_count: z2.number().int().min(0)
   }).optional()
 });
 
@@ -243,173 +1006,11 @@ var logger = {
   }
 };
 
-// src/sync.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync3, writeFileSync, renameSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2, dirname } from "path";
-var GITIGNORE = `# PLUR \u2014 derived/cache files (regenerated automatically)
-embeddings/
-.embeddings-cache.json
-*.db
-*.sqlite
-exchange/
-`;
-function git(args, cwd) {
-  return execFileSync("git", args, { cwd, encoding: "utf8", timeout: 3e4 }).trim();
-}
-function gitSafe(args, cwd) {
-  try {
-    return git(args, cwd);
-  } catch {
-    return null;
-  }
-}
-function isGitRepo(root) {
-  return existsSync3(join2(root, ".git"));
-}
-function hasGitCli() {
-  try {
-    execFileSync("git", ["--version"], { encoding: "utf8", timeout: 5e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getRemote(root) {
-  return gitSafe(["remote", "get-url", "origin"], root);
-}
-function isDirty(root) {
-  const status = gitSafe(["status", "--porcelain"], root);
-  return status !== null && status.length > 0;
-}
-function countDiff(root, direction) {
-  const tracking = gitSafe(["rev-parse", "--abbrev-ref", "@{u}"], root);
-  if (!tracking) return 0;
-  const flag = direction === "ahead" ? "--left-only" : "--right-only";
-  const count = gitSafe(["rev-list", flag, "--count", "HEAD...@{u}"], root);
-  return count ? parseInt(count, 10) : 0;
-}
-function getSyncStatus(root) {
-  if (!isGitRepo(root)) {
-    return { initialized: false, remote: null, dirty: false, branch: null, ahead: 0, behind: 0 };
-  }
-  const branch = gitSafe(["rev-parse", "--abbrev-ref", "HEAD"], root);
-  const remote = getRemote(root);
-  if (remote) gitSafe(["fetch", "origin", "--quiet"], root);
-  return {
-    initialized: true,
-    remote,
-    dirty: isDirty(root),
-    branch,
-    ahead: countDiff(root, "ahead"),
-    behind: countDiff(root, "behind")
-  };
-}
-function initRepo(root) {
-  git(["init"], root);
-  atomicWrite(join2(root, ".gitignore"), GITIGNORE);
-  git(["add", "-A"], root);
-  git(["commit", "-m", "Initial PLUR engram store"], root);
-}
-function commitChanges(root) {
-  if (!isDirty(root)) return 0;
-  git(["add", "-A"], root);
-  const diff = gitSafe(["diff", "--cached", "--stat", "--shortstat"], root);
-  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
-  git(["commit", "-m", `plur sync ${now}`], root);
-  const match = diff?.match(/(\d+) file/);
-  return match ? parseInt(match[1], 10) : 1;
-}
-function hasConflictMarkers(root) {
-  const result = gitSafe(["grep", "-l", "<<<<<<<"], root);
-  return result !== null && result.length > 0;
-}
-function pullRebase(root) {
-  const result = gitSafe(["pull", "--rebase", "origin", "main"], root);
-  if (result !== null) return true;
-  gitSafe(["rebase", "--abort"], root);
-  const mergeResult = gitSafe(["pull", "origin", "main", "--no-edit"], root);
-  if (mergeResult !== null) return true;
-  if (hasConflictMarkers(root)) {
-    gitSafe(["merge", "--abort"], root);
-    throw new Error("Sync conflict: YAML files have merge conflicts that require manual resolution. Your local changes are preserved.");
-  }
-  git(["add", "-A"], root);
-  gitSafe(["commit", "-m", "plur sync: merge conflict resolved (kept both)"], root);
-  return true;
-}
-function sync(root, remote) {
-  if (!hasGitCli()) {
-    throw new Error("git is not installed. Install git to enable sync.");
-  }
-  if (!isGitRepo(root)) {
-    initRepo(root);
-    if (remote) {
-      git(["remote", "add", "origin", remote], root);
-      const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], root);
-      git(["push", "-u", "origin", branch], root);
-      return { action: "initialized", message: `Initialized and pushed to ${remote}`, remote, files_changed: 0 };
-    }
-    return {
-      action: "initialized",
-      message: "Initialized local git repo. Call plur.sync with remote to enable cross-device sync.",
-      remote: null,
-      files_changed: 0
-    };
-  }
-  const existingRemote = getRemote(root);
-  if (remote && !existingRemote) {
-    git(["remote", "add", "origin", remote], root);
-    const filesChanged2 = commitChanges(root);
-    const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], root);
-    git(["push", "-u", "origin", branch], root);
-    return { action: "synced", message: `Remote added and pushed to ${remote}`, remote, files_changed: filesChanged2 };
-  }
-  if (!existingRemote) {
-    const filesChanged2 = commitChanges(root);
-    if (filesChanged2 === 0) {
-      return { action: "up-to-date", message: 'No changes to commit. Add a remote with plur.sync({ remote: "..." }) to enable cross-device sync.', remote: null, files_changed: 0 };
-    }
-    return { action: "committed", message: `Committed ${filesChanged2} file(s) locally.`, remote: null, files_changed: filesChanged2 };
-  }
-  const filesChanged = commitChanges(root);
-  gitSafe(["fetch", "origin", "--quiet"], root);
-  const behind = countDiff(root, "behind");
-  const aheadBefore = countDiff(root, "ahead");
-  if (behind > 0) {
-    pullRebase(root);
-  }
-  const aheadAfter = countDiff(root, "ahead");
-  if (aheadAfter > 0) {
-    gitSafe(["push", "origin"], root);
-  }
-  if (filesChanged === 0 && behind === 0 && aheadBefore === 0) {
-    return { action: "up-to-date", message: "Already in sync.", remote: existingRemote, files_changed: 0 };
-  }
-  const parts = [];
-  if (filesChanged > 0) parts.push(`${filesChanged} file(s) committed`);
-  if (behind > 0) parts.push(`pulled ${behind} remote commit(s)`);
-  if (aheadAfter === 0 && aheadBefore > 0) parts.push("pushed");
-  return {
-    action: "synced",
-    message: `Synced. ${parts.join(", ")}.`,
-    remote: existingRemote,
-    files_changed: filesChanged
-  };
-}
-function atomicWrite(filePath, content) {
-  const dir = dirname(filePath);
-  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
-  const tmp = filePath + ".tmp";
-  writeFileSync(tmp, content);
-  renameSync(tmp, filePath);
-}
-
 // src/engrams.ts
 function loadEngrams(filePath) {
   if (!fs.existsSync(filePath)) return [];
   try {
-    const raw = yaml2.load(fs.readFileSync(filePath, "utf8"));
+    const raw = yaml.load(fs.readFileSync(filePath, "utf8"));
     if (!raw?.engrams || !Array.isArray(raw.engrams)) return [];
     const valid = [];
     let skipped = 0;
@@ -426,14 +1027,14 @@ function loadEngrams(filePath) {
   }
 }
 function saveEngrams(filePath, engrams) {
-  const content = yaml2.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  const content = yaml.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
   atomicWrite(filePath, content);
 }
 function parseSkillMdFrontmatter(filePath) {
   const content = fs.readFileSync(filePath, "utf8");
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) throw new Error(`No frontmatter found in ${filePath}`);
-  return yaml2.load(match[1]);
+  return yaml.load(match[1]);
 }
 function loadPack(packDir) {
   const skillMdPath = `${packDir}/SKILL.md`;
@@ -443,7 +1044,7 @@ function loadPack(packDir) {
   if (fs.existsSync(skillMdPath)) {
     rawManifest = parseSkillMdFrontmatter(skillMdPath);
   } else if (fs.existsSync(manifestYamlPath)) {
-    rawManifest = yaml2.load(fs.readFileSync(manifestYamlPath, "utf8"));
+    rawManifest = yaml.load(fs.readFileSync(manifestYamlPath, "utf8"));
   } else {
     throw new Error(`No SKILL.md or manifest.yaml found in ${packDir}`);
   }
@@ -475,66 +1076,163 @@ function generateEngramId(existing) {
   return `${prefix}${String(next).padStart(3, "0")}`;
 }
 
-// src/fts.ts
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "the",
-  "and",
-  "for",
-  "that",
-  "this",
-  "with",
-  "from",
-  "are",
-  "was",
-  "were",
-  "been",
-  "have",
-  "has",
-  "not",
-  "but",
-  "its",
-  "you",
-  "your",
-  "can",
-  "will",
-  "should",
-  "would",
-  "could",
-  "may",
-  "might"
-]);
-function ftsTokenize(text) {
-  return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2).filter((w) => !STOP_WORDS.has(w));
-}
-function engramSearchText(engram) {
-  const parts = [engram.statement];
-  if (engram.domain) parts.push(engram.domain.replace(/\./g, " "));
-  if (engram.tags.length > 0) parts.push(engram.tags.join(" "));
-  if (engram.entities) {
-    for (const e of engram.entities) {
-      parts.push(e.name);
-      if (e.type !== "other") parts.push(e.type);
-    }
-  }
-  if (engram.temporal) {
-    if (engram.temporal.valid_from) parts.push(engram.temporal.valid_from);
-    if (engram.temporal.valid_until) parts.push(engram.temporal.valid_until);
-  }
-  if (engram.rationale) parts.push(engram.rationale);
-  return parts.join(" ");
-}
-function ftsScore(engram, queryTokens) {
-  const allTerms = ftsTokenize(engramSearchText(engram));
-  let matches = 0;
-  for (const qt of queryTokens) {
-    if (allTerms.some((t) => t.includes(qt) || qt.includes(t))) matches++;
+// src/storage-indexed.ts
+var Database = null;
+function getDatabase() {
+  if (!Database) {
+    try {
+      Database = require_lib();
+    } catch {
+      throw new Error(
+        "better-sqlite3 is required for index: true. Install it with: npm install better-sqlite3"
+      );
+    }
+  }
+  return Database;
+}
+var IndexedStorage = class {
+  dbPath;
+  engramsPath;
+  db = null;
+  constructor(engramsPath, dbPath) {
+    this.engramsPath = engramsPath;
+    this.dbPath = dbPath;
+  }
+  getDb() {
+    if (!this.db) {
+      const DB = getDatabase();
+      this.db = new DB(this.dbPath);
+      this.db.pragma("journal_mode = WAL");
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS engrams (
+          id TEXT PRIMARY KEY,
+          status TEXT NOT NULL,
+          scope TEXT NOT NULL,
+          domain TEXT,
+          last_accessed TEXT,
+          data TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_status ON engrams(status);
+        CREATE INDEX IF NOT EXISTS idx_scope ON engrams(scope);
+        CREATE INDEX IF NOT EXISTS idx_domain ON engrams(domain);
+      `);
+    }
+    return this.db;
+  }
+  /** Load all engrams from SQLite index. Auto-rebuilds if db missing. */
+  loadAll() {
+    if (!existsSync3(this.dbPath)) {
+      this.reindex();
+    }
+    const db = this.getDb();
+    const rows = db.prepare("SELECT data FROM engrams").all();
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  /** Load engrams with SQL-level filtering. */
+  loadFiltered(filter) {
+    if (!existsSync3(this.dbPath)) {
+      this.reindex();
+    }
+    const db = this.getDb();
+    const conditions = [];
+    const params = [];
+    if (filter.status) {
+      conditions.push("status = ?");
+      params.push(filter.status);
+    }
+    if (filter.scope) {
+      conditions.push("(scope = 'global' OR scope = ? OR scope LIKE ? || '%')");
+      params.push(filter.scope, filter.scope);
+    }
+    if (filter.domain) {
+      conditions.push("domain LIKE ? || '%'");
+      params.push(filter.domain);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = db.prepare(`SELECT data FROM engrams ${where}`).all(...params);
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  /** Count engrams with optional status filter. */
+  count(filter) {
+    if (!existsSync3(this.dbPath)) {
+      this.reindex();
+    }
+    const db = this.getDb();
+    if (filter?.status) {
+      return db.prepare("SELECT COUNT(*) as c FROM engrams WHERE status = ?").get(filter.status).c;
+    }
+    return db.prepare("SELECT COUNT(*) as c FROM engrams").get().c;
+  }
+  /** Sync SQLite index from YAML source of truth. */
+  syncFromYaml() {
+    const engrams = loadEngrams(this.engramsPath);
+    const db = this.getDb();
+    const upsert = db.prepare(`
+      INSERT OR REPLACE INTO engrams (id, status, scope, domain, last_accessed, data)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    const deleteStmt = db.prepare("DELETE FROM engrams WHERE id = ?");
+    const yamlIds = new Set(engrams.map((e) => e.id));
+    const dbIds = new Set(
+      db.prepare("SELECT id FROM engrams").all().map((r) => r.id)
+    );
+    const tx = db.transaction(() => {
+      for (const e of engrams) {
+        upsert.run(e.id, e.status, e.scope, e.domain ?? null, e.activation.last_accessed, JSON.stringify(e));
+      }
+      for (const id of dbIds) {
+        if (!yamlIds.has(id)) deleteStmt.run(id);
+      }
+    });
+    tx();
+  }
+  /** Drop and rebuild the entire index from YAML. */
+  reindex() {
+    this.close();
+    const db = this.getDb();
+    db.exec("DELETE FROM engrams");
+    this.syncFromYaml();
+  }
+  /** Close the database connection. */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+};
+
+// src/config.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import yaml2 from "js-yaml";
+
+// src/schemas/config.ts
+import { z as z3 } from "zod";
+var PlurConfigSchema = z3.object({
+  auto_learn: z3.boolean().default(true),
+  auto_capture: z3.boolean().default(true),
+  injection_budget: z3.number().default(2e3),
+  decay_enabled: z3.boolean().default(true),
+  decay_threshold: z3.number().default(0.15),
+  packs: z3.array(z3.string()).default([]),
+  injection: z3.object({
+    spread_cap: z3.number().default(3),
+    spread_budget: z3.number().default(480),
+    co_access: z3.boolean().default(true)
+  }).default({}),
+  allow_secrets: z3.boolean().default(false),
+  index: z3.boolean().default(false)
+}).partial();
+
+// src/config.ts
+function loadConfig(configPath) {
+  if (!existsSync4(configPath)) return PlurConfigSchema.parse({});
+  try {
+    const raw = yaml2.load(readFileSync2(configPath, "utf8"));
+    return PlurConfigSchema.parse(raw ?? {});
+  } catch {
+    return PlurConfigSchema.parse({});
   }
-  return queryTokens.length > 0 ? matches / queryTokens.length : 0;
-}
-function searchEngrams(engrams, query, limit = 20) {
-  const queryTokens = ftsTokenize(query);
-  if (queryTokens.length === 0) return [];
-  return engrams.map((e) => ({ engram: e, score: ftsScore(e, queryTokens) })).filter((r) => r.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((r) => r.engram);
 }
 
 // src/decay.ts
@@ -557,6 +1255,53 @@ function decayedCoAccessStrength(strength, daysSinceUpdate, lambda = 0.01) {
   return floor + (strength - floor) * Math.exp(-lambda * daysSinceUpdate);
 }
 
+// src/polarity.ts
+var DONT_PATTERNS = [
+  /\bnever\b/i,
+  /\bdo\s+not\b/i,
+  /\bdon'?t\b/i,
+  /\bavoid\b/i,
+  /\bmust\s+not\b/i,
+  /\bshould\s+not\b/i,
+  /\bNOT\b.*?\b(?:include|use|run|start|create|add|send|describe|reference|assume)\b/,
+  /\bstop\b.*?\b(?:generating|iterating|doing|running|creating)\b/i
+];
+function classifyPolarity(statement) {
+  if (!statement || statement.length < 5) return null;
+  const dotIndex = statement.indexOf(".");
+  const firstSentence = statement.slice(0, dotIndex > 0 ? Math.min(dotIndex, 200) : 200);
+  for (const pattern of DONT_PATTERNS) {
+    if (pattern.test(firstSentence)) return "dont";
+  }
+  return null;
+}
+
+// src/confidence.ts
+function computeConfidence(input) {
+  const fb = input.feedback_signals ?? { positive: 0, negative: 0, neutral: 0 };
+  const total = fb.positive + fb.negative + fb.neutral;
+  if (total === 0) return 0.5;
+  const netRatio = (fb.positive - fb.negative) / total;
+  const dampening = 1 - 1 / (total + 1);
+  const adjustedRatio = netRatio * dampening;
+  const steepness = 2;
+  const base = 1 / (1 + Math.exp(-steepness * adjustedRatio));
+  const consolidationBonus = input.consolidated ? 0.05 : 0;
+  return Math.min(1, Math.max(0, base + consolidationBonus));
+}
+function computeMetaConfidence(evidenceCount, domainCount, structuralDepth, validationRatio) {
+  const evidenceSignal = Math.min(evidenceCount / 5, 1) * 0.25;
+  const domainSignal = Math.min(domainCount / 3, 1) * 0.35;
+  const depthSignal = Math.min(structuralDepth / 3, 1) * 0.2;
+  const validationSignal = validationRatio * 0.2;
+  return evidenceSignal + domainSignal + depthSignal + validationSignal;
+}
+function confidenceBand(score) {
+  if (score >= 0.7) return "high";
+  if (score >= 0.4) return "medium";
+  return "low";
+}
+
 // src/inject.ts
 var DEFAULT_MAX_TOKENS = 8e3;
 var DEFAULT_MIN_RELEVANCE = 0.3;
@@ -614,7 +1359,7 @@ function stripAssociations(engram) {
 }
 function stripScoring(engram) {
   const { keyword_match: _, raw_score: _r, score: _s, ...rest } = engram;
-  return rest;
+  return { ...rest, confidence_score: computeConfidence(engram) };
 }
 function scoreEngram(engram, promptLower, promptWords, packMatchTerms, scopeFilter, isPack) {
   if (scopeFilter) {
@@ -650,6 +1395,8 @@ function scoreEngram(engram, promptLower, promptWords, packMatchTerms, scopeFilt
     else if (netFeedback < 0) score *= Math.max(1 + netFeedback * 0.1, 0.5);
   }
   if (engram.consolidated) score *= 1.1;
+  const emotionalWeight = engram.episodic?.emotional_weight ?? 5;
+  score *= 1 + (emotionalWeight - 5) * 0.04;
   return score;
 }
 function fillTokenBudget(scored, maxTokens) {
@@ -681,10 +1428,13 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
   const promptWords = new Set(promptLower.split(/\W+/).filter((w) => w.length > 2));
   const maxTokens = ctx.maxTokens ?? DEFAULT_MAX_TOKENS;
   const minRelevance = ctx.minRelevance ?? DEFAULT_MIN_RELEVANCE;
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const engramMap = /* @__PURE__ */ new Map();
   const scored = [];
   for (const engram of personalEngrams) {
     if (engram.status !== "active") continue;
+    if (engram.temporal?.valid_until && engram.temporal.valid_until < today) continue;
+    if (engram.temporal?.valid_from && engram.temporal.valid_from > today) continue;
     engramMap.set(engram.id, engram);
     let raw = scoreEngram(engram, promptLower, promptWords, [], ctx.scope, false);
     const embBoost = embeddingBoosts?.get(engram.id) ?? 0;
@@ -703,6 +1453,8 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
     const matchTerms = packMeta.match_terms;
     for (const engram of pack.engrams) {
       if (engram.status !== "active") continue;
+      if (engram.temporal?.valid_until && engram.temporal.valid_until < today) continue;
+      if (engram.temporal?.valid_from && engram.temporal.valid_from > today) continue;
       engramMap.set(engram.id, engram);
       let raw = scoreEngram(engram, promptLower, promptWords, matchTerms, ctx.scope, true);
       const embBoost = embeddingBoosts?.get(engram.id) ?? 0;
@@ -750,6 +1502,7 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
   if (directives.length === 0 && dip19Pool.length === 0) {
     return {
       directives: [],
+      constraints: [],
       consider: [],
       tokens_used: { directives: 0, consider: 0 }
     };
@@ -787,11 +1540,22 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
   const allConsider = [...dip19Pool, ...spreadCandidates];
   const agentDirectives = directives.map(stripAssociations);
   const agentConsider = allConsider.map(stripAssociations);
-  const wireDirectives = agentDirectives.map(stripScoring);
+  const wireAll = agentDirectives.map(stripScoring);
   const wireConsider = agentConsider.map(stripScoring);
+  const wireDirectives = [];
+  const wireConstraints = [];
+  for (const wire of wireAll) {
+    const polarity = wire.polarity ?? classifyPolarity(wire.statement);
+    if (polarity === "dont") {
+      wireConstraints.push(wire);
+    } else {
+      wireDirectives.push(wire);
+    }
+  }
   const considerTokens = dip19PoolTokens + spreadTokens;
   return {
     directives: wireDirectives,
+    constraints: wireConstraints,
     consider: wireConsider,
     tokens_used: { directives: directiveTokens, consider: considerTokens }
   };
@@ -905,86 +1669,6 @@ Rules:
   }
 }
 
-// src/embeddings.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, mkdirSync as mkdirSync3 } from "fs";
-import { join as join3 } from "path";
-import { createHash } from "crypto";
-var embedPipeline = null;
-var transformersUnavailable = false;
-async function getEmbedder() {
-  if (transformersUnavailable) return null;
-  if (!embedPipeline) {
-    try {
-      const { pipeline } = await import("./transformers.node-PH5YK5EA.js");
-      embedPipeline = await pipeline("feature-extraction", "Xenova/bge-small-en-v1.5", {
-        dtype: "fp32"
-      });
-    } catch {
-      transformersUnavailable = true;
-      return null;
-    }
-  }
-  return embedPipeline;
-}
-async function embed(text) {
-  const embedder = await getEmbedder();
-  if (!embedder) return null;
-  const result = await embedder(text, { pooling: "cls", normalize: true });
-  return new Float32Array(result.data);
-}
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
-  return dot;
-}
-function loadCache(cachePath) {
-  if (!existsSync6(cachePath)) return {};
-  try {
-    return JSON.parse(readFileSync4(cachePath, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function saveCache(cachePath, cache2) {
-  const dir = cachePath.substring(0, cachePath.lastIndexOf("/"));
-  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
-  atomicWrite(cachePath, JSON.stringify(cache2));
-}
-function hashStatement(statement) {
-  return createHash("sha256").update(statement).digest("hex").slice(0, 16);
-}
-async function embeddingSearch(engrams, query, limit, storagePath) {
-  if (engrams.length === 0) return [];
-  const cachePath = storagePath ? join3(storagePath, ".embeddings-cache.json") : ".embeddings-cache.json";
-  const cache2 = loadCache(cachePath);
-  const queryEmbedding = await embed(query);
-  if (!queryEmbedding) {
-    return [];
-  }
-  const similarities = [];
-  for (const engram of engrams) {
-    const searchText = engramSearchText(engram);
-    const hash = hashStatement(searchText);
-    let engramEmbedding;
-    if (cache2[engram.id]?.hash === hash) {
-      engramEmbedding = new Float32Array(cache2[engram.id].embedding);
-    } else {
-      const emb = await embed(searchText);
-      if (!emb) return [];
-      engramEmbedding = emb;
-      cache2[engram.id] = {
-        hash,
-        embedding: Array.from(engramEmbedding)
-      };
-    }
-    const score = cosineSimilarity(queryEmbedding, engramEmbedding);
-    similarities.push({ engram, score });
-  }
-  saveCache(cachePath, cache2);
-  similarities.sort((a, b) => b.score - a.score);
-  return similarities.slice(0, limit).map((s) => s.engram);
-}
-
 // src/hybrid-search.ts
 function rrfMerge(resultSets, k = 60) {
   const scores = /* @__PURE__ */ new Map();
@@ -1183,6 +1867,818 @@ ${manifest.description || ""}
   return { path: outputDir, engram_count: engrams.length };
 }
 
+// src/secrets.ts
+var SECRET_PATTERNS = [
+  { name: "aws_access_key", regex: /AKIA[0-9A-Z]{16}/ },
+  { name: "aws_secret_key", regex: /(?:aws_secret_access_key|secret_access_key)\s*[=:]\s*[A-Za-z0-9/+=]{40}/i },
+  { name: "generic_api_key", regex: /(?:^|[^a-z])(sk|pk)[-_][a-z0-9]{20,}/i },
+  { name: "api_key_assignment", regex: /(?:api[_-]?key|api[_-]?secret|secret[_-]?key)\s*[=:]\s*\S{20,}/i },
+  { name: "password_assignment", regex: /password\s*[=:]\s*\S{8,}/i },
+  { name: "connection_string", regex: /(?:postgres|mysql|mongodb|redis):\/\/\S+/ },
+  { name: "jwt", regex: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}/ },
+  { name: "private_key", regex: /-----BEGIN\s+\S+\s+PRIVATE KEY-----/ },
+  { name: "bearer_token", regex: /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/ }
+];
+function detectSecrets(text) {
+  const matches = [];
+  for (const { name, regex } of SECRET_PATTERNS) {
+    const m = text.match(regex);
+    if (m) {
+      matches.push({ pattern: name, match: m[0].slice(0, 20) + "..." });
+    }
+  }
+  return matches;
+}
+
+// src/meta/sanitize.ts
+function sanitizeForPrompt(text) {
+  return text.replace(/```/g, "~~~").replace(/\n{3,}/g, "\n\n").replace(/^(system|assistant|user):/gim, "$1 -").slice(0, 2e3);
+}
+
+// src/meta/structural-analysis.ts
+var FAILURE_TAGS = /* @__PURE__ */ new Set(["correction", "mistake", "bug", "fix", "error", "wrong", "broken"]);
+var BATCH_SIZE = 5;
+function isFailureDriven(engram) {
+  if (engram.tags.some((t) => FAILURE_TAGS.has(t.toLowerCase()))) return true;
+  const fb = engram.feedback_signals;
+  if (fb && fb.negative > fb.positive) return true;
+  return false;
+}
+function prioritize(engrams) {
+  return [...engrams].sort((a, b) => {
+    const aFail = isFailureDriven(a) ? 0 : 1;
+    const bFail = isFailureDriven(b) ? 0 : 1;
+    if (aFail !== bFail) return aFail - bFail;
+    const aFb = a.feedback_signals?.negative ?? 0;
+    const bFb = b.feedback_signals?.negative ?? 0;
+    return bFb - aFb;
+  });
+}
+function buildPrompt(engrams) {
+  const items = engrams.map((e, i) => {
+    const parts = [`  Statement: "${sanitizeForPrompt(e.statement)}"`];
+    if (e.rationale) parts.push(`  Rationale: "${sanitizeForPrompt(e.rationale)}"`);
+    if (e.domain) parts.push(`  Domain: "${e.domain}"`);
+    return `Engram ${i + 1} (${e.id}):
+${parts.join("\n")}`;
+  }).join("\n\n");
+  return `Given these learned lessons, extract relational structure for cross-domain transfer.
+
+${items}
+
+For EACH engram, extract:
+1. The GOAL the agent had (abstract type, not domain-specific)
+2. Relational triples: subject (role + domain instance), predicate, object (role + domain instance), outcome
+3. Use domain-GENERAL role types (e.g., "safety-metric" not "liquidation-price")
+
+Return a JSON array with one object per engram:
+[{
+  "engram_id": "ENG-...",
+  "goal_context": "what the agent was trying to achieve (abstract)",
+  "triples": [{ "subject": { "role": "...", "domain_instance": "..." }, "predicate": "...", "object": { "role": "...", "domain_instance": "..." }, "outcome": "..." }]
+}]
+
+Rules:
+- Roles MUST be domain-general (e.g., "safety-metric" not "liquidation-price")
+- If a lesson is purely domain-specific with no transferable structure, return empty triples: []
+- Prefer causal chains over isolated attributes
+- Return ONLY valid JSON, no markdown fencing`;
+}
+async function analyzeStructure(engrams, llm) {
+  const prioritized = prioritize(engrams.filter((e) => e.status === "active"));
+  const results = [];
+  for (let i = 0; i < prioritized.length; i += BATCH_SIZE) {
+    const batch = prioritized.slice(i, i + BATCH_SIZE);
+    const prompt = buildPrompt(batch);
+    let parsed;
+    try {
+      const response = await llm(prompt);
+      const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+      parsed = JSON.parse(cleaned);
+    } catch {
+      try {
+        const retryResponse = await llm(prompt + "\n\nIMPORTANT: Return ONLY raw JSON array, no text.");
+        const cleaned = retryResponse.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+        parsed = JSON.parse(cleaned);
+      } catch {
+        continue;
+      }
+    }
+    for (const item of parsed) {
+      if (!item.triples || item.triples.length === 0) continue;
+      const engram = batch.find((e) => e.id === item.engram_id) ?? batch[parsed.indexOf(item)];
+      if (!engram) continue;
+      results.push({
+        engram_id: engram.id,
+        triples: item.triples,
+        goal_context: item.goal_context ?? "",
+        is_failure_driven: isFailureDriven(engram),
+        domain: engram.domain ?? "unknown",
+        polarity: classifyPolarity(engram.statement) === "dont" ? "dont" : "do"
+      });
+    }
+  }
+  return results;
+}
+
+// src/meta/similarity.ts
+function tokenSimilarity(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/[\s\[\]→+\-]+/).filter((w) => w.length > 2));
+  const wordsB = new Set(b.toLowerCase().split(/[\s\[\]→+\-]+/).filter((w) => w.length > 2));
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let overlap = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) overlap++;
+  }
+  return overlap / Math.sqrt(wordsA.size * wordsB.size);
+}
+
+// src/meta/clustering.ts
+function tripleToTemplate(triple) {
+  const parts = [triple.subject.role, triple.predicate, triple.object.role];
+  if (triple.outcome) parts.push("\u2192", triple.outcome);
+  return parts.join(" ");
+}
+function analysisTemplate(analysis) {
+  return analysis.triples.map(tripleToTemplate).join("; ");
+}
+async function computeSimilarityMatrix(templates) {
+  const n = templates.length;
+  const matrix = Array.from({ length: n }, () => Array(n).fill(0));
+  try {
+    const { embed, cosineSimilarity } = await import("./embeddings-2IODIQAF.js");
+    const embeddings = [];
+    for (const t of templates) {
+      embeddings.push(await embed(t));
+    }
+    if (embeddings[0] !== null) {
+      for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+          if (embeddings[i] && embeddings[j]) {
+            const sim = cosineSimilarity(embeddings[i], embeddings[j]);
+            matrix[i][j] = sim;
+            matrix[j][i] = sim;
+          }
+        }
+      }
+      return { matrix, method: "embedding" };
+    }
+  } catch {
+  }
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const sim = tokenSimilarity(templates[i], templates[j]);
+      matrix[i][j] = sim;
+      matrix[j][i] = sim;
+    }
+  }
+  return { matrix, method: "token" };
+}
+var EMBEDDING_THRESHOLD = 0.65;
+var TOKEN_THRESHOLD = 0.35;
+async function clusterByStructure(analyses, threshold2) {
+  if (analyses.length < 2) return [];
+  const templates = analyses.map((a) => analysisTemplate(a));
+  const { matrix, method } = await computeSimilarityMatrix(templates);
+  const effectiveThreshold = threshold2 ?? (method === "embedding" ? EMBEDDING_THRESHOLD : TOKEN_THRESHOLD);
+  const seenClusters = /* @__PURE__ */ new Set();
+  const clusters = [];
+  let clusterId = 0;
+  for (let i = 0; i < analyses.length; i++) {
+    const members = [analyses[i]];
+    const memberIndices = [i];
+    for (let j = 0; j < analyses.length; j++) {
+      if (j === i) continue;
+      if (matrix[i][j] >= effectiveThreshold) {
+        members.push(analyses[j]);
+        memberIndices.push(j);
+      }
+    }
+    if (members.length < 2) continue;
+    const memberKey = members.map((m) => m.engram_id).sort().join(",");
+    if (seenClusters.has(memberKey)) continue;
+    seenClusters.add(memberKey);
+    const domains = [...new Set(members.map((m) => m.domain))];
+    let totalSim = 0;
+    let pairs = 0;
+    for (let a = 0; a < memberIndices.length; a++) {
+      for (let b = a + 1; b < memberIndices.length; b++) {
+        totalSim += matrix[memberIndices[a]][memberIndices[b]];
+        pairs++;
+      }
+    }
+    clusters.push({
+      cluster_id: `cluster-${clusterId++}`,
+      members,
+      domains,
+      is_cross_domain: domains.length >= 2,
+      cohesion: pairs > 0 ? totalSim / pairs : 0
+    });
+  }
+  return clusters;
+}
+
+// src/meta/platitudes.ts
+var PLATITUDE_PATTERNS = [
+  "always be careful",
+  "verify before acting",
+  "plan ahead",
+  "consider edge cases",
+  "communicate clearly",
+  "test thoroughly",
+  "keep it simple",
+  "document your work",
+  "think before you act",
+  "double check"
+];
+function isPlatitude(statement) {
+  const lower = statement.toLowerCase();
+  return PLATITUDE_PATTERNS.some((p) => lower.includes(p)) || statement.length < 30;
+}
+
+// src/meta/alignment.ts
+async function alignCluster(cluster, llm) {
+  const tripleDescriptions = cluster.members.map((m) => {
+    const domain = sanitizeForPrompt(m.domain);
+    const triples = m.triples.map((t) => {
+      const parts = [`${sanitizeForPrompt(t.subject.role)} ${sanitizeForPrompt(t.predicate)} ${sanitizeForPrompt(t.object.role)}`];
+      if (t.outcome) parts.push(`\u2192 ${sanitizeForPrompt(t.outcome)}`);
+      return parts.join(" ");
+    }).join("; ");
+    return `Domain ${domain} (${m.engram_id}): ${triples}`;
+  }).join("\n");
+  const prompt = `These lessons come from different domains but may share a common structural principle:
+
+${tripleDescriptions}
+
+Tasks:
+1. Is there a genuine common relational structure? (Not surface similarity, not a platitude)
+2. Choose the structural frame that BEST captures the pattern:
+   - "goal-constraint-outcome": [goal] + [constraint] \u2192 [outcome]
+   - "feedback-loop": [action] \u2192 [effect] \u2192 [feeds back to action]
+   - "causal-chain": [A] causes [B] causes [C]
+   - "tradeoff": [optimizing X] at the expense of [Y]
+   - "recursive": [pattern] contains smaller instances of [same pattern]
+   - "freeform": describe the structure in your own terms
+3. Express the common structure using your chosen frame
+4. Rate structural depth (1-5): 1=surface, 3=causal chain, 5=deep systematic
+5. For each member, rate alignment (0-1) and explain the mapping in one sentence
+6. What does this structure PREDICT in a domain not listed above?
+
+Return JSON:
+{
+  "common_structure": {
+    "goal_type": "...",
+    "constraint_type": "...",
+    "outcome_type": "...",
+    "template": "...",
+    "structure_type": "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "recursive" | "freeform",
+    "freeform_structure": "..." (only if structure_type is "freeform")
+  } | null,
+  "structural_depth": N,
+  "member_alignments": [{ "engram_id": "...", "alignment_score": N, "mapping_rationale": "..." }],
+  "candidate_inferences": ["..."]
+}
+
+If the commonality is shallow or trivially obvious (e.g., "mistakes happen", "always be careful"), return null for common_structure. We prefer no extraction over a false abstraction.
+Return ONLY valid JSON, no markdown fencing.`;
+  try {
+    const response = await llm(prompt);
+    const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+    if (cleaned === "null" || cleaned === '{"common_structure": null}') return null;
+    const parsed = JSON.parse(cleaned);
+    if (!parsed.common_structure) return null;
+    if (parsed.structural_depth < 2) return null;
+    if (isPlatitude(parsed.common_structure.template)) return null;
+    if (parsed.common_structure.template.length < 30) return null;
+    const alignments = parsed.member_alignments ?? [];
+    const lowAlignments = alignments.filter((a) => a.alignment_score < 0.5);
+    if (lowAlignments.length > alignments.length / 2) return null;
+    return {
+      cluster_id: cluster.cluster_id,
+      common_structure: parsed.common_structure,
+      member_alignments: alignments,
+      structural_depth: parsed.structural_depth,
+      systematicity: parsed.structural_depth,
+      // Use depth as systematicity proxy
+      candidate_inferences: parsed.candidate_inferences ?? []
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/meta/formulation.ts
+var PIPELINE_VERSION = "1.0.0";
+function slugifyTemplate(template) {
+  return template.toLowerCase().replace(/[\[\]→+]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+function isDuplicate(template, existingMetas) {
+  for (const meta of existingMetas) {
+    const metaField = meta.structured_data?.meta;
+    if (!metaField?.structure?.template) continue;
+    const sim = tokenSimilarity(template, metaField.structure.template);
+    if (sim > 0.9) return meta;
+  }
+  return null;
+}
+async function formulateMetaEngram(alignment, llm, existingMetas = [], domains = []) {
+  const { common_structure, member_alignments, structural_depth, candidate_inferences } = alignment;
+  if (isPlatitude(common_structure.template)) return null;
+  const memberSummary = member_alignments.map((m) => `  - ${m.engram_id}: ${sanitizeForPrompt(m.mapping_rationale)} (alignment: ${m.alignment_score})`).join("\n");
+  const prompt = `Structural principle: ${sanitizeForPrompt(common_structure.template)}
+Goal type: ${common_structure.goal_type}
+Constraint type: ${common_structure.constraint_type}
+Outcome type: ${common_structure.outcome_type}
+Structural depth: ${structural_depth}
+Evidence from members:
+${memberSummary}
+Candidate inferences: ${candidate_inferences.map(sanitizeForPrompt).join(", ")}
+
+Generate:
+1. A natural-language statement of this principle (1-2 sentences, precise, not generic)
+2. Conditions under which it holds (expected_conditions)
+3. Conditions under which it does NOT hold (expected_exceptions)
+4. A concrete test: pick a domain NOT in the evidence list, describe a scenario where this principle predicts a specific outcome (test_prediction)
+
+The statement must be specific enough to be FALSIFIABLE. If you cannot write falsification criteria, return null.
+
+Return JSON:
+{
+  "statement": "...",
+  "falsification": {
+    "expected_conditions": "...",
+    "expected_exceptions": "...",
+    "test_prediction": "..."
+  }
+}
+
+Or return null if the principle is too vague to falsify.
+Return ONLY valid JSON, no markdown fencing.`;
+  let parsed;
+  try {
+    const response = await llm(prompt);
+    const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+    if (cleaned === "null") return null;
+    parsed = JSON.parse(cleaned);
+  } catch {
+    return null;
+  }
+  if (!parsed || !parsed.statement || !parsed.falsification) return null;
+  if (!parsed.falsification.expected_conditions || !parsed.falsification.expected_exceptions) return null;
+  const duplicate = isDuplicate(common_structure.template, existingMetas);
+  if (duplicate) {
+    return null;
+  }
+  const evidenceCount = member_alignments.length;
+  const domainCount = domains.length > 0 ? domains.length : 1;
+  const validationRatio = 0;
+  const composite = computeMetaConfidence(evidenceCount, domainCount, structural_depth, validationRatio);
+  const slug = slugifyTemplate(common_structure.template);
+  const id = `META-${slug}`;
+  const evidence = member_alignments.map((ma) => ({
+    engram_id: ma.engram_id,
+    domain: "unknown",
+    // Will be enriched by pipeline orchestrator
+    mapping_rationale: ma.mapping_rationale,
+    alignment_score: ma.alignment_score
+  }));
+  const metaField = {
+    structure: common_structure,
+    evidence,
+    domain_coverage: {
+      validated: [],
+      failed: [],
+      predicted: candidate_inferences
+    },
+    falsification: parsed.falsification,
+    confidence: {
+      evidence_count: evidenceCount,
+      domain_count: domainCount,
+      structural_depth,
+      validation_ratio: validationRatio,
+      composite
+    },
+    hierarchy: {
+      level: domainCount >= 3 ? "top" : "mop",
+      parent: null,
+      children: []
+    },
+    pipeline_version: PIPELINE_VERSION
+  };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const engram = {
+    id,
+    version: 2,
+    status: "active",
+    consolidated: false,
+    type: "behavioral",
+    scope: "global",
+    visibility: "private",
+    statement: parsed.statement,
+    domain: "meta",
+    tags: ["meta-engram", common_structure.goal_type, common_structure.constraint_type],
+    activation: {
+      retrieval_strength: composite,
+      storage_strength: 1,
+      frequency: 0,
+      last_accessed: now.slice(0, 10)
+    },
+    feedback_signals: { positive: 0, negative: 0, neutral: 0 },
+    knowledge_anchors: [],
+    associations: [],
+    derivation_count: evidenceCount,
+    pack: null,
+    abstract: null,
+    derived_from: null,
+    polarity: null,
+    knowledge_type: {
+      memory_class: "metacognitive",
+      cognitive_level: "evaluate"
+    },
+    structured_data: { meta: metaField }
+  };
+  return engram;
+}
+
+// src/meta/validation.ts
+async function validateMetaEngram(meta, testEngrams, testDomain, llm) {
+  const metaField = meta.structured_data?.meta;
+  if (!metaField) {
+    return {
+      meta_engram_id: meta.id,
+      test_domain: testDomain,
+      prediction_held: false,
+      matching_engram_id: null,
+      alignment_score: 0,
+      rationale: "Meta-engram has no meta field"
+    };
+  }
+  const template = metaField.structure.template;
+  const testEngramSummary = testEngrams.filter((e) => e.status === "active").slice(0, 10).map((e) => `  - [${e.id}] ${sanitizeForPrompt(e.statement)}`).join("\n");
+  if (!testEngramSummary) {
+    return {
+      meta_engram_id: meta.id,
+      test_domain: testDomain,
+      prediction_held: false,
+      matching_engram_id: null,
+      alignment_score: 0,
+      rationale: "No test engrams available for validation"
+    };
+  }
+  const prompt = `Meta-engram structural principle: ${sanitizeForPrompt(template)}
+Meta-engram statement: ${sanitizeForPrompt(meta.statement)}
+
+Test domain: ${testDomain}
+Test engrams from this domain:
+${testEngramSummary}
+
+Task: Does any of the test engrams instantiate or validate this structural principle?
+
+If YES (a test engram matches):
+- prediction_held: true
+- matching_engram_id: the ID of the matching engram
+- alignment_score: 0.5-1.0 (how well the structural template maps)
+- rationale: one sentence explaining how the test engram maps to the template
+
+If NO (no test engram matches):
+- prediction_held: false
+- matching_engram_id: null
+- alignment_score: 0
+- rationale: one sentence explaining WHY none of the test engrams match (e.g., "Test engrams cover X domain but none exhibit the structural pattern of [assumed independence] \u2192 [understated risk]")
+
+Return JSON:
+{
+  "prediction_held": true|false,
+  "matching_engram_id": "ENG-..." | null,
+  "alignment_score": 0.0-1.0,
+  "rationale": "one sentence explanation \u2014 REQUIRED even when prediction_held is false"
+}
+
+Return ONLY valid JSON, no markdown fencing.`;
+  try {
+    const response = await llm(prompt);
+    const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+    const parsed = JSON.parse(cleaned);
+    const result = {
+      meta_engram_id: meta.id,
+      test_domain: testDomain,
+      prediction_held: Boolean(parsed.prediction_held),
+      matching_engram_id: parsed.matching_engram_id ?? null,
+      alignment_score: typeof parsed.alignment_score === "number" ? parsed.alignment_score : 0,
+      rationale: parsed.rationale ?? ""
+    };
+    if (result.prediction_held) {
+      if (!metaField.domain_coverage.validated.includes(testDomain)) {
+        metaField.domain_coverage.validated.push(testDomain);
+      }
+    } else {
+      if (!metaField.domain_coverage.failed.includes(testDomain)) {
+        metaField.domain_coverage.failed.push(testDomain);
+      }
+    }
+    const passes = metaField.domain_coverage.validated.length;
+    const total = passes + metaField.domain_coverage.failed.length;
+    const validationRatio = total > 0 ? passes / total : 0;
+    const updatedComposite = computeMetaConfidence(
+      metaField.confidence.evidence_count,
+      metaField.confidence.domain_count,
+      metaField.confidence.structural_depth,
+      validationRatio
+    );
+    metaField.confidence.validation_ratio = validationRatio;
+    metaField.confidence.composite = updatedComposite;
+    metaField.last_validated = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const failedCount = metaField.domain_coverage.failed.length;
+    if (failedCount >= 3) {
+      if (metaField.hierarchy.level === "top") {
+        metaField.hierarchy.level = "mop";
+      } else {
+        meta.status = "retired";
+      }
+    }
+    return result;
+  } catch {
+    return {
+      meta_engram_id: meta.id,
+      test_domain: testDomain,
+      prediction_held: false,
+      matching_engram_id: null,
+      alignment_score: 0,
+      rationale: "LLM parsing failed during validation"
+    };
+  }
+}
+
+// src/meta/hierarchy.ts
+var SUBSUMPTION_THRESHOLD = 0.75;
+function getMetaField(engram) {
+  return engram.structured_data?.meta ?? null;
+}
+function getDomainCount(metaField) {
+  const validated = metaField.domain_coverage.validated.length;
+  const evidenceDomains = new Set(metaField.evidence.map((e) => e.domain)).size;
+  return Math.max(validated, evidenceDomains, metaField.confidence.domain_count);
+}
+function organizeHierarchy(metaEngrams) {
+  const metas = metaEngrams.filter((e) => getMetaField(e) !== null && e.id.startsWith("META-"));
+  if (metas.length === 0) return metaEngrams;
+  for (const meta of metas) {
+    const mf = getMetaField(meta);
+    mf.hierarchy.parent = null;
+    mf.hierarchy.children = [];
+  }
+  for (let i = 0; i < metas.length; i++) {
+    for (let j = 0; j < metas.length; j++) {
+      if (i === j) continue;
+      const mfI = getMetaField(metas[i]);
+      const mfJ = getMetaField(metas[j]);
+      const sim = tokenSimilarity(mfI.structure.template, mfJ.structure.template);
+      if (sim < SUBSUMPTION_THRESHOLD) continue;
+      const domainsI = getDomainCount(mfI);
+      const domainsJ = getDomainCount(mfJ);
+      if (domainsI > domainsJ) {
+        if (!mfI.hierarchy.children.includes(metas[j].id)) {
+          mfI.hierarchy.children.push(metas[j].id);
+        }
+        if (!mfJ.hierarchy.parent) {
+          mfJ.hierarchy.parent = metas[i].id;
+        } else {
+          const currentParent = metas.find((m) => m.id === mfJ.hierarchy.parent);
+          const currentParentMf = currentParent ? getMetaField(currentParent) : null;
+          if (currentParentMf && getDomainCount(currentParentMf) < domainsI) {
+            mfJ.hierarchy.parent = metas[i].id;
+          }
+        }
+      }
+    }
+  }
+  for (const meta of metas) {
+    const mf = getMetaField(meta);
+    const domains = getDomainCount(mf);
+    if (domains >= 3 && !mf.hierarchy.parent) {
+      mf.hierarchy.level = "top";
+    } else {
+      mf.hierarchy.level = "mop";
+    }
+  }
+  return metaEngrams;
+}
+
+// src/meta/pipeline.ts
+async function extractMetaEngrams(engrams, llm, options = {}) {
+  const start = Date.now();
+  const {
+    run_validation = false,
+    validation_engrams = [],
+    existing_metas = [],
+    min_cluster_size = 2
+  } = options;
+  let rejected_as_platitudes = 0;
+  const analyses = await analyzeStructure(engrams, llm);
+  const clusters = await clusterByStructure(analyses);
+  const viableClusters = clusters.filter((c) => c.members.length >= min_cluster_size);
+  const alignmentResults = await Promise.all(
+    viableClusters.map((cluster) => alignCluster(cluster, llm))
+  );
+  const validAlignments = alignmentResults.filter((r) => r !== null);
+  const formulated = [];
+  for (const alignment of validAlignments) {
+    const cluster = viableClusters.find((c) => c.cluster_id === alignment.cluster_id);
+    const clusterDomains = cluster ? [...new Set(cluster.members.map((m) => m.domain))] : [];
+    const meta = await formulateMetaEngram(alignment, llm, [...existing_metas, ...formulated], clusterDomains);
+    if (meta === null) {
+      rejected_as_platitudes++;
+    } else {
+      if (cluster) {
+        const metaField = meta.structured_data?.meta;
+        if (metaField) {
+          const domainMap = new Map(cluster.members.map((m) => [m.engram_id, m.domain]));
+          for (const ev of metaField.evidence) {
+            if (domainMap.has(ev.engram_id)) {
+              ev.domain = domainMap.get(ev.engram_id);
+            }
+          }
+          metaField.domain_coverage.validated = clusterDomains;
+          meta.domain = clusterDomains.length >= 3 ? "meta" : `meta.${clusterDomains[0] ?? "unknown"}`;
+        }
+      }
+      formulated.push(meta);
+    }
+  }
+  const validationResults = [];
+  if (run_validation && validation_engrams.length > 0) {
+    for (const meta of formulated) {
+      const metaField = meta.structured_data?.meta;
+      if (!metaField) continue;
+      const evidenceDomains = new Set(metaField.evidence.map((e) => e.domain));
+      const testEngrams = validation_engrams.filter((e) => !evidenceDomains.has(e.domain ?? ""));
+      if (testEngrams.length > 0) {
+        const byDomain = /* @__PURE__ */ new Map();
+        for (const te of testEngrams) {
+          const d = te.domain ?? "unknown";
+          if (!byDomain.has(d)) byDomain.set(d, []);
+          byDomain.get(d).push(te);
+        }
+        for (const [domain, domainEngrams] of byDomain) {
+          const vr = await validateMetaEngram(meta, domainEngrams, domain, llm);
+          validationResults.push(vr);
+        }
+      }
+    }
+  }
+  const organized = organizeHierarchy(formulated);
+  const duration_ms = Date.now() - start;
+  return {
+    engrams_analyzed: analyses.length,
+    clusters_found: clusters.length,
+    alignments_passed: validAlignments.length,
+    meta_engrams_extracted: organized.length,
+    rejected_as_platitudes,
+    validation_results: validationResults,
+    results: organized,
+    duration_ms
+  };
+}
+
+// src/session-state.ts
+var SessionBreadcrumbs = class {
+  toolCalls = [];
+  engramsRecalled = [];
+  recordToolCall(tool, args) {
+    this.toolCalls.push({
+      tool,
+      args_keys: Object.keys(args).join(", "),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  recordEngramRecalled(engramId) {
+    if (!this.engramsRecalled.includes(engramId)) {
+      this.engramsRecalled.push(engramId);
+    }
+  }
+  getToolCalls() {
+    return this.toolCalls;
+  }
+  getEngramsRecalled() {
+    return this.engramsRecalled;
+  }
+  /**
+   * Returns only engram IDs that have the META- prefix.
+   * These represent meta-engrams injected into the session context.
+   */
+  getMetaEngramsRecalled() {
+    return this.engramsRecalled.filter((id) => id.startsWith("META-"));
+  }
+  generateContinuationContext() {
+    if (this.toolCalls.length === 0 && this.engramsRecalled.length === 0) return "";
+    const lines = [];
+    if (this.toolCalls.length > 0) {
+      const uniqueTools = [...new Set(this.toolCalls.map((tc) => tc.tool))];
+      lines.push(`Tools used: ${uniqueTools.join(", ")}`);
+      lines.push(`Total tool calls: ${this.toolCalls.length}`);
+    }
+    if (this.engramsRecalled.length > 0) {
+      lines.push(`Engrams recalled: ${this.engramsRecalled.length}`);
+      const metaCount = this.getMetaEngramsRecalled().length;
+      if (metaCount > 0) {
+        lines.push(`Meta-engrams: ${metaCount}`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/guardrails.ts
+function generateGuardrails() {
+  return `## PLUR Memory Guardrails
+
+### Verification Protocol
+When recalling facts that will drive actions (server IPs, file paths, API endpoints, credential locations):
+1. State the recalled fact explicitly before acting on it
+2. Include the engram ID or search that produced it
+3. If no engram matches, say "No engram found \u2014 verifying from filesystem" and check directly
+4. Never interpolate between two engrams to produce a "probably correct" composite
+
+When the user corrects a recalled fact: call plur.learn immediately, then plur.feedback with negative signal on the wrong engram, before continuing the task.
+
+### Over-engineering Check
+Before proposing any new system, module, or architectural change:
+1. What is the simplest version that solves the actual problem?
+2. Is there an existing tool/pattern that already covers 80% of this?
+3. Will this create maintenance burden disproportionate to its value?
+
+If a task can be done in <20 lines of shell script, do that first.
+
+### Tool Selection Discipline
+Before invoking any external tool, apply the locality test:
+1. Is the answer already in engrams? \u2192 plur.recall
+2. Is the answer in the local filesystem? \u2192 Read/Grep/Glob
+3. Is the answer derivable from context already loaded? \u2192 Just answer
+4. Only if 1-3 fail \u2192 Use external tools
+
+Meta-engrams flagged as "[structural transfer \u2014 untested in current domain]" are hypotheses, not rules. Test before applying.`;
+}
+
+// src/schemas/meta-engram.ts
+import { z as z4 } from "zod";
+var StructuralTemplateSchema = z4.object({
+  goal_type: z4.string().min(1),
+  constraint_type: z4.string().min(1),
+  outcome_type: z4.string().min(1),
+  template: z4.string().min(1),
+  /** Structural frame — declares which relational pattern this meta-engram uses.
+   *  Allows flexible analogy beyond rigid [goal]+[constraint]->[outcome]. */
+  structure_type: z4.enum([
+    "goal-constraint-outcome",
+    "feedback-loop",
+    "causal-chain",
+    "recursive",
+    "tradeoff",
+    "freeform"
+  ]).default("goal-constraint-outcome"),
+  /** For patterns that don't fit the standard template fields — the LLM's own structural description */
+  freeform_structure: z4.string().optional()
+});
+var EvidenceEntrySchema = z4.object({
+  engram_id: z4.string(),
+  domain: z4.string(),
+  mapping_rationale: z4.string(),
+  alignment_score: z4.number().min(0).max(1)
+});
+var FalsificationSchema = z4.object({
+  expected_conditions: z4.string(),
+  expected_exceptions: z4.string(),
+  test_prediction: z4.string().optional()
+});
+var MetaConfidenceSchema = z4.object({
+  evidence_count: z4.number().int().min(0),
+  domain_count: z4.number().int().min(0),
+  structural_depth: z4.number().int().min(1).max(5),
+  validation_ratio: z4.number().min(0).max(1).default(0),
+  composite: z4.number().min(0).max(1)
+});
+var DomainCoverageSchema = z4.object({
+  validated: z4.array(z4.string()),
+  failed: z4.array(z4.string()).default([]),
+  predicted: z4.array(z4.string()).default([])
+});
+var HierarchyPositionSchema = z4.object({
+  level: z4.enum(["mop", "top"]),
+  parent: z4.string().nullable().default(null),
+  children: z4.array(z4.string()).default([])
+});
+var MetaFieldSchema = z4.object({
+  structure: StructuralTemplateSchema,
+  evidence: z4.array(EvidenceEntrySchema).min(2),
+  domain_coverage: DomainCoverageSchema,
+  falsification: FalsificationSchema,
+  confidence: MetaConfidenceSchema,
+  hierarchy: HierarchyPositionSchema,
+  pipeline_version: z4.string(),
+  last_validated: z4.string().optional()
+});
+
 // src/version-check.ts
 var cache = /* @__PURE__ */ new Map();
 async function checkForUpdate(packageName, currentVersion, onResult) {
@@ -1245,53 +2741,67 @@ var INGEST_PATTERNS = [
 var Plur = class {
   paths;
   config;
+  indexedStorage = null;
   constructor(options) {
     this.paths = detectPlurStorage(options?.path);
     this.config = loadConfig(this.paths.config);
+    if (this.config.index) {
+      this.indexedStorage = new IndexedStorage(this.paths.engrams, this.paths.db);
+    }
   }
   /** Create engram, detect conflicts, save. Returns the created engram. */
   learn(statement, context) {
-    const engrams = loadEngrams(this.paths.engrams);
-    const id = generateEngramId(engrams);
-    const scope = context?.scope ?? "global";
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const conflictingEngrams = detectConflicts({ statement, scope }, engrams);
-    const conflictIds = conflictingEngrams.map((e) => e.id);
-    const engram = {
-      id,
-      version: 2,
-      status: "active",
-      consolidated: false,
-      type: context?.type ?? "behavioral",
-      scope,
-      visibility: "private",
-      statement,
-      source: context?.source,
-      domain: context?.domain,
-      activation: {
-        retrieval_strength: 0.7,
-        storage_strength: 1,
-        frequency: 0,
-        last_accessed: now.slice(0, 10)
-      },
-      feedback_signals: { positive: 0, negative: 0, neutral: 0 },
-      knowledge_anchors: [],
-      associations: [],
-      derivation_count: 1,
-      tags: [],
-      pack: null,
-      abstract: null,
-      derived_from: null,
-      relations: conflictIds.length > 0 ? {
-        broader: [],
-        narrower: [],
-        related: [],
-        conflicts: conflictIds
-      } : void 0
-    };
-    engrams.push(engram);
-    saveEngrams(this.paths.engrams, engrams);
-    return engram;
+    if (!this.config.allow_secrets) {
+      const secrets = detectSecrets(statement);
+      if (secrets.length > 0) {
+        throw new Error(`Secret detected in statement: ${secrets[0].pattern}. Use config.allow_secrets to override.`);
+      }
+    }
+    return withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const id = generateEngramId(engrams);
+      const scope = context?.scope ?? "global";
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const conflictingEngrams = detectConflicts({ statement, scope }, engrams);
+      const conflictIds = conflictingEngrams.map((e) => e.id);
+      const engram = {
+        id,
+        version: 2,
+        status: "active",
+        consolidated: false,
+        type: context?.type ?? "behavioral",
+        scope,
+        visibility: "private",
+        statement,
+        source: context?.source,
+        domain: context?.domain,
+        activation: {
+          retrieval_strength: 0.7,
+          storage_strength: 1,
+          frequency: 0,
+          last_accessed: now.slice(0, 10)
+        },
+        feedback_signals: { positive: 0, negative: 0, neutral: 0 },
+        knowledge_anchors: [],
+        associations: [],
+        derivation_count: 1,
+        tags: [],
+        pack: null,
+        abstract: null,
+        derived_from: null,
+        polarity: null,
+        relations: conflictIds.length > 0 ? {
+          broader: [],
+          narrower: [],
+          related: [],
+          conflicts: conflictIds
+        } : void 0
+      };
+      engrams.push(engram);
+      saveEngrams(this.paths.engrams, engrams);
+      this._syncIndex();
+      return engram;
+    });
   }
   /**
    * Search engrams, filter by scope/domain/strength, reactivate accessed.
@@ -1339,39 +2849,95 @@ var Plur = class {
     this._reactivateResults(results);
     return results;
   }
+  /** List all active engrams, optionally filtered by scope/domain. No search — returns all matches. */
+  list(options) {
+    return this._filterEngrams(options);
+  }
   /** Filter engrams by scope/domain/strength (shared by both modes) */
   _filterEngrams(options) {
-    let engrams = loadEngrams(this.paths.engrams);
-    engrams = engrams.filter((e) => e.status === "active");
-    if (options?.domain) {
-      engrams = engrams.filter((e) => e.domain?.startsWith(options.domain));
+    let engrams;
+    if (this.indexedStorage) {
+      engrams = this.indexedStorage.loadFiltered({
+        status: "active",
+        scope: options?.scope,
+        domain: options?.domain
+      });
+    } else {
+      engrams = loadEngrams(this.paths.engrams);
+      engrams = engrams.filter((e) => e.status === "active");
+      if (options?.domain) {
+        engrams = engrams.filter((e) => e.domain?.startsWith(options.domain));
+      }
+      if (options?.scope) {
+        const scope = options.scope;
+        engrams = engrams.filter(
+          (e) => e.scope === "global" || e.scope === scope || e.scope.startsWith(scope)
+        );
+      }
     }
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    engrams = engrams.filter((e) => {
+      if (e.temporal?.valid_until && e.temporal.valid_until < today) return false;
+      if (e.temporal?.valid_from && e.temporal.valid_from > today) return false;
+      return true;
+    });
     if (options?.min_strength !== void 0) {
       engrams = engrams.filter((e) => e.activation.retrieval_strength >= options.min_strength);
     }
-    if (options?.scope) {
-      const scope = options.scope;
-      engrams = engrams.filter(
-        (e) => e.scope === "global" || e.scope === scope || e.scope.startsWith(scope)
-      );
-    }
     return engrams;
   }
-  /** Reactivate accessed engrams (bump retrieval strength, frequency, last_accessed) */
+  /** Reactivate accessed engrams and update co-access associations */
   _reactivateResults(results) {
     if (results.length === 0) return;
-    const allEngrams = loadEngrams(this.paths.engrams);
-    const resultIds = new Set(results.map((e) => e.id));
-    let modified = false;
-    for (const e of allEngrams) {
-      if (resultIds.has(e.id)) {
-        e.activation.retrieval_strength = reactivate(e.activation.retrieval_strength);
-        e.activation.last_accessed = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-        e.activation.frequency += 1;
-        modified = true;
+    withLock(this.paths.engrams, () => {
+      const allEngrams = loadEngrams(this.paths.engrams);
+      const resultIds = new Set(results.map((e) => e.id));
+      const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      let modified = false;
+      for (const e of allEngrams) {
+        if (resultIds.has(e.id)) {
+          e.activation.retrieval_strength = reactivate(e.activation.retrieval_strength);
+          e.activation.last_accessed = today;
+          e.activation.frequency += 1;
+          modified = true;
+        }
       }
-    }
-    if (modified) saveEngrams(this.paths.engrams, allEngrams);
+      if (results.length >= 2 && this.config.injection?.co_access !== false) {
+        const topHalf = results.slice(0, Math.max(2, Math.ceil(results.length / 2)));
+        const topIds = topHalf.map((e) => e.id);
+        for (const sourceId of topIds) {
+          const source = allEngrams.find((e) => e.id === sourceId);
+          if (!source) continue;
+          for (const targetId of topIds) {
+            if (targetId === sourceId) continue;
+            const existing = source.associations.find(
+              (a) => a.type === "co_accessed" && a.target === targetId
+            );
+            if (existing) {
+              existing.strength = Math.min(0.95, existing.strength + 0.05);
+              existing.updated_at = today;
+              modified = true;
+            } else {
+              const coAccessCount = source.associations.filter((a) => a.type === "co_accessed").length;
+              if (coAccessCount < 5) {
+                source.associations.push({
+                  target_type: "engram",
+                  target: targetId,
+                  type: "co_accessed",
+                  strength: 0.3,
+                  updated_at: today
+                });
+                modified = true;
+              }
+            }
+          }
+        }
+      }
+      if (modified) {
+        saveEngrams(this.paths.engrams, allEngrams);
+        this._syncIndex();
+      }
+    });
   }
   /** Scored injection within token budget (BM25 only). Returns formatted strings. */
   inject(task, options) {
@@ -1416,11 +2982,13 @@ var Plur = class {
       return wires.map((e) => `[${e.id}] ${e.statement}`).join("\n");
     };
     const directivesStr = formatEngrams(result.directives);
+    const constraintsStr = formatEngrams(result.constraints);
     const considerStr = formatEngrams(result.consider);
-    const count = result.directives.length + result.consider.length;
+    const count = result.directives.length + result.constraints.length + result.consider.length;
     const tokensUsed = result.tokens_used.directives + result.tokens_used.consider;
     return {
       directives: directivesStr,
+      constraints: constraintsStr,
       consider: considerStr,
       count,
       tokens_used: tokensUsed
@@ -1428,30 +2996,96 @@ var Plur = class {
   }
   /** Update feedback_signals and adjust retrieval_strength. */
   feedback(id, signal) {
-    const engrams = loadEngrams(this.paths.engrams);
-    const engram = engrams.find((e) => e.id === id);
-    if (!engram) throw new Error(`Engram not found: ${id}`);
-    if (!engram.feedback_signals) {
-      engram.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
-    }
-    engram.feedback_signals[signal] += 1;
-    if (signal === "positive") {
-      engram.activation.retrieval_strength = Math.min(1, engram.activation.retrieval_strength + 0.05);
-    } else if (signal === "negative") {
-      engram.activation.retrieval_strength = Math.max(0, engram.activation.retrieval_strength - 0.1);
-    }
-    saveEngrams(this.paths.engrams, engrams);
+    withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const engram = engrams.find((e) => e.id === id);
+      if (!engram) throw new Error(`Engram not found: ${id}`);
+      if (!engram.feedback_signals) {
+        engram.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
+      }
+      engram.feedback_signals[signal] += 1;
+      if (signal === "positive") {
+        engram.activation.retrieval_strength = Math.min(1, engram.activation.retrieval_strength + 0.05);
+      } else if (signal === "negative") {
+        engram.activation.retrieval_strength = Math.max(0, engram.activation.retrieval_strength - 0.1);
+      }
+      saveEngrams(this.paths.engrams, engrams);
+      this._syncIndex();
+    });
+  }
+  /** Save extracted meta-engrams to the engram store. Skips IDs that already exist. */
+  saveMetaEngrams(metas) {
+    return withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const existingIds = new Set(engrams.map((e) => e.id));
+      let saved = 0;
+      let skipped = 0;
+      for (const meta of metas) {
+        if (existingIds.has(meta.id)) {
+          skipped++;
+        } else {
+          engrams.push(meta);
+          saved++;
+        }
+      }
+      if (saved > 0) {
+        saveEngrams(this.paths.engrams, engrams);
+        this._syncIndex();
+      }
+      return { saved, skipped };
+    });
+  }
+  /** Update an existing engram in the store by ID. Returns true if found and updated. */
+  updateEngram(updated) {
+    return withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const idx = engrams.findIndex((e) => e.id === updated.id);
+      if (idx === -1) return false;
+      engrams[idx] = updated;
+      saveEngrams(this.paths.engrams, engrams);
+      this._syncIndex();
+      return true;
+    });
   }
   /** Set engram status to 'retired'. */
   forget(id, reason) {
-    const engrams = loadEngrams(this.paths.engrams);
-    const engram = engrams.find((e) => e.id === id);
-    if (!engram) throw new Error(`Engram not found: ${id}`);
-    engram.status = "retired";
-    if (reason && !engram.rationale) {
-      engram.rationale = `Retired: ${reason}`;
+    withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const engram = engrams.find((e) => e.id === id);
+      if (!engram) throw new Error(`Engram not found: ${id}`);
+      engram.status = "retired";
+      if (reason && !engram.rationale) {
+        engram.rationale = `Retired: ${reason}`;
+      }
+      saveEngrams(this.paths.engrams, engrams);
+      this._syncIndex();
+    });
+  }
+  /** Remove retired engrams from storage. Returns count of removed and remaining. */
+  compact() {
+    return withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const active = engrams.filter((e) => e.status !== "retired");
+      const removed = engrams.length - active.length;
+      if (removed > 0) {
+        saveEngrams(this.paths.engrams, active);
+        this._syncIndex();
+      }
+      return { removed, remaining: active.length };
+    });
+  }
+  /** Rebuild SQLite index from YAML source of truth. Only works when index: true. */
+  reindex() {
+    if (!this.indexedStorage) {
+      this.indexedStorage = new IndexedStorage(this.paths.engrams, this.paths.db);
+    }
+    this.indexedStorage.reindex();
+  }
+  /** Sync SQLite index after YAML write (no-op if index disabled) */
+  _syncIndex() {
+    if (this.indexedStorage) {
+      this.indexedStorage.syncFromYaml();
     }
-    saveEngrams(this.paths.engrams, engrams);
   }
   /** Capture an episodic memory. */
   capture(summary, context) {
@@ -1472,6 +3106,7 @@ var Plur = class {
         const captured = match.slice(1).filter(Boolean).join(" ").trim();
         if (!captured || captured.length < 5) continue;
         if (seen.has(captured.toLowerCase())) continue;
+        if (!this.config.allow_secrets && detectSecrets(captured).length > 0) continue;
         seen.add(captured.toLowerCase());
         candidates.push({
           statement: captured,
@@ -1527,10 +3162,35 @@ var Plur = class {
   }
 };
 export {
+  DomainCoverageSchema,
+  EvidenceEntrySchema,
+  FalsificationSchema,
+  HierarchyPositionSchema,
+  IndexedStorage,
+  MetaConfidenceSchema,
+  MetaFieldSchema,
+  PLATITUDE_PATTERNS,
   Plur,
+  SessionBreadcrumbs,
+  StructuralTemplateSchema,
+  alignCluster,
+  analyzeStructure,
   checkForUpdate,
+  classifyPolarity,
   clearVersionCache,
+  clusterByStructure,
+  computeConfidence,
+  computeMetaConfidence,
+  confidenceBand,
   detectPlurStorage,
+  detectSecrets,
   engramSearchText,
-  getCachedUpdateCheck
+  extractMetaEngrams,
+  formulateMetaEngram,
+  generateGuardrails,
+  getCachedUpdateCheck,
+  isPlatitude,
+  organizeHierarchy,
+  tokenSimilarity,
+  validateMetaEngram
 };