@smartergpt/lexrunner 1.2.1 → 1.4.0

package/dist/frames/index.cjs

@@ -2026,7 +2026,7 @@ var require_thread_stream = __commonJS({
     var { version } = require_package();
     var { EventEmitter } = require("events");
     var { Worker } = require("worker_threads");
-    var { join: join9 } = require("path");
+    var { join: join10 } = require("path");
     var { pathToFileURL } = require("url");
     var { wait } = require_wait();
     var {
@@ -2077,7 +2077,7 @@ var require_thread_stream = __commonJS({
     function createWorker(stream, opts) {
       const { filename, workerData } = opts;
       const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-      const toExecute = bundlerOverrides["thread-stream-worker"] || join9(__dirname, "lib", "worker.js");
+      const toExecute = bundlerOverrides["thread-stream-worker"] || join10(__dirname, "lib", "worker.js");
       const worker = new Worker(toExecute, {
         ...opts.workerOpts,
         name: opts.workerOpts?.name || "thread-stream",
@@ -2543,9 +2543,9 @@ var require_transport = __commonJS({
   "node_modules/pino/lib/transport.js"(exports2, module2) {
     "use strict";
     var { createRequire: createRequire2 } = require("module");
-    var { existsSync: existsSync12 } = require("fs");
+    var { existsSync: existsSync13 } = require("fs");
     var getCallers = require_caller();
-    var { join: join9, isAbsolute: isAbsolute5, sep: sep2 } = require("path");
+    var { join: join10, isAbsolute: isAbsolute5, sep: sep2 } = require("path");
     var { fileURLToPath: fileURLToPath3 } = require("url");
     var sleep = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
@@ -2617,7 +2617,7 @@ var require_transport = __commonJS({
           return false;
         }
       }
-      return isAbsolute5(path4) && !existsSync12(path4);
+      return isAbsolute5(path4) && !existsSync13(path4);
     }
     function stripQuotes(value) {
       const first = value[0];
@@ -2698,7 +2698,7 @@ var require_transport = __commonJS({
         throw new Error("only one of target or targets can be specified");
       }
       if (targets) {
-        target = bundlerOverrides["pino-worker"] || join9(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join10(__dirname, "worker.js");
         options.targets = targets.filter((dest) => dest.target).map((dest) => {
           return {
             ...dest,
@@ -2716,7 +2716,7 @@ var require_transport = __commonJS({
           });
         });
       } else if (pipeline) {
-        target = bundlerOverrides["pino-worker"] || join9(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join10(__dirname, "worker.js");
         options.pipelines = [pipeline.map((dest) => {
           return {
             ...dest,
@@ -2739,7 +2739,7 @@ var require_transport = __commonJS({
           return origin;
         }
         if (origin === "pino/file") {
-          return join9(__dirname, "..", "file.js");
+          return join10(__dirname, "..", "file.js");
         }
         let fixTarget2;
         for (const filePath of callers) {
@@ -3720,7 +3720,7 @@ var require_safe_stable_stringify = __commonJS({
               return circularValue;
             }
             let res = "";
-            let join9 = ",";
+            let join10 = ",";
             const originalIndentation = indentation;
             if (Array.isArray(value)) {
               if (value.length === 0) {
@@ -3734,7 +3734,7 @@ var require_safe_stable_stringify = __commonJS({
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join9 = `,
+                join10 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -3742,13 +3742,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join9;
+                res += join10;
               }
               const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join9}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join10}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3769,7 +3769,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join9 = `,
+              join10 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -3783,13 +3783,13 @@ ${indentation}`;
               const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join9;
+                separator = join10;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join9;
+              separator = join10;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -3830,7 +3830,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join9 = ",";
+            let join10 = ",";
             if (Array.isArray(value)) {
               if (value.length === 0) {
                 return "[]";
@@ -3843,7 +3843,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join9 = `,
+                join10 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -3851,13 +3851,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join9;
+                res += join10;
               }
               const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join9}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join10}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3870,7 +3870,7 @@ ${originalIndentation}`;
             let whitespace = "";
             if (spacer !== "") {
               indentation += spacer;
-              join9 = `,
+              join10 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -3879,7 +3879,7 @@ ${indentation}`;
               const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join9;
+                separator = join10;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -3937,20 +3937,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join10 = `,
+              const join11 = `,
 ${indentation}`;
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
               let i = 0;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
                 res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join10;
+                res2 += join11;
               }
               const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
               res2 += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res2 += `${join10}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join11}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -3966,16 +3966,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join9 = `,
+            const join10 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join9, maximumBreadth);
+              res += stringifyTypedArray(value, join10, maximumBreadth);
               keys = keys.slice(value.length);
               maximumPropertiesToStringify -= value.length;
-              separator = join9;
+              separator = join10;
             }
             if (deterministic) {
               keys = sort(keys, comparator);
@@ -3986,13 +3986,13 @@ ${indentation}`;
               const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join9;
+                separator = join10;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join9;
+              separator = join10;
             }
             if (separator !== "") {
               res = `
@@ -7564,7 +7564,7 @@ var require_dist = __commonJS({
     function parse(stream, callback) {
       const parser = new parser_1.Parser();
       stream.on("data", (buffer) => parser.parse(buffer, callback));
-      return new Promise((resolve7) => stream.on("end", () => resolve7()));
+      return new Promise((resolve9) => stream.on("end", () => resolve9()));
     }
   }
 });
@@ -8326,12 +8326,12 @@ var require_client = __commonJS({
           this._connect(callback);
           return;
         }
-        return new this._Promise((resolve7, reject) => {
+        return new this._Promise((resolve9, reject) => {
           this._connect((error) => {
             if (error) {
               reject(error);
             } else {
-              resolve7(this);
+              resolve9(this);
             }
           });
         });
@@ -8678,8 +8678,8 @@ var require_client = __commonJS({
         } else {
           query = new Query2(config, values, callback);
           if (!query.callback) {
-            result = new this._Promise((resolve7, reject) => {
-              query.callback = (err, res) => err ? reject(err) : resolve7(res);
+            result = new this._Promise((resolve9, reject) => {
+              query.callback = (err, res) => err ? reject(err) : resolve9(res);
             }).catch((err) => {
               Error.captureStackTrace(err);
               throw err;
@@ -8763,8 +8763,8 @@ var require_client = __commonJS({
         if (cb) {
           this.connection.once("end", cb);
         } else {
-          return new this._Promise((resolve7) => {
-            this.connection.once("end", resolve7);
+          return new this._Promise((resolve9) => {
+            this.connection.once("end", resolve9);
           });
         }
       }
@@ -8813,8 +8813,8 @@ var require_pg_pool = __commonJS({
       const cb = function(err, client) {
         err ? rej(err) : res(client);
       };
-      const result = new Promise2(function(resolve7, reject) {
-        res = resolve7;
+      const result = new Promise2(function(resolve9, reject) {
+        res = resolve9;
         rej = reject;
       }).catch((err) => {
         Error.captureStackTrace(err);
@@ -8875,7 +8875,7 @@ var require_pg_pool = __commonJS({
         if (typeof Promise2.try === "function") {
           return Promise2.try(f);
         }
-        return new Promise2((resolve7) => resolve7(f()));
+        return new Promise2((resolve9) => resolve9(f()));
       }
       _isFull() {
         return this._clients.length >= this.options.max;
@@ -9268,8 +9268,8 @@ var require_query2 = __commonJS({
     NativeQuery.prototype._getPromise = function() {
       if (this._promise) return this._promise;
       this._promise = new Promise(
-        function(resolve7, reject) {
-          this._once("end", resolve7);
+        function(resolve9, reject) {
+          this._once("end", resolve9);
           this._once("error", reject);
         }.bind(this)
       );
@@ -9447,12 +9447,12 @@ var require_client2 = __commonJS({
         this._connect(callback);
         return;
       }
-      return new this._Promise((resolve7, reject) => {
+      return new this._Promise((resolve9, reject) => {
         this._connect((error) => {
           if (error) {
             reject(error);
           } else {
-            resolve7(this);
+            resolve9(this);
           }
         });
       });
@@ -9476,8 +9476,8 @@ var require_client2 = __commonJS({
         query = new NativeQuery(config, values, callback);
         if (!query.callback) {
           let resolveOut, rejectOut;
-          result = new this._Promise((resolve7, reject) => {
-            resolveOut = resolve7;
+          result = new this._Promise((resolve9, reject) => {
+            resolveOut = resolve9;
             rejectOut = reject;
           }).catch((err) => {
             Error.captureStackTrace(err);
@@ -9540,8 +9540,8 @@ var require_client2 = __commonJS({
       }
       let result;
       if (!cb) {
-        result = new this._Promise(function(resolve7, reject) {
-          cb = (err) => err ? reject(err) : resolve7();
+        result = new this._Promise(function(resolve9, reject) {
+          cb = (err) => err ? reject(err) : resolve9();
         });
       }
       this.native.end(function() {
@@ -10413,6 +10413,10 @@ var RUNTIME_OPERATION_CAPABILITIES = Object.freeze({
   FRAME_WRITE: "frame:write",
   FRAME_DELETE: "frame:delete",
   FRAME_ADMIN: "frame:admin",
+  BEHAVIOR_READ: "behavior:read",
+  BEHAVIOR_WRITE: "behavior:write",
+  BEHAVIOR_PROMOTE: "behavior:promote",
+  BEHAVIOR_PROVENANCE: "behavior:provenance",
   WORKSPACE_BIND: "workspace:bind",
   WORKSPACE_INSPECT: "workspace:inspect",
   WORKSPACE_REBIND: "workspace:rebind",
@@ -10447,6 +10451,10 @@ var CLI_CAPABILITIES = Object.freeze({
   "instructions:init": Object.freeze([]),
   "instructions:generate": Object.freeze([]),
   "instructions:check": Object.freeze([]),
+  "knowledge:check": Object.freeze([]),
+  "knowledge:index": Object.freeze([]),
+  "knowledge:context": Object.freeze([]),
+  "knowledge:explain": Object.freeze([]),
   "code-atlas": Object.freeze([]),
   turncost: Object.freeze([RUNTIME_OPERATION_CAPABILITIES.FRAME_READ]),
   dedupe: Object.freeze([
@@ -10539,6 +10547,10 @@ var CAPABILITIES = Object.freeze([
   RUNTIME_OPERATION_CAPABILITIES.FRAME_READ,
   RUNTIME_OPERATION_CAPABILITIES.FRAME_WRITE,
   RUNTIME_OPERATION_CAPABILITIES.FRAME_DELETE,
+  RUNTIME_OPERATION_CAPABILITIES.BEHAVIOR_READ,
+  RUNTIME_OPERATION_CAPABILITIES.BEHAVIOR_WRITE,
+  RUNTIME_OPERATION_CAPABILITIES.BEHAVIOR_PROMOTE,
+  RUNTIME_OPERATION_CAPABILITIES.BEHAVIOR_PROVENANCE,
   RUNTIME_OPERATION_CAPABILITIES.WORKSPACE_BIND,
   RUNTIME_OPERATION_CAPABILITIES.WORKSPACE_INSPECT,
   RUNTIME_OPERATION_CAPABILITIES.WORKSPACE_REBIND,
@@ -10566,6 +10578,91 @@ var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.ex
 var import_node_crypto7 = require("crypto");
 var import_node_fs3 = require("fs");
 
+// node_modules/@smartergpt/lex/dist/knowledge/types.js
+var import_zod2 = require("zod");
+var KNOWLEDGE_FRAME_SCHEMA_VERSION = 1;
+var KnowledgeFrameTypeSchema = import_zod2.z.enum(["hypothesis", "evidence", "seam", "probe"]);
+var KnowledgeFrameLifecycleSchema = import_zod2.z.enum(["draft", "active", "retired"]);
+var KnowledgeFrameVisibilitySchema = import_zod2.z.literal("workspace");
+var KnowledgeConfidenceSchema = import_zod2.z.enum(["low", "medium", "high"]);
+var KnowledgeFrameIdSchema = import_zod2.z.string().min(1).max(200).regex(/^[a-z0-9][a-z0-9._/-]*$/, "must be a stable lowercase logical ID");
+var KnowledgeRelationSchema = import_zod2.z.object({
+  type: import_zod2.z.string().min(1).max(80).regex(/^[a-z][a-z0-9-]*$/),
+  target: KnowledgeFrameIdSchema
+}).strict();
+var KnowledgeProvenanceSchema = import_zod2.z.object({
+  repositoryKey: import_zod2.z.string().min(1).max(200),
+  path: import_zod2.z.string().min(1).max(512),
+  anchor: KnowledgeFrameIdSchema,
+  startLine: import_zod2.z.number().int().positive(),
+  endLine: import_zod2.z.number().int().positive(),
+  startByte: import_zod2.z.number().int().nonnegative(),
+  endByte: import_zod2.z.number().int().nonnegative(),
+  sourceDigest: import_zod2.z.string().regex(/^sha256:[a-f0-9]{64}$/),
+  sourceLayer: import_zod2.z.enum(["commit", "working-tree"]),
+  commitSha: import_zod2.z.string().regex(/^[a-f0-9]{40}$/),
+  baseCommitSha: import_zod2.z.string().regex(/^[a-f0-9]{40}$/).optional(),
+  branch: import_zod2.z.string().min(1).max(255).optional(),
+  compilerVersion: import_zod2.z.string().min(1),
+  snapshotId: import_zod2.z.string().regex(/^sha256:[a-f0-9]{64}$/)
+}).strict();
+var CommonKnowledgeFrameSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.literal(KNOWLEDGE_FRAME_SCHEMA_VERSION),
+  id: KnowledgeFrameIdSchema,
+  lifecycle: KnowledgeFrameLifecycleSchema,
+  visibility: KnowledgeFrameVisibilitySchema,
+  title: import_zod2.z.string().min(1).max(300),
+  body: import_zod2.z.string().min(1).max(65536),
+  relations: import_zod2.z.array(KnowledgeRelationSchema).max(100),
+  provenance: KnowledgeProvenanceSchema,
+  recordDigest: import_zod2.z.string().regex(/^sha256:[a-f0-9]{64}$/)
+});
+var HypothesisKnowledgeFrameSchema = CommonKnowledgeFrameSchema.extend({
+  type: import_zod2.z.literal("hypothesis"),
+  confidence: KnowledgeConfidenceSchema
+}).strict();
+var NonHypothesisKnowledgeFrameSchema = (type) => CommonKnowledgeFrameSchema.extend({ type: import_zod2.z.literal(type) }).strict();
+var KnowledgeFrameV1Schema = import_zod2.z.discriminatedUnion("type", [
+  HypothesisKnowledgeFrameSchema,
+  NonHypothesisKnowledgeFrameSchema("evidence"),
+  NonHypothesisKnowledgeFrameSchema("seam"),
+  NonHypothesisKnowledgeFrameSchema("probe")
+]);
+
+// node_modules/@smartergpt/lex/dist/knowledge/compiler.js
+var import_node_crypto8 = require("crypto");
+var import_node_path4 = require("path");
+var import_yaml = require("yaml");
+var import_zod3 = require("zod");
+var MarkerSchema = import_zod3.z.object({
+  id: KnowledgeFrameIdSchema,
+  type: KnowledgeFrameTypeSchema,
+  lifecycle: KnowledgeFrameLifecycleSchema,
+  confidence: KnowledgeConfidenceSchema.optional(),
+  visibility: KnowledgeFrameVisibilitySchema.default("workspace"),
+  relations: import_zod3.z.array(KnowledgeRelationSchema).max(100).default([])
+}).strict().superRefine((marker, context) => {
+  if (marker.type === "hypothesis" && marker.confidence === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["confidence"],
+      message: "is required for hypotheses"
+    });
+  }
+  if (marker.type !== "hypothesis" && marker.confidence !== void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["confidence"],
+      message: `is not valid for ${marker.type} records`
+    });
+  }
+});
+
+// node_modules/@smartergpt/lex/dist/knowledge/store.js
+var import_better_sqlite3_multiple_ciphers2 = __toESM(require("better-sqlite3-multiple-ciphers"), 1);
+var import_node_fs5 = require("fs");
+var import_node_path6 = require("path");
+
 // node_modules/@smartergpt/lex/dist/memory/store/db.js
 var import_better_sqlite3_multiple_ciphers = __toESM(require("better-sqlite3-multiple-ciphers"), 1);
 
@@ -10727,7 +10824,7 @@ var fs = __toESM(require("fs"), 1);
 
 // node_modules/@smartergpt/lex/dist/shared/config/contained-path.js
 var import_node_fs4 = require("fs");
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 
 // node_modules/@smartergpt/lex/dist/shared/config/index.js
 var logger = getLogger("config");
@@ -10771,6 +10868,37 @@ function resolveCallerWorkspaceRoot(options = {}) {
   };
 }
 
+// node_modules/@smartergpt/lex/dist/knowledge/workspace.js
+var import_node_crypto9 = require("crypto");
+var import_node_fs6 = require("fs");
+var import_node_path7 = require("path");
+var import_node_child_process2 = require("child_process");
+var import_yaml2 = require("yaml");
+
+// node_modules/@smartergpt/lex/dist/shared/config/lex-yaml-schema.js
+var import_zod4 = require("zod");
+var ProjectionsSchema = import_zod4.z.object({
+  copilot: import_zod4.z.boolean().default(true),
+  cursor: import_zod4.z.boolean().default(true)
+});
+var InstructionsSchema = import_zod4.z.object({
+  canonical: import_zod4.z.string().default(".smartergpt/instructions/lex.md"),
+  projections: ProjectionsSchema.optional()
+});
+var REPO_RELATIVE_SOURCE_PATH = /^(?!\/)(?![a-z]:\/)(?!.*(?:^|\/)\.\.(?:\/|$))(?!.*[*?\[\]{}!]).+\.md$/i;
+var KnowledgeSchema = import_zod4.z.object({
+  sources: import_zod4.z.array(import_zod4.z.string().min(1).max(512).transform((value) => value.replaceAll("\\", "/")).refine((value) => REPO_RELATIVE_SOURCE_PATH.test(value), {
+    message: "must be an exact repo-relative Markdown path without traversal or glob syntax"
+  })).max(256).refine((sources) => new Set(sources).size === sources.length, {
+    message: "must not contain duplicate source paths"
+  })
+});
+var LexYamlSchema = import_zod4.z.object({
+  version: import_zod4.z.literal(1),
+  instructions: InstructionsSchema.optional(),
+  knowledge: KnowledgeSchema.optional()
+});
+
 // node_modules/@smartergpt/lex/dist/memory/store/scoped-frame-store.js
 var FRAME_STORE_CAPABILITIES = Object.freeze({
   READ: "frame:read",
@@ -10785,107 +10913,124 @@ var SCOPED_FRAME_STORE_ERROR_CODES = Object.freeze({
   STORE_CLOSED: "LEX_FRAME_STORE_CLOSED"
 });
 
+// node_modules/@smartergpt/lex/dist/memory/store/behavioral-store.js
+var import_node_crypto10 = require("crypto");
+var BEHAVIORAL_STORE_CAPABILITIES = Object.freeze({
+  READ: "behavior:read",
+  WRITE: "behavior:write",
+  PROMOTE: "behavior:promote",
+  PROVENANCE: "behavior:provenance"
+});
+var BEHAVIORAL_STORE_ERROR_CODES = Object.freeze({
+  INVALID_BINDING: "LEX_BEHAVIORAL_INVALID_BINDING",
+  CAPABILITY_MISSING: "LEX_BEHAVIORAL_CAPABILITY_MISSING",
+  SCOPE_EXPIRED: "LEX_BEHAVIORAL_SCOPE_EXPIRED",
+  STORE_CLOSED: "LEX_BEHAVIORAL_STORE_CLOSED",
+  INVALID_INPUT: "LEX_BEHAVIORAL_INVALID_INPUT",
+  REVISION_CONFLICT: "LEX_BEHAVIORAL_REVISION_CONFLICT"
+});
+
 // node_modules/@smartergpt/lex/dist/memory/frames/types.js
-var import_zod2 = require("zod");
-var FrameSpendMetadata = import_zod2.z.object({
-  prompts: import_zod2.z.number().optional(),
-  tokens_estimated: import_zod2.z.number().optional()
+var import_zod5 = require("zod");
+var FrameSpendMetadata = import_zod5.z.object({
+  prompts: import_zod5.z.number().optional(),
+  tokens_estimated: import_zod5.z.number().optional()
 });
-var ModuleAttribution = import_zod2.z.object({
-  mode: import_zod2.z.enum(["explicit", "inferred", "fallback"]),
-  confidence: import_zod2.z.enum(["high", "medium", "low"]),
-  evidence: import_zod2.z.array(import_zod2.z.string())
+var ModuleAttribution = import_zod5.z.object({
+  mode: import_zod5.z.enum(["explicit", "inferred", "fallback"]),
+  confidence: import_zod5.z.enum(["high", "medium", "low"]),
+  evidence: import_zod5.z.array(import_zod5.z.string())
 });
-var TurnCostComponent = import_zod2.z.object({
-  latency: import_zod2.z.number().describe("Response time in ms"),
-  contextReset: import_zod2.z.number().describe("Tokens for context re-establishment"),
-  renegotiation: import_zod2.z.number().describe("Count of clarification turns"),
-  tokenBloat: import_zod2.z.number().describe("Excess tokens beyond minimum"),
-  attentionSwitch: import_zod2.z.number().describe("Human intervention count")
+var TurnCostComponent = import_zod5.z.object({
+  latency: import_zod5.z.number().describe("Response time in ms"),
+  contextReset: import_zod5.z.number().describe("Tokens for context re-establishment"),
+  renegotiation: import_zod5.z.number().describe("Count of clarification turns"),
+  tokenBloat: import_zod5.z.number().describe("Excess tokens beyond minimum"),
+  attentionSwitch: import_zod5.z.number().describe("Human intervention count")
 });
-var TurnCostWeights = import_zod2.z.object({
-  lambda: import_zod2.z.number().default(0.1).describe("Latency weight"),
-  gamma: import_zod2.z.number().default(0.2).describe("Context reset weight"),
-  rho: import_zod2.z.number().default(0.3).describe("Renegotiation weight"),
-  tau: import_zod2.z.number().default(0.1).describe("Token bloat weight"),
-  alpha: import_zod2.z.number().default(0.3).describe("Attention switch weight")
+var TurnCostWeights = import_zod5.z.object({
+  lambda: import_zod5.z.number().default(0.1).describe("Latency weight"),
+  gamma: import_zod5.z.number().default(0.2).describe("Context reset weight"),
+  rho: import_zod5.z.number().default(0.3).describe("Renegotiation weight"),
+  tau: import_zod5.z.number().default(0.1).describe("Token bloat weight"),
+  alpha: import_zod5.z.number().default(0.3).describe("Attention switch weight")
 });
-var TurnCost = import_zod2.z.object({
+var TurnCost = import_zod5.z.object({
   components: TurnCostComponent,
   weights: TurnCostWeights.optional(),
-  weightedScore: import_zod2.z.number().optional().describe("Calculated weighted Turn Cost score"),
-  sessionId: import_zod2.z.string().optional().describe("Session identifier for Turn Cost tracking"),
-  timestamp: import_zod2.z.string().optional().describe("ISO 8601 timestamp of measurement")
+  weightedScore: import_zod5.z.number().optional().describe("Calculated weighted Turn Cost score"),
+  sessionId: import_zod5.z.string().optional().describe("Session identifier for Turn Cost tracking"),
+  timestamp: import_zod5.z.string().optional().describe("ISO 8601 timestamp of measurement")
 });
-var FrameStatusSnapshot = import_zod2.z.object({
-  next_action: import_zod2.z.string(),
-  blockers: import_zod2.z.array(import_zod2.z.string()).optional(),
-  merge_blockers: import_zod2.z.array(import_zod2.z.string()).optional(),
-  tests_failing: import_zod2.z.array(import_zod2.z.string()).optional()
+var FrameStatusSnapshot = import_zod5.z.object({
+  next_action: import_zod5.z.string(),
+  blockers: import_zod5.z.array(import_zod5.z.string()).optional(),
+  merge_blockers: import_zod5.z.array(import_zod5.z.string()).optional(),
+  tests_failing: import_zod5.z.array(import_zod5.z.string()).optional()
 });
-var CapabilityTier = import_zod2.z.enum(["senior", "mid", "junior"]);
-var TaskComplexity = import_zod2.z.object({
+var CapabilityTier = import_zod5.z.enum(["senior", "mid", "junior"]);
+var TaskComplexity = import_zod5.z.object({
   tier: CapabilityTier,
-  assignedModel: import_zod2.z.string().optional(),
-  actualModel: import_zod2.z.string().optional(),
+  assignedModel: import_zod5.z.string().optional(),
+  actualModel: import_zod5.z.string().optional(),
   // What model actually did the work
-  escalated: import_zod2.z.boolean().optional(),
-  escalationReason: import_zod2.z.string().optional(),
-  retryCount: import_zod2.z.number().optional(),
-  tierMismatch: import_zod2.z.boolean().optional()
+  escalated: import_zod5.z.boolean().optional(),
+  escalationReason: import_zod5.z.string().optional(),
+  retryCount: import_zod5.z.number().optional(),
+  tierMismatch: import_zod5.z.boolean().optional()
   // Did actual tier differ from suggested?
 });
-var Frame = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  timestamp: import_zod2.z.string(),
+var Frame = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  timestamp: import_zod5.z.string(),
   // ISO 8601
-  branch: import_zod2.z.string(),
-  jira: import_zod2.z.string().optional(),
-  module_scope: import_zod2.z.array(import_zod2.z.string()),
+  branch: import_zod5.z.string(),
+  jira: import_zod5.z.string().optional(),
+  module_scope: import_zod5.z.array(import_zod5.z.string()),
   // Must match lexmap.policy.json module IDs (THE CRITICAL RULE)
-  summary_caption: import_zod2.z.string(),
-  reference_point: import_zod2.z.string(),
+  summary_caption: import_zod5.z.string(),
+  reference_point: import_zod5.z.string(),
   // Human-memorable anchor phrase
   status_snapshot: FrameStatusSnapshot,
-  keywords: import_zod2.z.array(import_zod2.z.string()).optional(),
-  atlas_frame_id: import_zod2.z.string().optional(),
+  keywords: import_zod5.z.array(import_zod5.z.string()).optional(),
+  atlas_frame_id: import_zod5.z.string().optional(),
   // Link to Atlas Frame (spatial neighborhood)
-  feature_flags: import_zod2.z.array(import_zod2.z.string()).optional(),
-  permissions: import_zod2.z.array(import_zod2.z.string()).optional(),
+  feature_flags: import_zod5.z.array(import_zod5.z.string()).optional(),
+  permissions: import_zod5.z.array(import_zod5.z.string()).optional(),
   module_attribution: ModuleAttribution.optional(),
-  image_ids: import_zod2.z.array(import_zod2.z.string()).optional(),
+  image_ids: import_zod5.z.array(import_zod5.z.string()).optional(),
   // Merge-weave metadata (v2)
-  runId: import_zod2.z.string().optional(),
-  planHash: import_zod2.z.string().optional(),
+  runId: import_zod5.z.string().optional(),
+  planHash: import_zod5.z.string().optional(),
   spend: FrameSpendMetadata.optional(),
   // OAuth2/JWT user isolation (v3)
-  userId: import_zod2.z.string().optional(),
+  userId: import_zod5.z.string().optional(),
   // LexRunner structured metadata (v3)
-  executorRole: import_zod2.z.string().optional(),
-  toolCalls: import_zod2.z.array(import_zod2.z.string()).optional(),
-  guardrailProfile: import_zod2.z.string().optional(),
+  executorRole: import_zod5.z.string().optional(),
+  toolCalls: import_zod5.z.array(import_zod5.z.string()).optional(),
+  guardrailProfile: import_zod5.z.string().optional(),
   // Turn Cost metrics (v4)
   turnCost: TurnCost.optional(),
   // Capability tier classification (v4)
   capabilityTier: CapabilityTier.optional(),
   taskComplexity: TaskComplexity.optional(),
   // Deduplication metadata (v5)
-  superseded_by: import_zod2.z.string().optional(),
-  merged_from: import_zod2.z.array(import_zod2.z.string()).optional(),
+  superseded_by: import_zod5.z.string().optional(),
+  merged_from: import_zod5.z.array(import_zod5.z.string()).optional(),
   // Contradiction metadata (v6)
-  contradiction_resolution: import_zod2.z.object({
-    type: import_zod2.z.enum(["supersede", "scope", "keep-both", "cancel"]),
-    contradicts_frame_id: import_zod2.z.string(),
-    scope: import_zod2.z.string().optional(),
-    note: import_zod2.z.string().optional()
+  contradiction_resolution: import_zod5.z.object({
+    type: import_zod5.z.enum(["supersede", "scope", "keep-both", "cancel"]),
+    contradicts_frame_id: import_zod5.z.string(),
+    scope: import_zod5.z.string().optional(),
+    note: import_zod5.z.string().optional()
   }).optional()
 });
 
 // node_modules/@smartergpt/lex/dist/shared/config/store-identity.js
-var import_node_crypto8 = require("crypto");
-var import_node_fs5 = require("fs");
+var import_node_crypto11 = require("crypto");
+var import_node_fs7 = require("fs");
 var import_node_os = require("os");
-var import_node_path5 = require("path");
+var import_node_path8 = require("path");
 
 // node_modules/@smartergpt/lex/dist/memory/store/code-unit-queries.js
 var logger2 = getNDJSONLogger("memory/store/code-unit-queries");
@@ -10894,7 +11039,7 @@ var logger2 = getNDJSONLogger("memory/store/code-unit-queries");
 var logger3 = getNDJSONLogger("memory/store/code-atlas-runs");
 
 // node_modules/@smartergpt/lex/dist/memory/store/durable-frame-metadata.js
-var import_zod3 = require("zod");
+var import_zod6 = require("zod");
 var DURABLE_FRAME_METADATA_VERSION = 1;
 var DurableFrameMetadata = Frame.pick({
   image_ids: true,
@@ -10905,7 +11050,7 @@ var DurableFrameMetadata = Frame.pick({
   capabilityTier: true,
   taskComplexity: true,
   contradiction_resolution: true
-}).extend({ schemaVersion: import_zod3.z.literal(DURABLE_FRAME_METADATA_VERSION) }).strict();
+}).extend({ schemaVersion: import_zod6.z.literal(DURABLE_FRAME_METADATA_VERSION) }).strict();
 
 // node_modules/@smartergpt/lex/dist/memory/store/sqlite/scoped-schema.js
 var SCOPED_SQLITE_ERROR_CODES = Object.freeze({
@@ -10990,9 +11135,14 @@ var FRAME_UPSERT_SQL = `
     frame_metadata = excluded.frame_metadata
 `;
 
+// node_modules/@smartergpt/lex/dist/memory/store/sqlite/behavioral-store.js
+var import_node_fs8 = require("fs");
+var import_node_path9 = require("path");
+var import_better_sqlite3_multiple_ciphers3 = __toESM(require("better-sqlite3-multiple-ciphers"), 1);
+
 // node_modules/@smartergpt/lex/dist/memory/store/sqlite/scoped-migration.js
-var import_node_crypto9 = require("crypto");
-var import_node_fs6 = require("fs");
+var import_node_crypto12 = require("crypto");
+var import_node_fs9 = require("fs");
 var LEGACY_FRAME_COLUMNS = Object.freeze([
   "id",
   "timestamp",
@@ -11043,7 +11193,7 @@ var MIGRATION_ACTIONS = Object.freeze([
 ]);
 
 // node_modules/@smartergpt/lex/dist/memory/store/postgres/frame-store.js
-var import_node_crypto10 = require("crypto");
+var import_node_crypto13 = require("crypto");
 
 // node_modules/pg/esm/index.mjs
 var import_lib = __toESM(require_lib2(), 1);
@@ -11067,7 +11217,56 @@ var COMPATIBILITY_OBJECTS = Object.freeze({
 });
 
 // node_modules/@smartergpt/lex/dist/memory/store/postgres/scoped-frame-store.js
-var import_node_crypto11 = require("crypto");
+var import_node_crypto14 = require("crypto");
+
+// node_modules/@smartergpt/lex/dist/memory/store/postgres/behavioral-store.js
+var import_node_crypto15 = require("crypto");
+var RELATIONS = Object.freeze([
+  "lex_behavioral_persona_revisions",
+  "lex_behavioral_rule_revisions",
+  "lex_behavioral_evidence",
+  "lex_behavioral_promotions",
+  "lex_behavioral_write_receipts"
+]);
+
+// node_modules/@smartergpt/lex/dist/memory/store/postgres/quarantine-recovery.js
+var import_node_crypto16 = require("crypto");
+var QUARANTINE_RECOVERY_ERROR_CODES = Object.freeze({
+  INVALID_INPUT: "LEX_QUARANTINE_RECOVERY_INVALID_INPUT",
+  UNSUPPORTED_SCHEMA: "LEX_QUARANTINE_RECOVERY_UNSUPPORTED_SCHEMA",
+  DUPLICATE_SOURCE: "LEX_QUARANTINE_RECOVERY_DUPLICATE_SOURCE",
+  PARTIAL_SELECTION: "LEX_QUARANTINE_RECOVERY_PARTIAL_SELECTION",
+  STALE_INVENTORY: "LEX_QUARANTINE_RECOVERY_STALE_INVENTORY",
+  AUTHORITY_MISSING: "LEX_QUARANTINE_RECOVERY_AUTHORITY_MISSING",
+  DESTINATION_COLLISION: "LEX_QUARANTINE_RECOVERY_DESTINATION_COLLISION",
+  ADMINISTRATION_CLOSED: "LEX_QUARANTINE_RECOVERY_ADMINISTRATION_CLOSED",
+  RECOVERY_NOT_FOUND: "LEX_QUARANTINE_RECOVERY_NOT_FOUND",
+  RECOVERY_ALREADY_CLEANED: "LEX_QUARANTINE_RECOVERY_ALREADY_CLEANED"
+});
+
+// node_modules/@smartergpt/lex/dist/memory/store/postgres/quarantine-recovery-administration.js
+var LEGACY_COLUMNS = Object.freeze([
+  ["id", "text", "NO"],
+  ["timestamp", "text", "NO"],
+  ["branch", "text", "NO"],
+  ["jira", "text", "YES"],
+  ["module_scope", "_text", "NO"],
+  ["summary_caption", "text", "NO"],
+  ["reference_point", "text", "NO"],
+  ["status_snapshot", "jsonb", "NO"],
+  ["keywords", "_text", "YES"],
+  ["atlas_frame_id", "text", "YES"],
+  ["feature_flags", "_text", "YES"],
+  ["permissions", "_text", "YES"],
+  ["module_attribution", "jsonb", "YES"],
+  ["run_id", "text", "YES"],
+  ["plan_hash", "text", "YES"],
+  ["spend", "jsonb", "YES"],
+  ["user_id", "text", "YES"],
+  ["superseded_by", "text", "YES"],
+  ["merged_from", "_text", "YES"],
+  ["search_vector", "tsvector", "NO"]
+]);
 
 // node_modules/@smartergpt/lex/dist/memory/store/queries.js
 var logger4 = getNDJSONLogger("memory/store");
@@ -11103,28 +11302,28 @@ var import_fs3 = require("fs");
 var import_path3 = require("path");
 
 // node_modules/@smartergpt/lex/dist/shared/errors/ax-error.js
-var import_zod4 = require("zod");
-var AXErrorSchema = import_zod4.z.object({
+var import_zod7 = require("zod");
+var AXErrorSchema = import_zod7.z.object({
   /**
    * Stable error code in UPPER_SNAKE_CASE
    * Must be unique and documented in error-codes.ts
    */
-  code: import_zod4.z.string().regex(/^[A-Z][A-Z0-9_]*$/, "Error code must be UPPER_SNAKE_CASE (e.g., FRAME_NOT_FOUND)"),
+  code: import_zod7.z.string().regex(/^[A-Z][A-Z0-9_]*$/, "Error code must be UPPER_SNAKE_CASE (e.g., FRAME_NOT_FOUND)"),
   /**
    * Human-readable error message
    * Should be concise but descriptive
    */
-  message: import_zod4.z.string().min(1, "Message is required"),
+  message: import_zod7.z.string().min(1, "Message is required"),
   /**
    * Optional structured context about the error
    * Include relevant IDs, paths, or values that help diagnose
    */
-  context: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional(),
+  context: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional(),
   /**
    * Recovery suggestions - at least one required
    * These tell the agent what to try next
    */
-  nextActions: import_zod4.z.array(import_zod4.z.string().min(1)).min(1, "At least one nextAction is required")
+  nextActions: import_zod7.z.array(import_zod7.z.string().min(1)).min(1, "At least one nextAction is required")
 });
 function createAXError(code, message, nextActions, context) {
   return AXErrorSchema.parse({ code, message, nextActions, context });
@@ -11383,9 +11582,9 @@ function extractCanonicalIds(resolutions) {
 }
 
 // src/util/hash.ts
-var import_node_crypto12 = require("crypto");
-var import_node_fs7 = __toESM(require("fs"), 1);
-var sha256 = (buf) => (0, import_node_crypto12.createHash)("sha256").update(buf).digest("hex");
+var import_node_crypto17 = require("crypto");
+var import_node_fs10 = __toESM(require("fs"), 1);
+var sha256 = (buf) => (0, import_node_crypto17.createHash)("sha256").update(buf).digest("hex");
 
 // src/frames/storage.ts
 var fs4 = __toESM(require("fs"), 1);