clawvault 3.1.0 → 3.2.1

package/dist/plugin/index.js

@@ -1,110 +1,3610 @@
 import {
-  buildFullContext,
-  buildPreferenceContext,
-  buildSessionRecap,
-  formatMemoriesForContext,
-  formatSearchResults,
-  scanVaultFiles
-} from "../chunk-CMB7UL7C.js";
-import {
-  detectCategory,
-  extractObservations,
-  extractSearchTerms,
-  isObservable,
-  processMessageForObservations
-} from "../chunk-6U6MK36V.js";
-import {
-  appendToLedger,
-  batchWriteObservations,
-  ensureVaultStructure,
-  writeObservation,
-  writeVaultFile
-} from "../chunk-MFM6K7PU.js";
-import {
-  classifyText,
-  getAllSchemas,
-  getSchema,
-  getSchemaNames,
-  initializeTemplateRegistry
-} from "../chunk-GQSLDZTS.js";
-import {
-  __require
-} from "../chunk-3RG5ZIWI.js";
+  __commonJS,
+  __toESM
+} from "../chunk-U67V476Y.js";
+
+// node_modules/@sinclair/typebox/typebox.js
+var require_typebox = __commonJS({
+  "node_modules/@sinclair/typebox/typebox.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Modifier = void 0;
+    exports.Modifier = /* @__PURE__ */ Symbol.for("TypeBox.Modifier");
+    exports.Hint = /* @__PURE__ */ Symbol.for("TypeBox.Hint");
+    exports.Kind = /* @__PURE__ */ Symbol.for("TypeBox.Kind");
+    exports.PatternBoolean = "(true|false)";
+    exports.PatternNumber = "(0|[1-9][0-9]*)";
+    exports.PatternString = "(.*)";
+    exports.PatternBooleanExact = `^${exports.PatternBoolean}$`;
+    exports.PatternNumberExact = `^${exports.PatternNumber}$`;
+    exports.PatternStringExact = `^${exports.PatternString}$`;
+    var TypeRegistry;
+    (function(TypeRegistry2) {
+      const map = /* @__PURE__ */ new Map();
+      function Entries() {
+        return new Map(map);
+      }
+      TypeRegistry2.Entries = Entries;
+      function Clear() {
+        return map.clear();
+      }
+      TypeRegistry2.Clear = Clear;
+      function Has(kind) {
+        return map.has(kind);
+      }
+      TypeRegistry2.Has = Has;
+      function Set2(kind, func) {
+        map.set(kind, func);
+      }
+      TypeRegistry2.Set = Set2;
+      function Get(kind) {
+        return map.get(kind);
+      }
+      TypeRegistry2.Get = Get;
+    })(TypeRegistry = exports.TypeRegistry || (exports.TypeRegistry = {}));
+    var FormatRegistry;
+    (function(FormatRegistry2) {
+      const map = /* @__PURE__ */ new Map();
+      function Entries() {
+        return new Map(map);
+      }
+      FormatRegistry2.Entries = Entries;
+      function Clear() {
+        return map.clear();
+      }
+      FormatRegistry2.Clear = Clear;
+      function Has(format) {
+        return map.has(format);
+      }
+      FormatRegistry2.Has = Has;
+      function Set2(format, func) {
+        map.set(format, func);
+      }
+      FormatRegistry2.Set = Set2;
+      function Get(format) {
+        return map.get(format);
+      }
+      FormatRegistry2.Get = Get;
+    })(FormatRegistry = exports.FormatRegistry || (exports.FormatRegistry = {}));
+    var TypeGuardUnknownTypeError = class extends Error {
+      constructor(schema) {
+        super("TypeGuard: Unknown type");
+        this.schema = schema;
+      }
+    };
+    exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
+    var TypeGuard;
+    (function(TypeGuard2) {
+      function IsObject(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+      }
+      function IsArray(value) {
+        return typeof value === "object" && value !== null && Array.isArray(value);
+      }
+      function IsPattern(value) {
+        try {
+          new RegExp(value);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      function IsControlCharacterFree(value) {
+        if (typeof value !== "string")
+          return false;
+        for (let i = 0; i < value.length; i++) {
+          const code = value.charCodeAt(i);
+          if (code >= 7 && code <= 13 || code === 27 || code === 127) {
+            return false;
+          }
+        }
+        return true;
+      }
+      function IsBigInt(value) {
+        return typeof value === "bigint";
+      }
+      function IsString(value) {
+        return typeof value === "string";
+      }
+      function IsNumber(value) {
+        return typeof value === "number" && globalThis.Number.isFinite(value);
+      }
+      function IsBoolean(value) {
+        return typeof value === "boolean";
+      }
+      function IsOptionalBigInt(value) {
+        return value === void 0 || value !== void 0 && IsBigInt(value);
+      }
+      function IsOptionalNumber(value) {
+        return value === void 0 || value !== void 0 && IsNumber(value);
+      }
+      function IsOptionalBoolean(value) {
+        return value === void 0 || value !== void 0 && IsBoolean(value);
+      }
+      function IsOptionalString(value) {
+        return value === void 0 || value !== void 0 && IsString(value);
+      }
+      function IsOptionalPattern(value) {
+        return value === void 0 || value !== void 0 && IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
+      }
+      function IsOptionalFormat(value) {
+        return value === void 0 || value !== void 0 && IsString(value) && IsControlCharacterFree(value);
+      }
+      function IsOptionalSchema(value) {
+        return value === void 0 || TSchema(value);
+      }
+      function TAny(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Any" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TAny = TAny;
+      function TArray(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Array" && schema.type === "array" && IsOptionalString(schema.$id) && TSchema(schema.items) && IsOptionalNumber(schema.minItems) && IsOptionalNumber(schema.maxItems) && IsOptionalBoolean(schema.uniqueItems);
+      }
+      TypeGuard2.TArray = TArray;
+      function TBigInt(schema) {
+        return TKind(schema) && schema[exports.Kind] === "BigInt" && schema.type === "null" && schema.typeOf === "BigInt" && IsOptionalString(schema.$id) && IsOptionalBigInt(schema.multipleOf) && IsOptionalBigInt(schema.minimum) && IsOptionalBigInt(schema.maximum) && IsOptionalBigInt(schema.exclusiveMinimum) && IsOptionalBigInt(schema.exclusiveMaximum);
+      }
+      TypeGuard2.TBigInt = TBigInt;
+      function TBoolean(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Boolean" && schema.type === "boolean" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TBoolean = TBoolean;
+      function TConstructor(schema) {
+        if (!(TKind(schema) && schema[exports.Kind] === "Constructor" && schema.type === "object" && schema.instanceOf === "Constructor" && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
+          return false;
+        }
+        for (const parameter of schema.parameters) {
+          if (!TSchema(parameter))
+            return false;
+        }
+        return true;
+      }
+      TypeGuard2.TConstructor = TConstructor;
+      function TDate(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Date" && schema.type === "object" && schema.instanceOf === "Date" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minimumTimestamp) && IsOptionalNumber(schema.maximumTimestamp) && IsOptionalNumber(schema.exclusiveMinimumTimestamp) && IsOptionalNumber(schema.exclusiveMaximumTimestamp);
+      }
+      TypeGuard2.TDate = TDate;
+      function TFunction(schema) {
+        if (!(TKind(schema) && schema[exports.Kind] === "Function" && schema.type === "object" && schema.instanceOf === "Function" && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
+          return false;
+        }
+        for (const parameter of schema.parameters) {
+          if (!TSchema(parameter))
+            return false;
+        }
+        return true;
+      }
+      TypeGuard2.TFunction = TFunction;
+      function TInteger(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Integer" && schema.type === "integer" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.multipleOf) && IsOptionalNumber(schema.minimum) && IsOptionalNumber(schema.maximum) && IsOptionalNumber(schema.exclusiveMinimum) && IsOptionalNumber(schema.exclusiveMaximum);
+      }
+      TypeGuard2.TInteger = TInteger;
+      function TIntersect(schema) {
+        if (!(TKind(schema) && schema[exports.Kind] === "Intersect" && IsArray(schema.allOf) && IsOptionalString(schema.type) && (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) && IsOptionalString(schema.$id))) {
+          return false;
+        }
+        if ("type" in schema && schema.type !== "object") {
+          return false;
+        }
+        for (const inner of schema.allOf) {
+          if (!TSchema(inner))
+            return false;
+        }
+        return true;
+      }
+      TypeGuard2.TIntersect = TIntersect;
+      function TKind(schema) {
+        return IsObject(schema) && exports.Kind in schema && typeof schema[exports.Kind] === "string";
+      }
+      TypeGuard2.TKind = TKind;
+      function TLiteral(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Literal" && IsOptionalString(schema.$id) && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const) || IsBigInt(schema.const));
+      }
+      TypeGuard2.TLiteral = TLiteral;
+      function TNever(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Never" && IsObject(schema.not) && globalThis.Object.getOwnPropertyNames(schema.not).length === 0;
+      }
+      TypeGuard2.TNever = TNever;
+      function TNot(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Not" && IsArray(schema.allOf) && schema.allOf.length === 2 && IsObject(schema.allOf[0]) && TSchema(schema.allOf[0].not) && TSchema(schema.allOf[1]);
+      }
+      TypeGuard2.TNot = TNot;
+      function TNull(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Null" && schema.type === "null" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TNull = TNull;
+      function TNumber(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Number" && schema.type === "number" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.multipleOf) && IsOptionalNumber(schema.minimum) && IsOptionalNumber(schema.maximum) && IsOptionalNumber(schema.exclusiveMinimum) && IsOptionalNumber(schema.exclusiveMaximum);
+      }
+      TypeGuard2.TNumber = TNumber;
+      function TObject(schema) {
+        if (!(TKind(schema) && schema[exports.Kind] === "Object" && schema.type === "object" && IsOptionalString(schema.$id) && IsObject(schema.properties) && (IsOptionalBoolean(schema.additionalProperties) || IsOptionalSchema(schema.additionalProperties)) && IsOptionalNumber(schema.minProperties) && IsOptionalNumber(schema.maxProperties))) {
+          return false;
+        }
+        for (const [key, value] of Object.entries(schema.properties)) {
+          if (!IsControlCharacterFree(key))
+            return false;
+          if (!TSchema(value))
+            return false;
+        }
+        return true;
+      }
+      TypeGuard2.TObject = TObject;
+      function TPromise(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Promise" && schema.type === "object" && schema.instanceOf === "Promise" && IsOptionalString(schema.$id) && TSchema(schema.item);
+      }
+      TypeGuard2.TPromise = TPromise;
+      function TRecord(schema) {
+        if (!(TKind(schema) && schema[exports.Kind] === "Record" && schema.type === "object" && IsOptionalString(schema.$id) && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
+          return false;
+        }
+        const keys = Object.keys(schema.patternProperties);
+        if (keys.length !== 1) {
+          return false;
+        }
+        if (!IsPattern(keys[0])) {
+          return false;
+        }
+        if (!TSchema(schema.patternProperties[keys[0]])) {
+          return false;
+        }
+        return true;
+      }
+      TypeGuard2.TRecord = TRecord;
+      function TRef(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Ref" && IsOptionalString(schema.$id) && IsString(schema.$ref);
+      }
+      TypeGuard2.TRef = TRef;
+      function TString(schema) {
+        return TKind(schema) && schema[exports.Kind] === "String" && schema.type === "string" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalFormat(schema.format);
+      }
+      TypeGuard2.TString = TString;
+      function TSymbol(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Symbol" && schema.type === "null" && schema.typeOf === "Symbol" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TSymbol = TSymbol;
+      function TTemplateLiteral(schema) {
+        return TKind(schema) && schema[exports.Kind] === "TemplateLiteral" && schema.type === "string" && IsString(schema.pattern) && schema.pattern[0] === "^" && schema.pattern[schema.pattern.length - 1] === "$";
+      }
+      TypeGuard2.TTemplateLiteral = TTemplateLiteral;
+      function TThis(schema) {
+        return TKind(schema) && schema[exports.Kind] === "This" && IsOptionalString(schema.$id) && IsString(schema.$ref);
+      }
+      TypeGuard2.TThis = TThis;
+      function TTuple(schema) {
+        if (!(TKind(schema) && schema[exports.Kind] === "Tuple" && schema.type === "array" && IsOptionalString(schema.$id) && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
+          return false;
+        }
+        if (schema.items === void 0 && schema.additionalItems === void 0 && schema.minItems === 0) {
+          return true;
+        }
+        if (!IsArray(schema.items)) {
+          return false;
+        }
+        for (const inner of schema.items) {
+          if (!TSchema(inner))
+            return false;
+        }
+        return true;
+      }
+      TypeGuard2.TTuple = TTuple;
+      function TUndefined(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Undefined" && schema.type === "null" && schema.typeOf === "Undefined" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TUndefined = TUndefined;
+      function TUnion(schema) {
+        if (!(TKind(schema) && schema[exports.Kind] === "Union" && IsArray(schema.anyOf) && IsOptionalString(schema.$id))) {
+          return false;
+        }
+        for (const inner of schema.anyOf) {
+          if (!TSchema(inner))
+            return false;
+        }
+        return true;
+      }
+      TypeGuard2.TUnion = TUnion;
+      function TUnionLiteral(schema) {
+        return TUnion(schema) && schema.anyOf.every((schema2) => TLiteral(schema2) && typeof schema2.const === "string");
+      }
+      TypeGuard2.TUnionLiteral = TUnionLiteral;
+      function TUint8Array(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Uint8Array" && schema.type === "object" && IsOptionalString(schema.$id) && schema.instanceOf === "Uint8Array" && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
+      }
+      TypeGuard2.TUint8Array = TUint8Array;
+      function TUnknown(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Unknown" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TUnknown = TUnknown;
+      function TUnsafe(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Unsafe";
+      }
+      TypeGuard2.TUnsafe = TUnsafe;
+      function TVoid(schema) {
+        return TKind(schema) && schema[exports.Kind] === "Void" && schema.type === "null" && schema.typeOf === "Void" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TVoid = TVoid;
+      function TReadonlyOptional(schema) {
+        return IsObject(schema) && schema[exports.Modifier] === "ReadonlyOptional";
+      }
+      TypeGuard2.TReadonlyOptional = TReadonlyOptional;
+      function TReadonly(schema) {
+        return IsObject(schema) && schema[exports.Modifier] === "Readonly";
+      }
+      TypeGuard2.TReadonly = TReadonly;
+      function TOptional(schema) {
+        return IsObject(schema) && schema[exports.Modifier] === "Optional";
+      }
+      TypeGuard2.TOptional = TOptional;
+      function TSchema(schema) {
+        return typeof schema === "object" && (TAny(schema) || TArray(schema) || TBoolean(schema) || TBigInt(schema) || TConstructor(schema) || TDate(schema) || TFunction(schema) || TInteger(schema) || TIntersect(schema) || TLiteral(schema) || TNever(schema) || TNot(schema) || TNull(schema) || TNumber(schema) || TObject(schema) || TPromise(schema) || TRecord(schema) || TRef(schema) || TString(schema) || TSymbol(schema) || TTemplateLiteral(schema) || TThis(schema) || TTuple(schema) || TUndefined(schema) || TUnion(schema) || TUint8Array(schema) || TUnknown(schema) || TUnsafe(schema) || TVoid(schema) || TKind(schema) && TypeRegistry.Has(schema[exports.Kind]));
+      }
+      TypeGuard2.TSchema = TSchema;
+    })(TypeGuard = exports.TypeGuard || (exports.TypeGuard = {}));
+    var ExtendsUndefined;
+    (function(ExtendsUndefined2) {
+      function Check(schema) {
+        if (schema[exports.Kind] === "Undefined")
+          return true;
+        if (schema[exports.Kind] === "Union") {
+          const union = schema;
+          return union.anyOf.some((schema2) => Check(schema2));
+        }
+        return false;
+      }
+      ExtendsUndefined2.Check = Check;
+    })(ExtendsUndefined = exports.ExtendsUndefined || (exports.ExtendsUndefined = {}));
+    var TypeExtendsResult;
+    (function(TypeExtendsResult2) {
+      TypeExtendsResult2[TypeExtendsResult2["Union"] = 0] = "Union";
+      TypeExtendsResult2[TypeExtendsResult2["True"] = 1] = "True";
+      TypeExtendsResult2[TypeExtendsResult2["False"] = 2] = "False";
+    })(TypeExtendsResult = exports.TypeExtendsResult || (exports.TypeExtendsResult = {}));
+    var TypeExtends;
+    (function(TypeExtends2) {
+      function IntoBooleanResult(result) {
+        return result === TypeExtendsResult.False ? TypeExtendsResult.False : TypeExtendsResult.True;
+      }
+      function AnyRight(left, right) {
+        return TypeExtendsResult.True;
+      }
+      function Any(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema)))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TUnion(right))
+          return TypeExtendsResult.Union;
+        if (TypeGuard.TUnknown(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TAny(right))
+          return TypeExtendsResult.True;
+        return TypeExtendsResult.Union;
+      }
+      function ArrayRight(left, right) {
+        if (TypeGuard.TUnknown(left))
+          return TypeExtendsResult.False;
+        if (TypeGuard.TAny(left))
+          return TypeExtendsResult.Union;
+        if (TypeGuard.TNever(left))
+          return TypeExtendsResult.True;
+        return TypeExtendsResult.False;
+      }
+      function Array2(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
+          return TypeExtendsResult.True;
+        if (!TypeGuard.TArray(right))
+          return TypeExtendsResult.False;
+        return IntoBooleanResult(Visit(left.items, right.items));
+      }
+      function BigInt(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+          return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        return TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function BooleanRight(left, right) {
+        if (TypeGuard.TLiteral(left) && typeof left.const === "boolean")
+          return TypeExtendsResult.True;
+        return TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Boolean(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+          return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        return TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Constructor(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (!TypeGuard.TConstructor(right))
+          return TypeExtendsResult.False;
+        if (left.parameters.length > right.parameters.length)
+          return TypeExtendsResult.False;
+        if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
+          return TypeExtendsResult.False;
+        }
+        return IntoBooleanResult(Visit(left.returns, right.returns));
+      }
+      function Date2(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        return TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Function(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (!TypeGuard.TFunction(right))
+          return TypeExtendsResult.False;
+        if (left.parameters.length > right.parameters.length)
+          return TypeExtendsResult.False;
+        if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
+          return TypeExtendsResult.False;
+        }
+        return IntoBooleanResult(Visit(left.returns, right.returns));
+      }
+      function IntegerRight(left, right) {
+        if (TypeGuard.TLiteral(left) && typeof left.const === "number")
+          return TypeExtendsResult.True;
+        return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Integer(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+          return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function IntersectRight(left, right) {
+        return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Intersect(left, right) {
+        return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function IsLiteralString(schema) {
+        return typeof schema.const === "string";
+      }
+      function IsLiteralNumber(schema) {
+        return typeof schema.const === "number";
+      }
+      function IsLiteralBoolean(schema) {
+        return typeof schema.const === "boolean";
+      }
+      function Literal(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+          return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        if (TypeGuard.TString(right))
+          return StringRight(left, right);
+        if (TypeGuard.TNumber(right))
+          return NumberRight(left, right);
+        if (TypeGuard.TInteger(right))
+          return IntegerRight(left, right);
+        if (TypeGuard.TBoolean(right))
+          return BooleanRight(left, right);
+        return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function NeverRight(left, right) {
+        return TypeExtendsResult.False;
+      }
+      function Never(left, right) {
+        return TypeExtendsResult.True;
+      }
+      function Null(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+          return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        return TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function NumberRight(left, right) {
+        if (TypeGuard.TLiteral(left) && IsLiteralNumber(left))
+          return TypeExtendsResult.True;
+        return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Number2(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+          return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function IsObjectPropertyCount(schema, count) {
+        return globalThis.Object.keys(schema.properties).length === count;
+      }
+      function IsObjectStringLike(schema) {
+        return IsObjectArrayLike(schema);
+      }
+      function IsObjectSymbolLike(schema) {
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && TypeGuard.TUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (TypeGuard.TString(schema.properties.description.anyOf[0]) && TypeGuard.TUndefined(schema.properties.description.anyOf[1]) || TypeGuard.TString(schema.properties.description.anyOf[1]) && TypeGuard.TUndefined(schema.properties.description.anyOf[0]));
+      }
+      function IsObjectNumberLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectBooleanLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectBigIntLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectDateLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectUint8ArrayLike(schema) {
+        return IsObjectArrayLike(schema);
+      }
+      function IsObjectFunctionLike(schema) {
+        const length = exports.Type.Number();
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === TypeExtendsResult.True;
+      }
+      function IsObjectConstructorLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectArrayLike(schema) {
+        const length = exports.Type.Number();
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === TypeExtendsResult.True;
+      }
+      function IsObjectPromiseLike(schema) {
+        const then = exports.Type.Function([exports.Type.Any()], exports.Type.Any());
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit(schema.properties["then"], then)) === TypeExtendsResult.True;
+      }
+      function Property(left, right) {
+        if (Visit(left, right) === TypeExtendsResult.False)
+          return TypeExtendsResult.False;
+        if (TypeGuard.TOptional(left) && !TypeGuard.TOptional(right))
+          return TypeExtendsResult.False;
+        return TypeExtendsResult.True;
+      }
+      function ObjectRight(left, right) {
+        if (TypeGuard.TUnknown(left))
+          return TypeExtendsResult.False;
+        if (TypeGuard.TAny(left))
+          return TypeExtendsResult.Union;
+        if (TypeGuard.TNever(left))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TLiteral(left) && IsLiteralString(left) && IsObjectStringLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TLiteral(left) && IsLiteralNumber(left) && IsObjectNumberLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TLiteral(left) && IsLiteralBoolean(left) && IsObjectBooleanLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TString(left) && IsObjectStringLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TNumber(left) && IsObjectNumberLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TInteger(left) && IsObjectNumberLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TDate(left) && IsObjectDateLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TFunction(left) && IsObjectFunctionLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) {
+          return right[exports.Hint] === "Record" ? TypeExtendsResult.True : TypeExtendsResult.False;
+        }
+        if (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) {
+          return IsObjectPropertyCount(right, 0) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        }
+        return TypeExtendsResult.False;
+      }
+      function Object2(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        if (!TypeGuard.TObject(right))
+          return TypeExtendsResult.False;
+        for (const key of globalThis.Object.keys(right.properties)) {
+          if (!(key in left.properties))
+            return TypeExtendsResult.False;
+          if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
+            return TypeExtendsResult.False;
+          }
+        }
+        return TypeExtendsResult.True;
+      }
+      function Promise2(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right) && IsObjectPromiseLike(right))
+          return TypeExtendsResult.True;
+        if (!TypeGuard.TPromise(right))
+          return TypeExtendsResult.False;
+        return IntoBooleanResult(Visit(left.item, right.item));
+      }
+      function RecordKey(schema) {
+        if (exports.PatternNumberExact in schema.patternProperties)
+          return exports.Type.Number();
+        if (exports.PatternStringExact in schema.patternProperties)
+          return exports.Type.String();
+        throw Error("TypeExtends: Cannot get record key");
+      }
+      function RecordValue(schema) {
+        if (exports.PatternNumberExact in schema.patternProperties)
+          return schema.patternProperties[exports.PatternNumberExact];
+        if (exports.PatternStringExact in schema.patternProperties)
+          return schema.patternProperties[exports.PatternStringExact];
+        throw Error("TypeExtends: Cannot get record value");
+      }
+      function RecordRight(left, right) {
+        const Key = RecordKey(right);
+        const Value = RecordValue(right);
+        if (TypeGuard.TLiteral(left) && IsLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True)
+          return TypeExtendsResult.True;
+        if (TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key))
+          return Visit(left, Value);
+        if (TypeGuard.TString(left) && TypeGuard.TNumber(Key))
+          return Visit(left, Value);
+        if (TypeGuard.TArray(left) && TypeGuard.TNumber(Key))
+          return Visit(left, Value);
+        if (TypeGuard.TObject(left)) {
+          for (const key of globalThis.Object.keys(left.properties)) {
+            if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
+              return TypeExtendsResult.False;
+            }
+          }
+          return TypeExtendsResult.True;
+        }
+        return TypeExtendsResult.False;
+      }
+      function Record(left, right) {
+        const Value = RecordValue(left);
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (!TypeGuard.TRecord(right))
+          return TypeExtendsResult.False;
+        return Visit(Value, RecordValue(right));
+      }
+      function StringRight(left, right) {
+        if (TypeGuard.TLiteral(left) && typeof left.const === "string")
+          return TypeExtendsResult.True;
+        return TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function String2(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+          return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        return TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Symbol2(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+          return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TupleRight(left, right) {
+        if (TypeGuard.TUnknown(left))
+          return TypeExtendsResult.False;
+        if (TypeGuard.TAny(left))
+          return TypeExtendsResult.Union;
+        if (TypeGuard.TNever(left))
+          return TypeExtendsResult.True;
+        return TypeExtendsResult.False;
+      }
+      function IsArrayOfTuple(left, right) {
+        return TypeGuard.TArray(right) && left.items !== void 0 && left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True);
+      }
+      function Tuple(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
+          return TypeExtendsResult.True;
+        if (TypeGuard.TArray(right) && IsArrayOfTuple(left, right))
+          return TypeExtendsResult.True;
+        if (!TypeGuard.TTuple(right))
+          return TypeExtendsResult.False;
+        if (left.items === void 0 && right.items !== void 0 || left.items !== void 0 && right.items === void 0)
+          return TypeExtendsResult.False;
+        if (left.items === void 0 && right.items === void 0)
+          return TypeExtendsResult.True;
+        return left.items.every((schema, index) => Visit(schema, right.items[index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Uint8Array(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        return TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Undefined(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+          return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+          return RecordRight(left, right);
+        if (TypeGuard.TVoid(right))
+          return VoidRight(left, right);
+        return TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function UnionRight(left, right) {
+        return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Union(left, right) {
+        return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function UnknownRight(left, right) {
+        return TypeExtendsResult.True;
+      }
+      function Unknown(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TString(right))
+          return StringRight(left, right);
+        if (TypeGuard.TNumber(right))
+          return NumberRight(left, right);
+        if (TypeGuard.TInteger(right))
+          return IntegerRight(left, right);
+        if (TypeGuard.TBoolean(right))
+          return BooleanRight(left, right);
+        if (TypeGuard.TArray(right))
+          return ArrayRight(left, right);
+        if (TypeGuard.TTuple(right))
+          return TupleRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        return TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function VoidRight(left, right) {
+        if (TypeGuard.TUndefined(left))
+          return TypeExtendsResult.True;
+        return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Void(left, right) {
+        if (TypeGuard.TIntersect(right))
+          return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+          return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+          return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+          return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+          return ObjectRight(left, right);
+        return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Visit(left, right) {
+        if (TypeGuard.TTemplateLiteral(left))
+          return Visit(TemplateLiteralResolver.Resolve(left), right);
+        if (TypeGuard.TTemplateLiteral(right))
+          return Visit(left, TemplateLiteralResolver.Resolve(right));
+        if (TypeGuard.TAny(left))
+          return Any(left, right);
+        if (TypeGuard.TArray(left))
+          return Array2(left, right);
+        if (TypeGuard.TBigInt(left))
+          return BigInt(left, right);
+        if (TypeGuard.TBoolean(left))
+          return Boolean(left, right);
+        if (TypeGuard.TConstructor(left))
+          return Constructor(left, right);
+        if (TypeGuard.TDate(left))
+          return Date2(left, right);
+        if (TypeGuard.TFunction(left))
+          return Function(left, right);
+        if (TypeGuard.TInteger(left))
+          return Integer(left, right);
+        if (TypeGuard.TIntersect(left))
+          return Intersect(left, right);
+        if (TypeGuard.TLiteral(left))
+          return Literal(left, right);
+        if (TypeGuard.TNever(left))
+          return Never(left, right);
+        if (TypeGuard.TNull(left))
+          return Null(left, right);
+        if (TypeGuard.TNumber(left))
+          return Number2(left, right);
+        if (TypeGuard.TObject(left))
+          return Object2(left, right);
+        if (TypeGuard.TRecord(left))
+          return Record(left, right);
+        if (TypeGuard.TString(left))
+          return String2(left, right);
+        if (TypeGuard.TSymbol(left))
+          return Symbol2(left, right);
+        if (TypeGuard.TTuple(left))
+          return Tuple(left, right);
+        if (TypeGuard.TPromise(left))
+          return Promise2(left, right);
+        if (TypeGuard.TUint8Array(left))
+          return Uint8Array(left, right);
+        if (TypeGuard.TUndefined(left))
+          return Undefined(left, right);
+        if (TypeGuard.TUnion(left))
+          return Union(left, right);
+        if (TypeGuard.TUnknown(left))
+          return Unknown(left, right);
+        if (TypeGuard.TVoid(left))
+          return Void(left, right);
+        throw Error(`TypeExtends: Unknown left type operand '${left[exports.Kind]}'`);
+      }
+      function Extends(left, right) {
+        return Visit(left, right);
+      }
+      TypeExtends2.Extends = Extends;
+    })(TypeExtends = exports.TypeExtends || (exports.TypeExtends = {}));
+    var TypeClone;
+    (function(TypeClone2) {
+      function IsObject(value) {
+        return typeof value === "object" && value !== null;
+      }
+      function IsArray(value) {
+        return globalThis.Array.isArray(value);
+      }
+      function Array2(value) {
+        return value.map((value2) => Visit(value2));
+      }
+      function Object2(value) {
+        const clonedProperties = globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
+          return { ...acc, [key]: Visit(value[key]) };
+        }, {});
+        const clonedSymbols = globalThis.Object.getOwnPropertySymbols(value).reduce((acc, key) => {
+          return { ...acc, [key]: Visit(value[key]) };
+        }, {});
+        return { ...clonedProperties, ...clonedSymbols };
+      }
+      function Visit(value) {
+        if (IsArray(value))
+          return Array2(value);
+        if (IsObject(value))
+          return Object2(value);
+        return value;
+      }
+      function Clone(schema, options) {
+        return { ...Visit(schema), ...options };
+      }
+      TypeClone2.Clone = Clone;
+    })(TypeClone = exports.TypeClone || (exports.TypeClone = {}));
+    var ObjectMap;
+    (function(ObjectMap2) {
+      function Intersect(schema, callback) {
+        return exports.Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema });
+      }
+      function Union(schema, callback) {
+        return exports.Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema });
+      }
+      function Object2(schema, callback) {
+        return callback(schema);
+      }
+      function Visit(schema, callback) {
+        if (schema[exports.Kind] === "Intersect")
+          return Intersect(schema, callback);
+        if (schema[exports.Kind] === "Union")
+          return Union(schema, callback);
+        if (schema[exports.Kind] === "Object")
+          return Object2(schema, callback);
+        return schema;
+      }
+      function Map2(schema, callback, options) {
+        return { ...Visit(TypeClone.Clone(schema, {}), callback), ...options };
+      }
+      ObjectMap2.Map = Map2;
+    })(ObjectMap = exports.ObjectMap || (exports.ObjectMap = {}));
+    var KeyResolver;
+    (function(KeyResolver2) {
+      function IsKeyable(schema) {
+        return TypeGuard.TIntersect(schema) || TypeGuard.TUnion(schema) || TypeGuard.TObject(schema) && globalThis.Object.getOwnPropertyNames(schema.properties).length > 0;
+      }
+      function Intersect(schema) {
+        return [...schema.allOf.filter((schema2) => IsKeyable(schema2)).reduce((set, schema2) => Visit(schema2).map((key) => set.add(key))[0], /* @__PURE__ */ new Set())];
+      }
+      function Union(schema) {
+        const sets = schema.anyOf.filter((schema2) => IsKeyable(schema2)).map((inner) => Visit(inner));
+        return [...sets.reduce((set, outer) => outer.map((key) => sets.every((inner) => inner.includes(key)) ? set.add(key) : set)[0], /* @__PURE__ */ new Set())];
+      }
+      function Object2(schema) {
+        return globalThis.Object.keys(schema.properties);
+      }
+      function Visit(schema) {
+        if (TypeGuard.TIntersect(schema))
+          return Intersect(schema);
+        if (TypeGuard.TUnion(schema))
+          return Union(schema);
+        if (TypeGuard.TObject(schema))
+          return Object2(schema);
+        return [];
+      }
+      function Resolve(schema) {
+        return Visit(schema);
+      }
+      KeyResolver2.Resolve = Resolve;
+    })(KeyResolver = exports.KeyResolver || (exports.KeyResolver = {}));
+    var TemplateLiteralPattern;
+    (function(TemplateLiteralPattern2) {
+      function Escape(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
+      function Visit(schema, acc) {
+        if (TypeGuard.TTemplateLiteral(schema)) {
+          const pattern = schema.pattern.slice(1, schema.pattern.length - 1);
+          return pattern;
+        } else if (TypeGuard.TUnion(schema)) {
+          const tokens = schema.anyOf.map((schema2) => Visit(schema2, acc)).join("|");
+          return `(${tokens})`;
+        } else if (TypeGuard.TNumber(schema)) {
+          return `${acc}${exports.PatternNumber}`;
+        } else if (TypeGuard.TInteger(schema)) {
+          return `${acc}${exports.PatternNumber}`;
+        } else if (TypeGuard.TBigInt(schema)) {
+          return `${acc}${exports.PatternNumber}`;
+        } else if (TypeGuard.TString(schema)) {
+          return `${acc}${exports.PatternString}`;
+        } else if (TypeGuard.TLiteral(schema)) {
+          return `${acc}${Escape(schema.const.toString())}`;
+        } else if (TypeGuard.TBoolean(schema)) {
+          return `${acc}${exports.PatternBoolean}`;
+        } else if (TypeGuard.TNever(schema)) {
+          throw Error("TemplateLiteralPattern: TemplateLiteral cannot operate on types of TNever");
+        } else {
+          throw Error(`TemplateLiteralPattern: Unexpected Kind '${schema[exports.Kind]}'`);
+        }
+      }
+      function Create(kinds) {
+        return `^${kinds.map((schema) => Visit(schema, "")).join("")}$`;
+      }
+      TemplateLiteralPattern2.Create = Create;
+    })(TemplateLiteralPattern = exports.TemplateLiteralPattern || (exports.TemplateLiteralPattern = {}));
+    var TemplateLiteralResolver;
+    (function(TemplateLiteralResolver2) {
+      function Resolve(template) {
+        const expression = TemplateLiteralParser.ParseExact(template.pattern);
+        if (!TemplateLiteralFinite.Check(expression))
+          return exports.Type.String();
+        const literals = [...TemplateLiteralGenerator.Generate(expression)].map((value) => exports.Type.Literal(value));
+        return exports.Type.Union(literals);
+      }
+      TemplateLiteralResolver2.Resolve = Resolve;
+    })(TemplateLiteralResolver = exports.TemplateLiteralResolver || (exports.TemplateLiteralResolver = {}));
+    var TemplateLiteralParserError = class extends Error {
+      constructor(message) {
+        super(message);
+      }
+    };
+    exports.TemplateLiteralParserError = TemplateLiteralParserError;
+    var TemplateLiteralParser;
+    (function(TemplateLiteralParser2) {
+      function IsNonEscaped(pattern, index, char) {
+        return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+      }
+      function IsOpenParen(pattern, index) {
+        return IsNonEscaped(pattern, index, "(");
+      }
+      function IsCloseParen(pattern, index) {
+        return IsNonEscaped(pattern, index, ")");
+      }
+      function IsSeparator(pattern, index) {
+        return IsNonEscaped(pattern, index, "|");
+      }
+      function IsGroup(pattern) {
+        if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
+          return false;
+        let count = 0;
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            count += 1;
+          if (IsCloseParen(pattern, index))
+            count -= 1;
+          if (count === 0 && index !== pattern.length - 1)
+            return false;
+        }
+        return true;
+      }
+      function InGroup(pattern) {
+        return pattern.slice(1, pattern.length - 1);
+      }
+      function IsPrecedenceOr(pattern) {
+        let count = 0;
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            count += 1;
+          if (IsCloseParen(pattern, index))
+            count -= 1;
+          if (IsSeparator(pattern, index) && count === 0)
+            return true;
+        }
+        return false;
+      }
+      function IsPrecedenceAnd(pattern) {
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            return true;
+        }
+        return false;
+      }
+      function Or(pattern) {
+        let [count, start] = [0, 0];
+        const expressions = [];
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            count += 1;
+          if (IsCloseParen(pattern, index))
+            count -= 1;
+          if (IsSeparator(pattern, index) && count === 0) {
+            const range2 = pattern.slice(start, index);
+            if (range2.length > 0)
+              expressions.push(Parse(range2));
+            start = index + 1;
+          }
+        }
+        const range = pattern.slice(start);
+        if (range.length > 0)
+          expressions.push(Parse(range));
+        if (expressions.length === 0)
+          return { type: "const", const: "" };
+        if (expressions.length === 1)
+          return expressions[0];
+        return { type: "or", expr: expressions };
+      }
+      function And(pattern) {
+        function Group(value, index) {
+          if (!IsOpenParen(value, index))
+            throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+          let count = 0;
+          for (let scan = index; scan < value.length; scan++) {
+            if (IsOpenParen(value, scan))
+              count += 1;
+            if (IsCloseParen(value, scan))
+              count -= 1;
+            if (count === 0)
+              return [index, scan];
+          }
+          throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+        }
+        function Range(pattern2, index) {
+          for (let scan = index; scan < pattern2.length; scan++) {
+            if (IsOpenParen(pattern2, scan))
+              return [index, scan];
+          }
+          return [index, pattern2.length];
+        }
+        const expressions = [];
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index)) {
+            const [start, end] = Group(pattern, index);
+            const range = pattern.slice(start, end + 1);
+            expressions.push(Parse(range));
+            index = end;
+          } else {
+            const [start, end] = Range(pattern, index);
+            const range = pattern.slice(start, end);
+            if (range.length > 0)
+              expressions.push(Parse(range));
+            index = end - 1;
+          }
+        }
+        if (expressions.length === 0)
+          return { type: "const", const: "" };
+        if (expressions.length === 1)
+          return expressions[0];
+        return { type: "and", expr: expressions };
+      }
+      function Parse(pattern) {
+        if (IsGroup(pattern))
+          return Parse(InGroup(pattern));
+        if (IsPrecedenceOr(pattern))
+          return Or(pattern);
+        if (IsPrecedenceAnd(pattern))
+          return And(pattern);
+        return { type: "const", const: pattern };
+      }
+      TemplateLiteralParser2.Parse = Parse;
+      function ParseExact(pattern) {
+        return Parse(pattern.slice(1, pattern.length - 1));
+      }
+      TemplateLiteralParser2.ParseExact = ParseExact;
+    })(TemplateLiteralParser = exports.TemplateLiteralParser || (exports.TemplateLiteralParser = {}));
+    var TemplateLiteralFinite;
+    (function(TemplateLiteralFinite2) {
+      function IsNumber(expression) {
+        return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
+      }
+      function IsBoolean(expression) {
+        return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
+      }
+      function IsString(expression) {
+        return expression.type === "const" && expression.const === ".*";
+      }
+      function Check(expression) {
+        if (IsBoolean(expression))
+          return true;
+        if (IsNumber(expression) || IsString(expression))
+          return false;
+        if (expression.type === "and")
+          return expression.expr.every((expr) => Check(expr));
+        if (expression.type === "or")
+          return expression.expr.every((expr) => Check(expr));
+        if (expression.type === "const")
+          return true;
+        throw Error(`TemplateLiteralFinite: Unknown expression type`);
+      }
+      TemplateLiteralFinite2.Check = Check;
+    })(TemplateLiteralFinite = exports.TemplateLiteralFinite || (exports.TemplateLiteralFinite = {}));
+    var TemplateLiteralGenerator;
+    (function(TemplateLiteralGenerator2) {
+      function* Reduce(buffer) {
+        if (buffer.length === 1)
+          return yield* buffer[0];
+        for (const left of buffer[0]) {
+          for (const right of Reduce(buffer.slice(1))) {
+            yield `${left}${right}`;
+          }
+        }
+      }
+      function* And(expression) {
+        return yield* Reduce(expression.expr.map((expr) => [...Generate(expr)]));
+      }
+      function* Or(expression) {
+        for (const expr of expression.expr)
+          yield* Generate(expr);
+      }
+      function* Const(expression) {
+        return yield expression.const;
+      }
+      function* Generate(expression) {
+        if (expression.type === "and")
+          return yield* And(expression);
+        if (expression.type === "or")
+          return yield* Or(expression);
+        if (expression.type === "const")
+          return yield* Const(expression);
+        throw Error("TemplateLiteralGenerator: Unknown expression");
+      }
+      TemplateLiteralGenerator2.Generate = Generate;
+    })(TemplateLiteralGenerator = exports.TemplateLiteralGenerator || (exports.TemplateLiteralGenerator = {}));
+    var TypeOrdinal = 0;
+    var TypeBuilder = class {
+      /** `[Utility]` Creates a schema without `static` and `params` types */
+      Create(schema) {
+        return schema;
+      }
+      /** `[Standard]` Omits compositing symbols from this schema */
+      Strict(schema) {
+        return JSON.parse(JSON.stringify(schema));
+      }
+    };
+    exports.TypeBuilder = TypeBuilder;
+    var StandardTypeBuilder = class extends TypeBuilder {
+      // ------------------------------------------------------------------------
+      // Modifiers
+      // ------------------------------------------------------------------------
+      /** `[Modifier]` Creates a Optional property */
+      Optional(schema) {
+        return { [exports.Modifier]: "Optional", ...TypeClone.Clone(schema, {}) };
+      }
+      /** `[Modifier]` Creates a ReadonlyOptional property */
+      ReadonlyOptional(schema) {
+        return { [exports.Modifier]: "ReadonlyOptional", ...TypeClone.Clone(schema, {}) };
+      }
+      /** `[Modifier]` Creates a Readonly object or property */
+      Readonly(schema) {
+        return { [exports.Modifier]: "Readonly", ...schema };
+      }
+      // ------------------------------------------------------------------------
+      // Types
+      // ------------------------------------------------------------------------
+      /** `[Standard]` Creates an Any type */
+      Any(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Any" });
+      }
+      /** `[Standard]` Creates an Array type */
+      Array(items, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Array", type: "array", items: TypeClone.Clone(items, {}) });
+      }
+      /** `[Standard]` Creates a Boolean type */
+      Boolean(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Boolean", type: "boolean" });
+      }
+      /** `[Standard]` Creates a Composite object type. */
+      Composite(objects, options) {
+        const isOptionalAll = (objects2, key) => objects2.every((object) => !(key in object.properties) || IsOptional(object.properties[key]));
+        const IsOptional = (schema) => TypeGuard.TOptional(schema) || TypeGuard.TReadonlyOptional(schema);
+        const [required, optional] = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
+        for (const object of objects) {
+          for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
+            if (isOptionalAll(objects, key))
+              optional.add(key);
+          }
+        }
+        for (const object of objects) {
+          for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
+            if (!optional.has(key))
+              required.add(key);
+          }
+        }
+        const properties = {};
+        for (const object of objects) {
+          for (const [key, schema] of Object.entries(object.properties)) {
+            const property = TypeClone.Clone(schema, {});
+            if (!optional.has(key))
+              delete property[exports.Modifier];
+            if (key in properties) {
+              const left = TypeExtends.Extends(properties[key], property) !== TypeExtendsResult.False;
+              const right = TypeExtends.Extends(property, properties[key]) !== TypeExtendsResult.False;
+              if (!left && !right)
+                properties[key] = exports.Type.Never();
+              if (!left && right)
+                properties[key] = property;
+            } else {
+              properties[key] = property;
+            }
+          }
+        }
+        if (required.size > 0) {
+          return this.Create({ ...options, [exports.Kind]: "Object", [exports.Hint]: "Composite", type: "object", properties, required: [...required] });
+        } else {
+          return this.Create({ ...options, [exports.Kind]: "Object", [exports.Hint]: "Composite", type: "object", properties });
+        }
+      }
+      /** `[Standard]` Creates a Enum type */
+      Enum(item, options = {}) {
+        const values = globalThis.Object.keys(item).filter((key) => isNaN(key)).map((key) => item[key]);
+        const anyOf = values.map((value) => typeof value === "string" ? { [exports.Kind]: "Literal", type: "string", const: value } : { [exports.Kind]: "Literal", type: "number", const: value });
+        return this.Create({ ...options, [exports.Kind]: "Union", anyOf });
+      }
+      /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
+      Extends(left, right, trueType, falseType, options = {}) {
+        switch (TypeExtends.Extends(left, right)) {
+          case TypeExtendsResult.Union:
+            return this.Union([TypeClone.Clone(trueType, options), TypeClone.Clone(falseType, options)]);
+          case TypeExtendsResult.True:
+            return TypeClone.Clone(trueType, options);
+          case TypeExtendsResult.False:
+            return TypeClone.Clone(falseType, options);
+        }
+      }
+      /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
+      Exclude(left, right, options = {}) {
+        if (TypeGuard.TTemplateLiteral(left))
+          return this.Exclude(TemplateLiteralResolver.Resolve(left), right, options);
+        if (TypeGuard.TTemplateLiteral(right))
+          return this.Exclude(left, TemplateLiteralResolver.Resolve(right), options);
+        if (TypeGuard.TUnion(left)) {
+          const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) === TypeExtendsResult.False);
+          return narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options);
+        } else {
+          return TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options);
+        }
+      }
+      /** `[Standard]` Extracts from the left type any type that is assignable to the right */
+      Extract(left, right, options = {}) {
+        if (TypeGuard.TTemplateLiteral(left))
+          return this.Extract(TemplateLiteralResolver.Resolve(left), right, options);
+        if (TypeGuard.TTemplateLiteral(right))
+          return this.Extract(left, TemplateLiteralResolver.Resolve(right), options);
+        if (TypeGuard.TUnion(left)) {
+          const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False);
+          return narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options);
+        } else {
+          return TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? TypeClone.Clone(left, options) : this.Never(options);
+        }
+      }
+      /** `[Standard]` Creates an Integer type */
+      Integer(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Integer", type: "integer" });
+      }
+      Intersect(allOf, options = {}) {
+        if (allOf.length === 0)
+          return exports.Type.Never();
+        if (allOf.length === 1)
+          return TypeClone.Clone(allOf[0], options);
+        const objects = allOf.every((schema) => TypeGuard.TObject(schema));
+        const cloned = allOf.map((schema) => TypeClone.Clone(schema, {}));
+        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties, {}) } : {};
+        if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
+          return this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: "Intersect", type: "object", allOf: cloned });
+        } else {
+          return this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: "Intersect", allOf: cloned });
+        }
+      }
+      /** `[Standard]` Creates a KeyOf type */
+      KeyOf(schema, options = {}) {
+        if (TypeGuard.TRecord(schema)) {
+          const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+          if (pattern === exports.PatternNumberExact)
+            return this.Number(options);
+          if (pattern === exports.PatternStringExact)
+            return this.String(options);
+          throw Error("StandardTypeBuilder: Unable to resolve key type from Record key pattern");
+        } else {
+          const resolved = KeyResolver.Resolve(schema);
+          if (resolved.length === 0)
+            return this.Never(options);
+          const literals = resolved.map((key) => this.Literal(key));
+          return this.Union(literals, options);
+        }
+      }
+      /** `[Standard]` Creates a Literal type */
+      Literal(value, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Literal", const: value, type: typeof value });
+      }
+      /** `[Standard]` Creates a Never type */
+      Never(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Never", not: {} });
+      }
+      /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
+      Not(not, schema, options) {
+        return this.Create({ ...options, [exports.Kind]: "Not", allOf: [{ not: TypeClone.Clone(not, {}) }, TypeClone.Clone(schema, {})] });
+      }
+      /** `[Standard]` Creates a Null type */
+      Null(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Null", type: "null" });
+      }
+      /** `[Standard]` Creates a Number type */
+      Number(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Number", type: "number" });
+      }
+      /** `[Standard]` Creates an Object type */
+      Object(properties, options = {}) {
+        const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
+        const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]) || TypeGuard.TReadonlyOptional(properties[key]));
+        const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
+        const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties, {}) } : {};
+        const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key], {}) }), {});
+        if (requiredKeys.length > 0) {
+          return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: "Object", type: "object", properties: clonedProperties, required: requiredKeys });
+        } else {
+          return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: "Object", type: "object", properties: clonedProperties });
+        }
+      }
+      Omit(schema, unresolved, options = {}) {
+        const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema2) => schema2.const) : TypeGuard.TLiteral(unresolved) ? [unresolved.const] : TypeGuard.TNever(unresolved) ? [] : unresolved;
+        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema2) => {
+          if (schema2.required) {
+            schema2.required = schema2.required.filter((key) => !keys.includes(key));
+            if (schema2.required.length === 0)
+              delete schema2.required;
+          }
+          for (const key of globalThis.Object.keys(schema2.properties)) {
+            if (keys.includes(key))
+              delete schema2.properties[key];
+          }
+          return this.Create(schema2);
+        }, options);
+      }
+      /** `[Standard]` Creates a mapped type where all properties are Optional */
+      Partial(schema, options = {}) {
+        function Apply(schema2) {
+          switch (schema2[exports.Modifier]) {
+            case "ReadonlyOptional":
+              schema2[exports.Modifier] = "ReadonlyOptional";
+              break;
+            case "Readonly":
+              schema2[exports.Modifier] = "ReadonlyOptional";
+              break;
+            case "Optional":
+              schema2[exports.Modifier] = "Optional";
+              break;
+            default:
+              schema2[exports.Modifier] = "Optional";
+              break;
+          }
+        }
+        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema2) => {
+          delete schema2.required;
+          globalThis.Object.keys(schema2.properties).forEach((key) => Apply(schema2.properties[key]));
+          return schema2;
+        }, options);
+      }
+      Pick(schema, unresolved, options = {}) {
+        const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema2) => schema2.const) : TypeGuard.TLiteral(unresolved) ? [unresolved.const] : TypeGuard.TNever(unresolved) ? [] : unresolved;
+        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema2) => {
+          if (schema2.required) {
+            schema2.required = schema2.required.filter((key) => keys.includes(key));
+            if (schema2.required.length === 0)
+              delete schema2.required;
+          }
+          for (const key of globalThis.Object.keys(schema2.properties)) {
+            if (!keys.includes(key))
+              delete schema2.properties[key];
+          }
+          return this.Create(schema2);
+        }, options);
+      }
+      /** `[Standard]` Creates a Record type */
+      Record(key, schema, options = {}) {
+        if (TypeGuard.TTemplateLiteral(key)) {
+          const expression = TemplateLiteralParser.ParseExact(key.pattern);
+          return TemplateLiteralFinite.Check(expression) ? this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key2) => ({ ...acc, [key2]: TypeClone.Clone(schema, {}) }), {}), options) : this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
+        } else if (TypeGuard.TUnionLiteral(key)) {
+          if (key.anyOf.every((schema2) => TypeGuard.TLiteral(schema2) && (typeof schema2.const === "string" || typeof schema2.const === "number"))) {
+            const properties = key.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
+            return this.Object(properties, { ...options, [exports.Hint]: "Record" });
+          } else
+            throw Error("TypeBuilder: Record key can only be derived from union literal of number or string");
+        } else if (TypeGuard.TLiteral(key)) {
+          if (typeof key.const === "string" || typeof key.const === "number") {
+            return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
+          } else
+            throw Error("TypeBuilder: Record key can only be derived from literals of number or string");
+        } else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
+          const pattern = exports.PatternNumberExact;
+          return this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
+        } else if (TypeGuard.TString(key)) {
+          const pattern = key.pattern === void 0 ? exports.PatternStringExact : key.pattern;
+          return this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
+        } else {
+          throw Error(`StandardTypeBuilder: Invalid Record Key`);
+        }
+      }
+      /** `[Standard]` Creates a Recursive type */
+      Recursive(callback, options = {}) {
+        if (options.$id === void 0)
+          options.$id = `T${TypeOrdinal++}`;
+        const thisType = callback({ [exports.Kind]: "This", $ref: `${options.$id}` });
+        thisType.$id = options.$id;
+        return this.Create({ ...options, [exports.Hint]: "Recursive", ...thisType });
+      }
+      /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
+      Ref(schema, options = {}) {
+        if (schema.$id === void 0)
+          throw Error("StandardTypeBuilder.Ref: Target type must specify an $id");
+        return this.Create({ ...options, [exports.Kind]: "Ref", $ref: schema.$id });
+      }
+      /** `[Standard]` Creates a mapped type where all properties are Required */
+      Required(schema, options = {}) {
+        function Apply(schema2) {
+          switch (schema2[exports.Modifier]) {
+            case "ReadonlyOptional":
+              schema2[exports.Modifier] = "Readonly";
+              break;
+            case "Readonly":
+              schema2[exports.Modifier] = "Readonly";
+              break;
+            case "Optional":
+              delete schema2[exports.Modifier];
+              break;
+            default:
+              delete schema2[exports.Modifier];
+              break;
+          }
+        }
+        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema2) => {
+          schema2.required = globalThis.Object.keys(schema2.properties);
+          globalThis.Object.keys(schema2.properties).forEach((key) => Apply(schema2.properties[key]));
+          return schema2;
+        }, options);
+      }
+      /** `[Standard]` Creates a String type */
+      String(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "String", type: "string" });
+      }
+      /** `[Standard]` Creates a template literal type */
+      TemplateLiteral(kinds, options = {}) {
+        const pattern = TemplateLiteralPattern.Create(kinds);
+        return this.Create({ ...options, [exports.Kind]: "TemplateLiteral", type: "string", pattern });
+      }
+      /** `[Standard]` Creates a Tuple type */
+      Tuple(items, options = {}) {
+        const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+        const clonedItems = items.map((item) => TypeClone.Clone(item, {}));
+        const schema = items.length > 0 ? { ...options, [exports.Kind]: "Tuple", type: "array", items: clonedItems, additionalItems, minItems, maxItems } : { ...options, [exports.Kind]: "Tuple", type: "array", minItems, maxItems };
+        return this.Create(schema);
+      }
+      Union(union, options = {}) {
+        if (TypeGuard.TTemplateLiteral(union)) {
+          return TemplateLiteralResolver.Resolve(union);
+        } else {
+          const anyOf = union;
+          if (anyOf.length === 0)
+            return this.Never(options);
+          if (anyOf.length === 1)
+            return this.Create(TypeClone.Clone(anyOf[0], options));
+          const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}));
+          return this.Create({ ...options, [exports.Kind]: "Union", anyOf: clonedAnyOf });
+        }
+      }
+      /** `[Standard]` Creates an Unknown type */
+      Unknown(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Unknown" });
+      }
+      /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
+      Unsafe(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || "Unsafe" });
+      }
+    };
+    exports.StandardTypeBuilder = StandardTypeBuilder;
+    var ExtendedTypeBuilder = class extends StandardTypeBuilder {
+      /** `[Extended]` Creates a BigInt type */
+      BigInt(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "BigInt", type: "null", typeOf: "BigInt" });
+      }
+      /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
+      ConstructorParameters(schema, options = {}) {
+        return this.Tuple([...schema.parameters], { ...options });
+      }
+      Constructor(parameters, returns, options = {}) {
+        const clonedReturns = TypeClone.Clone(returns, {});
+        if (TypeGuard.TTuple(parameters)) {
+          const clonedParameters = parameters.items === void 0 ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}));
+          return this.Create({ ...options, [exports.Kind]: "Constructor", type: "object", instanceOf: "Constructor", parameters: clonedParameters, returns: clonedReturns });
+        } else if (globalThis.Array.isArray(parameters)) {
+          const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+          return this.Create({ ...options, [exports.Kind]: "Constructor", type: "object", instanceOf: "Constructor", parameters: clonedParameters, returns: clonedReturns });
+        } else {
+          throw new Error("ExtendedTypeBuilder.Constructor: Invalid parameters");
+        }
+      }
+      /** `[Extended]` Creates a Date type */
+      Date(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Date", type: "object", instanceOf: "Date" });
+      }
+      Function(parameters, returns, options = {}) {
+        const clonedReturns = TypeClone.Clone(returns, {});
+        if (TypeGuard.TTuple(parameters)) {
+          const clonedParameters = parameters.items === void 0 ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}));
+          return this.Create({ ...options, [exports.Kind]: "Function", type: "object", instanceOf: "Function", parameters: clonedParameters, returns: clonedReturns });
+        } else if (globalThis.Array.isArray(parameters)) {
+          const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+          return this.Create({ ...options, [exports.Kind]: "Function", type: "object", instanceOf: "Function", parameters: clonedParameters, returns: clonedReturns });
+        } else {
+          throw new Error("ExtendedTypeBuilder.Function: Invalid parameters");
+        }
+      }
+      /** `[Extended]` Extracts the InstanceType from the given Constructor */
+      InstanceType(schema, options = {}) {
+        return TypeClone.Clone(schema.returns, options);
+      }
+      /** `[Extended]` Extracts the Parameters from the given Function type */
+      Parameters(schema, options = {}) {
+        return this.Tuple(schema.parameters, { ...options });
+      }
+      /** `[Extended]` Creates a Promise type */
+      Promise(item, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Promise", type: "object", instanceOf: "Promise", item: TypeClone.Clone(item, {}) });
+      }
+      /** `[Extended]` Creates a regular expression type */
+      RegEx(regex, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "String", type: "string", pattern: regex.source });
+      }
+      /** `[Extended]` Extracts the ReturnType from the given Function */
+      ReturnType(schema, options = {}) {
+        return TypeClone.Clone(schema.returns, options);
+      }
+      /** `[Extended]` Creates a Symbol type */
+      Symbol(options) {
+        return this.Create({ ...options, [exports.Kind]: "Symbol", type: "null", typeOf: "Symbol" });
+      }
+      /** `[Extended]` Creates a Undefined type */
+      Undefined(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Undefined", type: "null", typeOf: "Undefined" });
+      }
+      /** `[Extended]` Creates a Uint8Array type */
+      Uint8Array(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Uint8Array", type: "object", instanceOf: "Uint8Array" });
+      }
+      /** `[Extended]` Creates a Void type */
+      Void(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Void", type: "null", typeOf: "Void" });
+      }
+    };
+    exports.ExtendedTypeBuilder = ExtendedTypeBuilder;
+    exports.StandardType = new StandardTypeBuilder();
+    exports.Type = new ExtendedTypeBuilder();
+  }
+});
+
+// src/plugin/index.ts
+var import_typebox = __toESM(require_typebox(), 1);
+import { execFileSync as execFileSync2, execFile } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, renameSync, statSync as statSync3 } from "fs";
+import { join as join5, basename } from "path";
+
+// src/plugin/templates.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+var DEFAULT_SCHEMAS = [
+  {
+    primitive: "memory_event",
+    description: "General memory event for observations",
+    fields: {
+      type: { type: "string", required: true, default: "memory_event" },
+      status: { type: "string", required: true, default: "recorded", enum: ["recorded", "superseded", "corrected"] },
+      created: { type: "datetime", required: true, default: "{{datetime}}" },
+      observed_at: { type: "datetime", required: true },
+      source: { type: "string", required: true, enum: ["openclaw", "claude-code", "replay", "manual-correction"] },
+      summary: { type: "string", required: true },
+      confidence: { type: "number" },
+      importance: { type: "number" }
+    },
+    keywords: ["preference", "like", "hate", "want", "need", "always", "never", "remember", "note"]
+  },
+  {
+    primitive: "person",
+    description: "People and relationship notes",
+    fields: {
+      title: { type: "string", required: true, default: "{{title}}" },
+      date: { type: "date", required: true, default: "{{date}}" },
+      type: { type: "string", required: true, default: "person" },
+      relationship: { type: "string", default: "contact" }
+    },
+    keywords: ["person", "contact", "colleague", "friend", "works at", "lives in", "email", "phone", "name is"]
+  },
+  {
+    primitive: "decision",
+    description: "Decision records",
+    fields: {
+      title: { type: "string", required: true, default: "{{title}}" },
+      date: { type: "date", required: true, default: "{{date}}" },
+      type: { type: "string", required: true, default: "decision" },
+      status: { type: "string", default: "decided", enum: ["proposed", "decided", "superseded"] }
+    },
+    keywords: ["decided", "decision", "chose", "will use", "go with", "ship", "approved", "rejected"]
+  },
+  {
+    primitive: "task",
+    description: "Task primitives",
+    fields: {
+      status: { type: "string", required: true, default: "open", enum: ["open", "in-progress", "blocked", "done"] },
+      created: { type: "datetime", required: true, default: "{{datetime}}" },
+      updated: { type: "datetime", required: true, default: "{{datetime}}" },
+      priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
+      due: { type: "date" }
+    },
+    keywords: ["task", "todo", "need to", "should", "must", "deadline", "due", "by tomorrow", "by tonight"]
+  },
+  {
+    primitive: "project",
+    description: "Project definition documents",
+    fields: {
+      type: { type: "string", required: true, default: "project" },
+      status: { type: "string", required: true, default: "active", enum: ["active", "paused", "completed", "archived"] },
+      created: { type: "datetime", required: true, default: "{{datetime}}" },
+      updated: { type: "datetime", required: true, default: "{{datetime}}" }
+    },
+    keywords: ["project", "initiative", "working on", "building", "developing"]
+  },
+  {
+    primitive: "lesson",
+    description: "Lessons learned",
+    fields: {
+      title: { type: "string", required: true, default: "{{title}}" },
+      date: { type: "date", required: true, default: "{{date}}" },
+      type: { type: "string", required: true, default: "lesson" }
+    },
+    keywords: ["learned", "lesson", "insight", "realized", "discovered", "found out"]
+  }
+];
+function parseYamlFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+  try {
+    const frontmatter = parseSimpleYaml(match[1]);
+    return { frontmatter, body: match[2] };
+  } catch {
+    return null;
+  }
+}
+function parseSimpleYaml(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  let currentKey = "";
+  let nestedObject = null;
+  let nestedKey = "";
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const indent = line.search(/\S/);
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ")) {
+      const value = trimmed.slice(2).trim();
+      if (nestedObject && nestedKey) {
+        const arr = nestedObject[nestedKey];
+        if (Array.isArray(arr)) arr.push(parseYamlValue(value));
+      } else if (currentKey && result[currentKey]) {
+        const arr = result[currentKey];
+        if (Array.isArray(arr)) arr.push(parseYamlValue(value));
+      }
+      continue;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    const valueStr = trimmed.slice(colonIndex + 1).trim();
+    if (indent === 0) {
+      if (valueStr === "" || valueStr === "|" || valueStr === ">") {
+        if (key === "fields") {
+          result[key] = {};
+          nestedObject = result[key];
+          nestedKey = "";
+        } else {
+          result[key] = {};
+          nestedObject = null;
+        }
+      } else {
+        result[key] = parseYamlValue(valueStr);
+        nestedObject = null;
+      }
+      currentKey = key;
+    } else if (nestedObject && indent > 0) {
+      if (valueStr === "" || valueStr === "|" || valueStr === ">") {
+        nestedObject[key] = {};
+        nestedKey = key;
+      } else if (nestedKey && indent > 2) {
+        const fieldObj = nestedObject[nestedKey];
+        if (fieldObj) {
+          if (key === "enum") {
+            fieldObj[key] = [];
+          } else {
+            fieldObj[key] = parseYamlValue(valueStr);
+          }
+        }
+      } else {
+        nestedObject[key] = parseYamlValue(valueStr);
+        nestedKey = key;
+      }
+    }
+  }
+  return result;
+}
+function parseYamlValue(value) {
+  if (value === "" || value === "null" || value === "~") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+var registry = null;
+function getTemplateRegistry() {
+  if (!registry) {
+    registry = {
+      schemas: /* @__PURE__ */ new Map(),
+      keywordIndex: /* @__PURE__ */ new Map(),
+      initialized: false
+    };
+  }
+  return registry;
+}
+function initializeTemplateRegistry(templatesDir) {
+  const reg = getTemplateRegistry();
+  if (reg.initialized) return reg;
+  const dirsToTry = templatesDir ? [templatesDir] : [
+    join(process.cwd(), "templates"),
+    join(process.cwd(), "..", "..", "templates"),
+    join(process.env.HOME ?? ".", "clawvault", "templates"),
+    join(process.env.HOME ?? ".", ".clawvault", "templates")
+  ];
+  let loaded = false;
+  for (const dir of dirsToTry) {
+    if (existsSync(dir)) {
+      try {
+        loadTemplatesFromDirectory(dir, reg);
+        loaded = true;
+        break;
+      } catch {
+      }
+    }
+  }
+  if (!loaded || reg.schemas.size === 0) {
+    loadDefaultSchemas(reg);
+  }
+  buildKeywordIndex(reg);
+  reg.initialized = true;
+  return reg;
+}
+function loadTemplatesFromDirectory(dir, reg) {
+  const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parseYamlFrontmatter(content);
+    if (!parsed?.frontmatter?.primitive) continue;
+    const schema = convertFrontmatterToSchema(
+      parsed.frontmatter,
+      parsed.body
+    );
+    if (schema) {
+      reg.schemas.set(schema.primitive, schema);
+    }
+  }
+}
+function convertFrontmatterToSchema(fm, body) {
+  const primitive = fm.primitive;
+  if (!primitive) return null;
+  const fields = {};
+  const fmFields = fm.fields;
+  if (fmFields) {
+    for (const [fieldName, fieldDef] of Object.entries(fmFields)) {
+      if (typeof fieldDef === "object" && fieldDef !== null) {
+        fields[fieldName] = {
+          type: fieldDef.type || "string",
+          required: fieldDef.required,
+          default: fieldDef.default,
+          enum: fieldDef.enum,
+          description: fieldDef.description
+        };
+      }
+    }
+  }
+  const keywords = extractKeywordsFromSchema(primitive, fm.description, fields);
+  return {
+    primitive,
+    description: fm.description,
+    fields,
+    bodyTemplate: body,
+    keywords
+  };
+}
+function extractKeywordsFromSchema(primitive, _description, fields) {
+  const keywords = [primitive];
+  keywords.push(primitive.replace(/-/g, " "));
+  keywords.push(primitive.replace(/_/g, " "));
+  const keywordMap = {
+    memory_event: ["preference", "like", "hate", "want", "need", "always", "never", "remember", "note"],
+    person: ["person", "contact", "colleague", "friend", "works at", "lives in", "email", "phone", "name is"],
+    decision: ["decided", "decision", "chose", "will use", "go with", "ship", "approved", "rejected"],
+    task: ["task", "todo", "need to", "should", "must", "deadline", "due", "by tomorrow", "by tonight"],
+    project: ["project", "initiative", "working on", "building", "developing"],
+    lesson: ["learned", "lesson", "insight", "realized", "discovered", "found out"],
+    trigger: ["trigger", "schedule", "cron", "automated", "recurring"],
+    run: ["run", "execution", "job", "started", "finished", "failed"],
+    checkpoint: ["checkpoint", "snapshot", "state", "progress"],
+    handoff: ["handoff", "transition", "context", "resume"],
+    "daily-note": ["daily", "today", "journal", "log"],
+    daily: ["daily", "today", "journal", "log"],
+    party: ["party", "agent", "human", "runtime", "service"],
+    workspace: ["workspace", "shared", "collaboration"]
+  };
+  if (keywordMap[primitive]) {
+    keywords.push(...keywordMap[primitive]);
+  }
+  if (fields.status?.enum) {
+    keywords.push(...fields.status.enum);
+  }
+  return [...new Set(keywords)];
+}
+function loadDefaultSchemas(reg) {
+  for (const schema of DEFAULT_SCHEMAS) {
+    reg.schemas.set(schema.primitive, schema);
+  }
+}
+function buildKeywordIndex(reg) {
+  reg.keywordIndex.clear();
+  for (const [primitive, schema] of reg.schemas) {
+    const keywords = schema.keywords ?? [primitive];
+    for (const keyword of keywords) {
+      const lower = keyword.toLowerCase();
+      const existing = reg.keywordIndex.get(lower) ?? [];
+      if (!existing.includes(primitive)) {
+        existing.push(primitive);
+      }
+      reg.keywordIndex.set(lower, existing);
+    }
+  }
+}
+function classifyText(text) {
+  const reg = getTemplateRegistry();
+  if (!reg.initialized) initializeTemplateRegistry();
+  const lower = text.toLowerCase();
+  const scores = /* @__PURE__ */ new Map();
+  for (const [keyword, primitives] of reg.keywordIndex) {
+    if (lower.includes(keyword)) {
+      for (const primitive of primitives) {
+        const existing = scores.get(primitive) ?? { score: 0, keywords: [] };
+        existing.score += getKeywordWeight(keyword, primitive);
+        existing.keywords.push(keyword);
+        scores.set(primitive, existing);
+      }
+    }
+  }
+  applyPatternScoring(lower, scores);
+  let bestPrimitive = "memory_event";
+  let bestScore = 0;
+  let bestKeywords = [];
+  for (const [primitive, data] of scores) {
+    if (data.score > bestScore) {
+      bestScore = data.score;
+      bestPrimitive = primitive;
+      bestKeywords = data.keywords;
+    }
+  }
+  const confidence = Math.min(1, bestScore / 5);
+  return {
+    primitiveType: bestPrimitive,
+    confidence,
+    matchedKeywords: [...new Set(bestKeywords)]
+  };
+}
+function getKeywordWeight(keyword, primitive) {
+  if (keyword === primitive || keyword === primitive.replace(/-/g, " ")) return 3;
+  const strongIndicators = {
+    person: ["works at", "lives in", "email", "phone", "name is"],
+    decision: ["decided", "chose", "will use", "go with"],
+    task: ["deadline", "due", "by tomorrow", "by tonight"],
+    memory_event: ["preference", "remember", "note"]
+  };
+  if (strongIndicators[primitive]?.includes(keyword)) return 2;
+  return 1;
+}
+function applyPatternScoring(text, scores) {
+  const patterns = [
+    { regex: /\b(my .+ is|his .+ is|her .+ is|their .+ is)\b/i, primitive: "person", weight: 2, label: "possessive pattern" },
+    { regex: /[\w.-]+@[\w.-]+\.\w+|\+\d{10,}/, primitive: "person", weight: 3, label: "contact info" },
+    { regex: /\b(i prefer|i like|i hate|i love|i want|i need|i always|i never|don't like|dont like)\b/i, primitive: "memory_event", weight: 3, label: "preference pattern" },
+    { regex: /\b(we decided|let's go with|we're going|i chose|we'll use|ship it|do it)\b/i, primitive: "decision", weight: 3, label: "decision pattern" },
+    { regex: /\b(by tonight|by tomorrow|deadline|due date|by end of|ship by|ready by)\b/i, primitive: "task", weight: 2, label: "deadline pattern" }
+  ];
+  for (const { regex, primitive, weight, label } of patterns) {
+    if (regex.test(text)) {
+      const existing = scores.get(primitive) ?? { score: 0, keywords: [] };
+      existing.score += weight;
+      existing.keywords.push(label);
+      scores.set(primitive, existing);
+    }
+  }
+}
+function getSchema(primitiveType) {
+  const reg = getTemplateRegistry();
+  if (!reg.initialized) initializeTemplateRegistry();
+  return reg.schemas.get(primitiveType);
+}
+function getAllSchemas() {
+  const reg = getTemplateRegistry();
+  if (!reg.initialized) initializeTemplateRegistry();
+  return Array.from(reg.schemas.values());
+}
+function getSchemaNames() {
+  const reg = getTemplateRegistry();
+  if (!reg.initialized) initializeTemplateRegistry();
+  return Array.from(reg.schemas.keys());
+}
+function generateFrontmatter(primitiveType, options = {}) {
+  const schema = getSchema(primitiveType);
+  if (!schema) {
+    return {
+      type: primitiveType,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const frontmatter = {};
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().split("T")[0];
+  const datetimeStr = now.toISOString();
+  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+    if (options.extraFields?.[fieldName] !== void 0) {
+      const value = options.extraFields[fieldName];
+      if (fieldDef.enum && !fieldDef.enum.includes(String(value))) {
+        frontmatter[fieldName] = fieldDef.default ?? fieldDef.enum[0];
+      } else {
+        frontmatter[fieldName] = value;
+      }
+      continue;
+    }
+    if (fieldDef.default !== void 0) {
+      let defaultValue = fieldDef.default;
+      if (typeof defaultValue === "string") {
+        defaultValue = defaultValue.replace("{{datetime}}", datetimeStr).replace("{{date}}", dateStr).replace("{{title}}", options.title ?? "Untitled");
+      }
+      frontmatter[fieldName] = defaultValue;
+    } else if (fieldDef.required) {
+      switch (fieldDef.type) {
+        case "datetime":
+          frontmatter[fieldName] = datetimeStr;
+          break;
+        case "date":
+          frontmatter[fieldName] = dateStr;
+          break;
+        case "string":
+          frontmatter[fieldName] = fieldDef.enum?.length ? fieldDef.enum[0] : "";
+          break;
+        case "number":
+          frontmatter[fieldName] = 0;
+          break;
+        case "boolean":
+          frontmatter[fieldName] = false;
+          break;
+      }
+    }
+  }
+  if (options.source && schema.fields.source) frontmatter.source = options.source;
+  if (options.sessionId && schema.fields.session_id) frontmatter.session_id = options.sessionId;
+  return frontmatter;
+}
+function validateFrontmatter(primitiveType, frontmatter) {
+  const schema = getSchema(primitiveType);
+  if (!schema) return { valid: true, errors: [] };
+  const errors = [];
+  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+    const value = frontmatter[fieldName];
+    if (fieldDef.required && (value === void 0 || value === null || value === "")) {
+      errors.push(`Missing required field: ${fieldName}`);
+      continue;
+    }
+    if (value === void 0 || value === null) continue;
+    if (fieldDef.enum && !fieldDef.enum.includes(String(value))) {
+      errors.push(`Invalid value for ${fieldName}: "${String(value)}". Must be one of: ${fieldDef.enum.join(", ")}`);
+    }
+    switch (fieldDef.type) {
+      case "number":
+        if (typeof value !== "number" && isNaN(Number(value))) {
+          errors.push(`Field ${fieldName} must be a number`);
+        }
+        break;
+      case "boolean":
+        if (typeof value !== "boolean" && value !== "true" && value !== "false") {
+          errors.push(`Field ${fieldName} must be a boolean`);
+        }
+        break;
+      case "datetime":
+        if (typeof value === "string" && isNaN(Date.parse(value))) {
+          errors.push(`Field ${fieldName} must be a valid datetime`);
+        }
+        break;
+      case "date":
+        if (typeof value === "string" && !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+          errors.push(`Field ${fieldName} must be a valid date (YYYY-MM-DD)`);
+        }
+        break;
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function serializeFrontmatter(frontmatter) {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      lines.push(`${key}:`);
+      for (const item of value) {
+        lines.push(`  - ${String(item)}`);
+      }
+    } else if (typeof value === "object") {
+      lines.push(`${key}: ${JSON.stringify(value)}`);
+    } else if (typeof value === "string" && value.includes("\n")) {
+      lines.push(`${key}: |`);
+      for (const line of value.split("\n")) {
+        lines.push(`  ${line}`);
+      }
+    } else {
+      lines.push(`${key}: ${String(value)}`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+
+// src/plugin/noise-filter.ts
+var REFUSAL_PATTERNS = [
+  /\b(i can'?t help with|i'?m not able to|i cannot|i'?m unable to|as an ai|i don'?t have the ability)\b/i,
+  /\b(i'?m sorry,?\s+(?:but )?i|unfortunately,?\s+i (?:can'?t|cannot))\b/i,
+  /\b(that'?s (?:beyond|outside) my|i'?m not (?:designed|programmed) to)\b/i,
+  /\b(i (?:must |need to )?(?:decline|refuse)|i won'?t be able to)\b/i
+];
+var META_PATTERNS = [
+  /\b(how does it feel|what'?s it like being|are you (?:sentient|conscious|alive|real))\b/i,
+  /\b(do you have (?:feelings|emotions|consciousness|a soul))\b/i,
+  /\b(what are you|who made you|who created you|what model are you)\b/i,
+  /\b(can you think|do you dream|are you aware)\b/i
+];
+var GREETING_PATTERNS = [
+  /^(?:hi|hello|hey|howdy|greetings|good (?:morning|afternoon|evening)|what'?s up|sup|yo)\s*[!.?]?\s*$/i,
+  /^(?:thanks?|thank you|thx|ty|cheers)\s*[!.?]?\s*$/i,
+  /^(?:ok|okay|sure|got it|understood|perfect|great|cool|nice|awesome)\s*[!.?]?\s*$/i,
+  /^(?:bye|goodbye|see you|later|gn|good night|cya)\s*[!.?]?\s*$/i
+];
+var LOW_INFO_PATTERNS = [
+  /^[!?.]+$/,
+  // Just punctuation
+  /^[\p{Emoji}\s]+$/u,
+  // Emoji-only
+  /^(?:yes|no|maybe|idk|hmm|hm|ah|oh|uh|um|lol|lmao|haha|heh)\s*[!.?]*$/i
+];
+var SYSTEM_NOISE_PATTERNS = [
+  /^(?:\[System|HEARTBEAT|NO_REPLY)/,
+  /^<(?:relevant-memories|session-recap|user-preferences)/,
+  /^\s*\{[\s\S]*"(?:type|action|tool_use)"[\s\S]*\}\s*$/
+  // JSON tool calls
+];
+var DEFAULT_NOISE_CONFIG = {
+  enabled: true,
+  minLength: 15,
+  maxLength: 5e3
+};
+function isNoise(text, config = DEFAULT_NOISE_CONFIG) {
+  if (!config.enabled) return { isNoise: false };
+  if (!text) return { isNoise: true, category: "length", reason: "Empty text" };
+  const trimmed = text.trim();
+  if (trimmed.length < config.minLength) {
+    return { isNoise: true, category: "length", reason: `Too short (${trimmed.length} < ${config.minLength})` };
+  }
+  if (trimmed.length > config.maxLength) {
+    return { isNoise: true, category: "length", reason: `Too long (${trimmed.length} > ${config.maxLength})` };
+  }
+  for (const pattern of SYSTEM_NOISE_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { isNoise: true, category: "system", reason: "System noise" };
+    }
+  }
+  for (const pattern of GREETING_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { isNoise: true, category: "greeting", reason: "Greeting/acknowledgment" };
+    }
+  }
+  for (const pattern of LOW_INFO_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { isNoise: true, category: "low_info", reason: "Low information content" };
+    }
+  }
+  for (const pattern of REFUSAL_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { isNoise: true, category: "refusal", reason: "AI refusal" };
+    }
+  }
+  for (const pattern of META_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { isNoise: true, category: "meta", reason: "Meta-question about AI" };
+    }
+  }
+  const markdownChars = (trimmed.match(/[#*`\-|>]/g) || []).length;
+  if (markdownChars / trimmed.length > 0.15) {
+    return { isNoise: true, category: "system", reason: "High markdown density (likely code/formatting)" };
+  }
+  return { isNoise: false };
+}
+
+// src/plugin/observe.ts
+function isObservable(text, noiseConfig) {
+  if (!text || text.length < 20 || text.length > 5e3) return false;
+  const check = isNoise(text, noiseConfig ?? DEFAULT_NOISE_CONFIG);
+  return !check.isNoise;
+}
+var OBSERVATION_PATTERNS = [
+  // Preferences
+  { pattern: /\b(i prefer|i like|i hate|i love|i want|i need|i always|i never|don't like|dont like)\b/i, weight: 2 },
+  // Decisions
+  { pattern: /\b(we decided|let's go with|we're going|i chose|we'll use|ship it|do it|go with)\b/i, weight: 2 },
+  // Facts about people/things
+  { pattern: /\b(my .+ is|his .+ is|her .+ is|their .+ is|works at|lives in|born in)\b/i, weight: 1.5 },
+  // Contact info
+  { pattern: /[\w.-]+@[\w.-]+\.\w+|\+\d{10,}/i, weight: 2 },
+  // Explicit memory request
+  { pattern: /\b(remember|don't forget|keep in mind|note that|important:)\b/i, weight: 2.5 },
+  // Deadlines/dates
+  { pattern: /\b(by tonight|by tomorrow|deadline|due date|by end of|ship by|ready by)\b/i, weight: 1.5 },
+  // Lessons learned
+  { pattern: /\b(i learned|we learned|lesson|realized|discovered|found out)\b/i, weight: 1.5 },
+  // Tasks
+  { pattern: /\b(need to|should|must|have to|todo|task)\b/i, weight: 1 },
+  // Projects
+  { pattern: /\b(working on|building|developing|project|initiative)\b/i, weight: 1 }
+];
+function extractObservations(text) {
+  const observations = [];
+  const sentences = splitIntoSentences(text);
+  const now = /* @__PURE__ */ new Date();
+  for (const sentence of sentences) {
+    if (sentence.length < 15) continue;
+    let totalWeight = 0;
+    for (const { pattern, weight } of OBSERVATION_PATTERNS) {
+      if (pattern.test(sentence)) {
+        totalWeight += weight;
+      }
+    }
+    if (totalWeight < 1) continue;
+    const classification = classifyText(sentence);
+    const category = deriveCategoryFromPrimitive(classification.primitiveType, sentence);
+    const tags = generateTags(classification, sentence);
+    observations.push({
+      text: sentence.trim(),
+      primitiveType: classification.primitiveType,
+      confidence: classification.confidence,
+      matchedKeywords: classification.matchedKeywords,
+      category,
+      tags,
+      extractedAt: now
+    });
+  }
+  return observations;
+}
+function splitIntoSentences(text) {
+  const raw = text.split(/(?<=[.!?\n])\s+/);
+  return raw.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function deriveCategoryFromPrimitive(primitiveType, text) {
+  const lower = text.toLowerCase();
+  if (primitiveType === "memory_event") {
+    if (/prefer|like|love|hate|want|need|always|never/i.test(lower)) return "preference";
+    if (/remember|don't forget|keep in mind|note that/i.test(lower)) return "note";
+    return "fact";
+  }
+  const categoryMap = {
+    person: "entity",
+    decision: "decision",
+    task: "task",
+    project: "project",
+    lesson: "lesson",
+    trigger: "automation",
+    run: "execution",
+    checkpoint: "checkpoint",
+    handoff: "handoff",
+    "daily-note": "daily",
+    daily: "daily",
+    party: "entity",
+    workspace: "workspace"
+  };
+  return categoryMap[primitiveType] ?? "fact";
+}
+function generateTags(classification, text) {
+  const tags = [classification.primitiveType];
+  const lower = text.toLowerCase();
+  if (/prefer|like|love/i.test(lower)) tags.push("positive");
+  if (/hate|dislike|don't like/i.test(lower)) tags.push("negative");
+  if (/deadline|due|by tomorrow|by tonight/i.test(lower)) tags.push("time-sensitive");
+  if (/important|critical|urgent/i.test(lower)) tags.push("high-priority");
+  if (/email|phone|contact/i.test(lower)) tags.push("contact-info");
+  if (/decided|chose|approved/i.test(lower)) tags.push("finalized");
+  if (/proposed|considering|might/i.test(lower)) tags.push("tentative");
+  return [...new Set(tags)];
+}
+function processMessageForObservations(content, _options = {}) {
+  if (!isObservable(content)) {
+    return {
+      observations: [],
+      skipped: 1,
+      reason: "Content not observable"
+    };
+  }
+  const observations = extractObservations(content);
+  const maxObservations = 5;
+  const limited = observations.slice(0, maxObservations);
+  const skipped = observations.length - limited.length;
+  return {
+    observations: limited,
+    skipped,
+    reason: skipped > 0 ? `Limited to ${maxObservations} observations` : void 0
+  };
+}
+function detectCategory(text) {
+  const classification = classifyText(text);
+  return deriveCategoryFromPrimitive(classification.primitiveType, text);
+}
+function extractSearchTerms(input) {
+  const noise = /\b(hey|hi|hello|um|uh|like|just|so|well|you know|i mean|basically|actually|really|very|pretty|quite|how does it feel|how do you|can you|could you|would you|do you|what do you think|tell me about)\b/gi;
+  let cleaned = input.replace(noise, " ").replace(/\s+/g, " ").trim();
+  if (cleaned.length < 5) cleaned = input.trim();
+  return cleaned;
+}
+
+// src/plugin/inject.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join2, relative } from "path";
+function parseYamlFrontmatter2(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+  try {
+    const frontmatter = parseSimpleYaml2(match[1]);
+    return { frontmatter, body: match[2] };
+  } catch {
+    return null;
+  }
+}
+function parseSimpleYaml2(yaml) {
+  const result = {};
+  for (const line of yaml.split("\n")) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const valueStr = line.slice(colonIndex + 1).trim();
+    if (valueStr === "" || valueStr.startsWith("|") || valueStr.startsWith(">")) continue;
+    result[key] = parseYamlValue2(valueStr);
+  }
+  return result;
+}
+function parseYamlValue2(value) {
+  if (value === "" || value === "null" || value === "~") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function scanVaultFiles(vaultPath, options = {}) {
+  const files = [];
+  const maxAge = options.maxAge ?? 7 * 24 * 60 * 60 * 1e3;
+  const limit = options.limit ?? 100;
+  const now = Date.now();
+  const cutoff = now - maxAge;
+  const dirsToScan = findVaultDirectories(vaultPath);
+  for (const dir of dirsToScan) {
+    if (!existsSync2(dir)) continue;
+    try {
+      scanDirectory(dir, vaultPath, files, cutoff, options.primitiveTypes);
+    } catch {
+    }
+  }
+  files.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+  return files.slice(0, limit);
+}
+function findVaultDirectories(vaultPath) {
+  const dirs = [vaultPath];
+  const commonDirs = [
+    "tasks",
+    "projects",
+    "decisions",
+    "people",
+    "persons",
+    "notes",
+    "daily",
+    "journal",
+    "ledger",
+    "memory",
+    "memories",
+    "observations",
+    "lessons",
+    "triggers",
+    "runs",
+    "checkpoints",
+    "handoffs",
+    "workspaces",
+    "parties"
+  ];
+  for (const subdir of commonDirs) {
+    const fullPath = join2(vaultPath, subdir);
+    if (existsSync2(fullPath)) dirs.push(fullPath);
+  }
+  try {
+    const entries = readdirSync2(vaultPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
+        const fullPath = join2(vaultPath, entry.name);
+        if (!dirs.includes(fullPath)) dirs.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return dirs;
+}
+function scanDirectory(dir, vaultPath, files, cutoff, primitiveTypes) {
+  const entries = readdirSync2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      const depth = fullPath.replace(vaultPath, "").split("/").length;
+      if (depth <= 3) {
+        scanDirectory(fullPath, vaultPath, files, cutoff, primitiveTypes);
+      }
+    } else if (entry.name.endsWith(".md")) {
+      try {
+        const stat = statSync(fullPath);
+        if (stat.mtimeMs < cutoff) continue;
+        const content = readFileSync2(fullPath, "utf-8");
+        const parsed = parseYamlFrontmatter2(content);
+        if (!parsed) continue;
+        const primitiveType = detectPrimitiveType(parsed.frontmatter, fullPath);
+        if (primitiveTypes && !primitiveTypes.includes(primitiveType)) continue;
+        files.push({
+          path: fullPath,
+          relativePath: relative(vaultPath, fullPath),
+          primitiveType,
+          frontmatter: parsed.frontmatter,
+          content: parsed.body,
+          modifiedAt: stat.mtime,
+          createdAt: stat.birthtime
+        });
+      } catch {
+      }
+    }
+  }
+}
+function detectPrimitiveType(frontmatter, filePath) {
+  if (frontmatter.primitive) return String(frontmatter.primitive);
+  if (frontmatter.type) return String(frontmatter.type);
+  const pathLower = filePath.toLowerCase();
+  const pathMap = {
+    "/tasks/": "task",
+    "/projects/": "project",
+    "/decisions/": "decision",
+    "/people/": "person",
+    "/persons/": "person",
+    "/daily/": "daily-note",
+    "/journal/": "daily-note",
+    "/lessons/": "lesson",
+    "/triggers/": "trigger",
+    "/runs/": "run",
+    "/checkpoints/": "checkpoint",
+    "/handoffs/": "handoff",
+    "/ledger/": "memory_event",
+    "/memory/": "memory_event",
+    "/memories/": "memory_event"
+  };
+  for (const [segment, type] of Object.entries(pathMap)) {
+    if (pathLower.includes(segment)) return type;
+  }
+  return "unknown";
+}
+function buildSessionRecap(vaultPath, options = {}) {
+  const maxAge = options.maxAge ?? 24 * 60 * 60 * 1e3;
+  const limit = options.limit ?? 20;
+  const includeContent = options.includeContent ?? false;
+  const files = scanVaultFiles(vaultPath, { maxAge, limit });
+  if (files.length === 0) {
+    return { xml: "", fileCount: 0, primitiveGroups: {}, timeRange: null };
+  }
+  const groups = {};
+  for (const file of files) {
+    const type = file.primitiveType;
+    if (!groups[type]) groups[type] = [];
+    groups[type].push(file);
+  }
+  const lines = ["<session-recap>"];
+  lines.push(`<summary>Found ${files.length} recent items across ${Object.keys(groups).length} categories</summary>`);
+  for (const [primitiveType, groupFiles] of Object.entries(groups)) {
+    lines.push(`<${primitiveType}-items count="${groupFiles.length}">`);
+    for (const file of groupFiles.slice(0, 5)) {
+      const title = file.frontmatter.title || file.frontmatter.summary || file.relativePath;
+      const status = file.frontmatter.status || "";
+      const modified = file.modifiedAt.toISOString().slice(0, 16).replace("T", " ");
+      lines.push(`  <item path="${file.relativePath}" modified="${modified}"${status ? ` status="${String(status)}"` : ""}>`);
+      lines.push(`    <title>${escapeXml(String(title))}</title>`);
+      if (includeContent && file.content) {
+        const snippet = file.content.slice(0, 200).replace(/\n/g, " ").trim();
+        if (snippet) {
+          lines.push(`    <snippet>${escapeXml(snippet)}</snippet>`);
+        }
+      }
+      lines.push("  </item>");
+    }
+    if (groupFiles.length > 5) {
+      lines.push(`  <more count="${groupFiles.length - 5}" />`);
+    }
+    lines.push(`</${primitiveType}-items>`);
+  }
+  lines.push("</session-recap>");
+  const sortedByTime = [...files].sort((a, b) => a.modifiedAt.getTime() - b.modifiedAt.getTime());
+  const timeRange = {
+    oldest: sortedByTime[0].modifiedAt,
+    newest: sortedByTime[sortedByTime.length - 1].modifiedAt
+  };
+  const primitiveGroups = {};
+  for (const [type, groupFiles] of Object.entries(groups)) {
+    primitiveGroups[type] = groupFiles.length;
+  }
+  return { xml: lines.join("\n"), fileCount: files.length, primitiveGroups, timeRange };
+}
+function buildPreferenceContext(vaultPath, options = {}) {
+  const maxAge = options.maxAge ?? 30 * 24 * 60 * 60 * 1e3;
+  const limit = options.limit ?? 50;
+  const files = scanVaultFiles(vaultPath, { maxAge, limit: limit * 2 });
+  const preferenceFiles = files.filter((file) => {
+    if (file.frontmatter.type === "preference") return true;
+    if (file.primitiveType === "memory_event" && file.frontmatter.type === "preference") return true;
+    const content = (file.content || "").toLowerCase();
+    return /\b(prefer|like|love|hate|dislike|want|need|always|never)\b/.test(content);
+  }).slice(0, limit);
+  if (preferenceFiles.length === 0) {
+    return { xml: "", preferenceCount: 0, categories: [] };
+  }
+  const categories = /* @__PURE__ */ new Set();
+  for (const file of preferenceFiles) {
+    if (file.frontmatter.category) categories.add(String(file.frontmatter.category));
+  }
+  const lines = ["<user-preferences>"];
+  for (const file of preferenceFiles) {
+    const summary = file.frontmatter.summary || file.frontmatter.title || extractPreferenceSummary(file.content);
+    if (!summary) continue;
+    const category = file.frontmatter.category || "general";
+    const sentiment = file.frontmatter.sentiment || inferSentiment(file.content);
+    lines.push(`  <preference category="${escapeXml(String(category))}" sentiment="${String(sentiment)}">`);
+    lines.push(`    ${escapeXml(String(summary))}`);
+    lines.push("  </preference>");
+  }
+  lines.push("</user-preferences>");
+  return {
+    xml: lines.join("\n"),
+    preferenceCount: preferenceFiles.length,
+    categories: Array.from(categories)
+  };
+}
+function extractPreferenceSummary(content) {
+  if (!content) return "";
+  const sentences = content.split(/[.!?\n]+/).map((s) => s.trim()).filter((s) => s.length > 10);
+  for (const sentence of sentences) {
+    if (/\b(prefer|like|love|hate|dislike|want|need|always|never)\b/i.test(sentence)) {
+      return sentence.slice(0, 150);
+    }
+  }
+  return sentences[0]?.slice(0, 150) || "";
+}
+function inferSentiment(content) {
+  if (!content) return "neutral";
+  const lower = content.toLowerCase();
+  if (/\b(love|like|prefer|enjoy|want|need|always)\b/.test(lower)) return "positive";
+  if (/\b(hate|dislike|don't like|never|avoid)\b/.test(lower)) return "negative";
+  return "neutral";
+}
+function formatMemoriesForContext(results, collection) {
+  if (results.length === 0) return "";
+  const lines = results.map((r, i) => {
+    const file = (r.file || "").replace(`qmd://${collection}/`, "");
+    const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "";
+    return `${i + 1}. [${file}] ${snippet}`;
+  });
+  return `<relevant-memories>
+These are recalled from long-term vault memory. Treat as historical context.
+${lines.join("\n")}
+</relevant-memories>`;
+}
+function formatSearchResults(results, collection) {
+  if (results.length === 0) return "No relevant memories found.";
+  return results.map((r, i) => {
+    const file = (r.file || "").replace(`qmd://${collection}/`, "");
+    const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "(no content)";
+    const score = ((r.score ?? 0) * 100).toFixed(0);
+    return `${i + 1}. [${file}] ${snippet} (${score}%)`;
+  }).join("\n");
+}
+function buildFullContext(vaultPath, options = {}) {
+  const parts = [];
+  if (options.includeRecap !== false) {
+    const recap = buildSessionRecap(vaultPath, {
+      maxAge: options.recapMaxAge ?? 24 * 60 * 60 * 1e3,
+      limit: 15,
+      includeContent: true
+    });
+    if (recap.xml) parts.push(recap.xml);
+  }
+  if (options.includePreferences !== false) {
+    const prefs = buildPreferenceContext(vaultPath, {
+      maxAge: options.preferenceMaxAge ?? 30 * 24 * 60 * 60 * 1e3,
+      limit: 20
+    });
+    if (prefs.xml) parts.push(prefs.xml);
+  }
+  return parts.join("\n\n");
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
 
-// src/plugin/index.ts
-import { execFileSync, execFile } from "child_process";
-import { existsSync, readFileSync, mkdirSync } from "fs";
-import { join, basename } from "path";
-import { Type } from "@sinclair/typebox";
-function resolveVaultPath(cfg) {
-  if (cfg?.vaultPath) return cfg.vaultPath;
-  if (process.env.CLAWVAULT_PATH) return process.env.CLAWVAULT_PATH;
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
-  for (const candidate of [`${home}/clawvault`, `${home}/.clawvault`]) {
-    if (existsSync(join(candidate, ".clawvault.json"))) return candidate;
+// src/plugin/vault.ts
+import { existsSync as existsSync3, mkdirSync, writeFileSync, readFileSync as readFileSync3, appendFileSync } from "fs";
+import { join as join3 } from "path";
+var autoEmbedFn = null;
+function setAutoEmbedFn(fn) {
+  autoEmbedFn = fn;
+}
+async function autoEmbed(filePath, content) {
+  if (autoEmbedFn) {
+    await autoEmbedFn(filePath, content).catch(() => {
+    });
   }
-  return `${home}/.clawvault`;
 }
-function getVaultConfig(vaultPath) {
-  const configPath = join(vaultPath, ".clawvault.json");
-  if (!existsSync(configPath)) return null;
+function writeVaultFile(vaultPath, options) {
+  const errors = [];
+  const primitiveType = options.primitiveType ?? classifyText(options.content ?? options.title ?? "").primitiveType;
+  const schema = getSchema(primitiveType);
+  const frontmatter = generateFrontmatter(primitiveType, {
+    title: options.title,
+    extraFields: options.extraFields,
+    source: options.source,
+    sessionId: options.sessionId
+  });
+  const validation = validateFrontmatter(primitiveType, frontmatter);
+  if (!validation.valid) errors.push(...validation.errors);
+  const directory = options.directory ?? getDefaultDirectory(vaultPath, primitiveType);
+  if (!existsSync3(directory)) {
+    mkdirSync(directory, { recursive: true });
+  }
+  const filename = options.filename ?? generateFilename(primitiveType, options.title, frontmatter);
+  const filePath = join3(directory, filename);
+  const fileExists = existsSync3(filePath);
+  if (fileExists && !options.overwrite) {
+    return updateVaultFile(filePath, frontmatter, options.content, primitiveType, errors);
+  }
+  const fileContent = buildFileContent(frontmatter, options.content, schema);
+  try {
+    writeFileSync(filePath, fileContent, "utf-8");
+    autoEmbed(filePath, fileContent).catch(() => {
+    });
+    return {
+      success: errors.length === 0,
+      path: filePath,
+      primitiveType,
+      errors,
+      created: true,
+      updated: false
+    };
+  } catch (err) {
+    errors.push(`Failed to write file: ${String(err)}`);
+    return {
+      success: false,
+      path: filePath,
+      primitiveType,
+      errors,
+      created: false,
+      updated: false
+    };
+  }
+}
+function updateVaultFile(filePath, newFrontmatter, newContent, primitiveType, errors) {
+  try {
+    const existingContent = readFileSync3(filePath, "utf-8");
+    const parsed = parseExistingFile(existingContent);
+    if (!parsed) {
+      errors.push("Failed to parse existing file");
+      return { success: false, path: filePath, primitiveType, errors, created: false, updated: false };
+    }
+    const mergedFrontmatter = {
+      ...parsed.frontmatter,
+      ...newFrontmatter,
+      updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (parsed.frontmatter.created) {
+      mergedFrontmatter.created = parsed.frontmatter.created;
+    }
+    const content = newContent ?? parsed.body;
+    const schema = getSchema(primitiveType);
+    const fileContent = buildFileContent(mergedFrontmatter, content, schema);
+    writeFileSync(filePath, fileContent, "utf-8");
+    return {
+      success: errors.length === 0,
+      path: filePath,
+      primitiveType,
+      errors,
+      created: false,
+      updated: true
+    };
+  } catch (err) {
+    errors.push(`Failed to update file: ${String(err)}`);
+    return { success: false, path: filePath, primitiveType, errors, created: false, updated: false };
+  }
+}
+function parseExistingFile(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+  try {
+    const result = {};
+    for (const line of match[1].split("\n")) {
+      if (!line.trim() || line.trim().startsWith("#")) continue;
+      const colonIndex = line.indexOf(":");
+      if (colonIndex === -1) continue;
+      const key = line.slice(0, colonIndex).trim();
+      const valueStr = line.slice(colonIndex + 1).trim();
+      if (valueStr === "" || valueStr.startsWith("|") || valueStr.startsWith(">")) continue;
+      result[key] = parseSimpleValue(valueStr);
+    }
+    return { frontmatter: result, body: match[2] };
+  } catch {
+    return null;
+  }
+}
+function parseSimpleValue(value) {
+  if (value === "" || value === "null" || value === "~") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function getDefaultDirectory(vaultPath, primitiveType) {
+  const directoryMap = {
+    task: "tasks",
+    project: "projects",
+    decision: "decisions",
+    person: "people",
+    lesson: "lessons",
+    trigger: "triggers",
+    run: "runs",
+    checkpoint: "checkpoints",
+    handoff: "handoffs",
+    "daily-note": "daily",
+    daily: "daily",
+    party: "parties",
+    workspace: "workspaces",
+    memory_event: "memory"
+  };
+  const subdir = directoryMap[primitiveType] ?? "notes";
+  return join3(vaultPath, subdir);
+}
+function generateFilename(primitiveType, title, _frontmatter) {
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().split("T")[0];
+  const timeStr = now.toISOString().slice(11, 19).replace(/:/g, "");
+  if (title) {
+    const slug = slugify(title);
+    return `${dateStr}-${slug}.md`;
+  }
+  switch (primitiveType) {
+    case "daily-note":
+    case "daily":
+      return `${dateStr}.md`;
+    case "memory_event":
+      return `${dateStr}-${timeStr}.md`;
+    case "run":
+      return `run-${dateStr}-${timeStr}.md`;
+    case "checkpoint":
+      return `checkpoint-${dateStr}-${timeStr}.md`;
+    case "handoff":
+      return `handoff-${dateStr}-${timeStr}.md`;
+    default:
+      return `${primitiveType}-${dateStr}-${timeStr}.md`;
+  }
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+}
+function buildFileContent(frontmatter, content, schema) {
+  const parts = [];
+  parts.push(serializeFrontmatter(frontmatter));
+  parts.push("");
+  const title = frontmatter.title || frontmatter.summary;
+  if (title) {
+    parts.push(`# ${String(title)}`);
+    parts.push("");
+  }
+  if (content) {
+    parts.push(content);
+  } else if (schema?.bodyTemplate) {
+    let body = schema.bodyTemplate;
+    body = body.replace(/\{\{title\}\}/g, String(title || "Untitled"));
+    body = body.replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
+    body = body.replace(/\{\{datetime\}\}/g, (/* @__PURE__ */ new Date()).toISOString());
+    body = body.replace(/\{\{links_line\}\}/g, "");
+    body = body.replace(/\{\{content\}\}/g, "");
+    parts.push(body.trim());
+  }
+  return parts.join("\n");
+}
+function writeObservation(vaultPath, observation, options = {}) {
+  const extraFields = {
+    type: observation.primitiveType === "memory_event" ? observation.category : observation.primitiveType,
+    confidence: observation.confidence,
+    tags: observation.tags,
+    observed_at: observation.extractedAt.toISOString()
+  };
+  if (options.scope && options.scope !== "global") {
+    extraFields.scope = options.scope;
+  }
+  return writeVaultFile(vaultPath, {
+    primitiveType: observation.primitiveType,
+    title: observation.text.slice(0, 80),
+    content: observation.text,
+    extraFields,
+    source: options.source ?? "openclaw",
+    sessionId: options.sessionId
+  });
+}
+function appendToLedger(vaultPath, entry) {
+  const dateStr = entry.timestamp.toISOString().slice(0, 10);
+  const ledgerDir = join3(vaultPath, "ledger");
+  if (!existsSync3(ledgerDir)) {
+    mkdirSync(ledgerDir, { recursive: true });
+  }
+  const ledgerFile = join3(ledgerDir, `${dateStr}.md`);
+  const timeStr = entry.timestamp.toISOString().slice(11, 19);
+  const parts = [`[${timeStr}]`];
+  if (entry.category) parts.push(`[${entry.category}]`);
+  if (entry.actor) parts.push(`(${entry.actor})`);
+  parts.push(entry.content);
+  const line = `
+- ${parts.join(" ")}`;
+  if (!existsSync3(ledgerFile)) {
+    const frontmatter = serializeFrontmatter({
+      type: "ledger",
+      date: dateStr,
+      created: entry.timestamp.toISOString()
+    });
+    writeFileSync(ledgerFile, `${frontmatter}
+
+# Observation Ledger \u2014 ${dateStr}
+${line}`, "utf-8");
+  } else {
+    appendFileSync(ledgerFile, line, "utf-8");
+  }
+}
+function appendObservationToLedger(vaultPath, observation, actor) {
+  appendToLedger(vaultPath, {
+    timestamp: observation.extractedAt,
+    category: observation.category,
+    actor,
+    content: observation.text,
+    primitiveType: observation.primitiveType,
+    tags: observation.tags
+  });
+}
+function batchWriteObservations(vaultPath, observations, options = {}) {
+  const results = [];
+  let successful = 0;
+  let failed = 0;
+  const writeLedger = options.writeLedger ?? true;
+  const writeFiles = options.writeFiles ?? false;
+  for (const observation of observations) {
+    if (writeLedger) {
+      try {
+        appendObservationToLedger(vaultPath, observation, options.actor);
+      } catch {
+      }
+    }
+    if (writeFiles) {
+      const result = writeObservation(vaultPath, observation, {
+        source: options.source,
+        sessionId: options.sessionId
+      });
+      results.push(result);
+      if (result.success) successful++;
+      else failed++;
+    } else {
+      successful++;
+      results.push({
+        success: true,
+        path: join3(vaultPath, "ledger", `${observation.extractedAt.toISOString().slice(0, 10)}.md`),
+        primitiveType: observation.primitiveType,
+        errors: [],
+        created: false,
+        updated: true
+      });
+    }
+  }
+  return { total: observations.length, successful, failed, results };
+}
+function ensureVaultStructure(vaultPath) {
+  const directories = [
+    "tasks",
+    "projects",
+    "decisions",
+    "people",
+    "lessons",
+    "memory",
+    "ledger",
+    "daily"
+  ];
+  for (const dir of directories) {
+    const fullPath = join3(vaultPath, dir);
+    if (!existsSync3(fullPath)) {
+      mkdirSync(fullPath, { recursive: true });
+    }
+  }
+}
+
+// src/plugin/retrieval.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join4, relative as relative2 } from "path";
+
+// src/plugin/types.ts
+function parseScope(scope) {
+  if (scope === "global") return "global";
+  if (scope.startsWith("agent:") || scope.startsWith("project:") || scope.startsWith("user:")) {
+    return scope;
+  }
+  return "global";
+}
+function matchesScope(itemScope, filterScope) {
+  if (filterScope === "global") return true;
+  return itemScope === filterScope;
+}
+var DEFAULT_RETRIEVAL_CONFIG = {
+  bm25Weight: 0.5,
+  semanticWeight: 0.5,
+  rrfK: 60,
+  topK: 10,
+  minScore: 0.01,
+  recencyHalfLifeDays: 14,
+  recencyWeight: 0.1,
+  decayHalfLifeDays: 60,
+  lengthNormAnchor: 500,
+  mmrLambda: 0.7,
+  rerankWeight: 0.6
+};
+
+// src/plugin/retrieval.ts
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 1);
+}
+function bm25Search(query, documents, topK) {
+  const queryTerms = tokenize(query);
+  if (queryTerms.length === 0 || documents.length === 0) return [];
+  const k1 = 1.2;
+  const b = 0.75;
+  const N = documents.length;
+  const docTokens = documents.map((d) => tokenize(`${d.title} ${d.content}`));
+  const avgDl = docTokens.reduce((sum, t) => sum + t.length, 0) / N;
+  const df = /* @__PURE__ */ new Map();
+  for (const term of queryTerms) {
+    let count = 0;
+    for (const tokens of docTokens) {
+      if (tokens.includes(term)) count++;
+    }
+    df.set(term, count);
+  }
+  const results = [];
+  for (let i = 0; i < documents.length; i++) {
+    const doc = documents[i];
+    const tokens = docTokens[i];
+    const dl = tokens.length;
+    let score = 0;
+    const tf = /* @__PURE__ */ new Map();
+    for (const t of tokens) {
+      tf.set(t, (tf.get(t) || 0) + 1);
+    }
+    for (const term of queryTerms) {
+      const termFreq = tf.get(term) || 0;
+      if (termFreq === 0) continue;
+      const docFreq = df.get(term) || 0;
+      const idf = Math.log((N - docFreq + 0.5) / (docFreq + 0.5) + 1);
+      const tfNorm = termFreq * (k1 + 1) / (termFreq + k1 * (1 - b + b * dl / avgDl));
+      score += idf * tfNorm;
+    }
+    if (score > 0) {
+      results.push({ id: doc.id, score, doc });
+    }
+  }
+  results.sort((a, b2) => b2.score - a.score);
+  return results.slice(0, topK);
+}
+var embeddingPipeline = null;
+var pipelineLoading = null;
+async function getEmbeddingPipeline() {
+  if (embeddingPipeline) return embeddingPipeline;
+  if (pipelineLoading) return pipelineLoading;
+  pipelineLoading = (async () => {
+    const { pipeline } = await import("@huggingface/transformers");
+    embeddingPipeline = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+      dtype: "fp32"
+    });
+    return embeddingPipeline;
+  })();
+  return pipelineLoading;
+}
+async function embed(text) {
+  const pipe = await getEmbeddingPipeline();
+  const result = await pipe(
+    text,
+    { pooling: "mean", 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 loadEmbeddingCache(vaultPath) {
+  const cachePath = join4(vaultPath, ".clawvault", "embeddings.bin.json");
+  const cache = /* @__PURE__ */ new Map();
+  if (!existsSync4(cachePath)) return cache;
+  try {
+    const data = JSON.parse(readFileSync4(cachePath, "utf-8"));
+    for (const [key, arr] of Object.entries(data)) {
+      cache.set(key, new Float32Array(arr));
+    }
+  } catch {
+  }
+  return cache;
+}
+async function semanticSearch(query, cache, topK) {
+  if (cache.size === 0) return [];
+  const queryEmb = await embed(query);
+  const results = [];
+  for (const [id, docEmb] of cache.entries()) {
+    results.push({ id, score: cosineSimilarity(queryEmb, docEmb) });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, topK);
+}
+function reciprocalRankFusion(list1, list2, k = 60, weight1 = 0.5, weight2 = 0.5) {
+  const scores = /* @__PURE__ */ new Map();
+  for (let rank = 0; rank < list1.length; rank++) {
+    const { id } = list1[rank];
+    scores.set(id, (scores.get(id) || 0) + weight1 / (k + rank + 1));
+  }
+  for (let rank = 0; rank < list2.length; rank++) {
+    const { id } = list2[rank];
+    scores.set(id, (scores.get(id) || 0) + weight2 / (k + rank + 1));
+  }
+  return Array.from(scores.entries()).map(([id, score]) => ({ id, score })).sort((a, b) => b.score - a.score);
+}
+async function crossEncoderRerank(query, documents, config) {
+  if (!config.rerankProvider || !config.rerankApiKey) return null;
+  if (documents.length === 0) return null;
+  const endpoints = {
+    jina: "https://api.jina.ai/v1/rerank",
+    voyage: "https://api.voyageai.com/v1/rerank",
+    siliconflow: "https://api.siliconflow.cn/v1/rerank",
+    pinecone: "https://api.pinecone.io/rerank"
+  };
+  const models = {
+    jina: "jina-reranker-v2-base-multilingual",
+    voyage: "rerank-2",
+    siliconflow: "BAAI/bge-reranker-v2-m3",
+    pinecone: "bge-reranker-v2-m3"
+  };
+  const endpoint = config.rerankEndpoint || endpoints[config.rerankProvider];
+  const model = config.rerankModel || models[config.rerankProvider];
+  if (!endpoint) return null;
   try {
-    return JSON.parse(readFileSync(configPath, "utf-8"));
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.rerankApiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        query,
+        documents,
+        top_n: documents.length
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (!data.results) return null;
+    const scores = new Array(documents.length).fill(0);
+    for (const result of data.results) {
+      if (result.index >= 0 && result.index < documents.length) {
+        scores[result.index] = result.relevance_score;
+      }
+    }
+    return scores;
   } catch {
     return null;
   }
 }
+function computeRecencyBoost(modifiedAt, now, halfLifeDays, weight) {
+  if (halfLifeDays <= 0 || weight <= 0) return 0;
+  const ageDays = (now.getTime() - modifiedAt.getTime()) / (1e3 * 60 * 60 * 24);
+  const decay = Math.exp(-ageDays * Math.LN2 / halfLifeDays);
+  return weight * decay;
+}
+function computeTimeDecay(modifiedAt, now, halfLifeDays) {
+  if (halfLifeDays <= 0) return 1;
+  const ageDays = (now.getTime() - modifiedAt.getTime()) / (1e3 * 60 * 60 * 24);
+  return 0.5 + 0.5 * Math.exp(-ageDays / halfLifeDays);
+}
+function computeLengthNorm(charLen, anchor) {
+  if (anchor <= 0 || charLen <= 0) return 1;
+  return 1 / (1 + Math.log2(Math.max(1, charLen / anchor)));
+}
+function mmrRerank(results, embeddingCache, lambda, topK) {
+  if (lambda >= 1 || results.length <= 1) return results.slice(0, topK);
+  const selected = [];
+  const remaining = new Set(results.map((_, i) => i));
+  selected.push(results[0]);
+  remaining.delete(0);
+  while (selected.length < topK && remaining.size > 0) {
+    let bestIdx = -1;
+    let bestMmrScore = -Infinity;
+    for (const idx of remaining) {
+      const relevance = results[idx].fusedScore;
+      let maxSim = 0;
+      const candidateId = results[idx].file?.replace(/^qmd:\/\/[^/]+\//, "").replace(/\.md$/, "") || "";
+      const candidateEmb = embeddingCache.get(candidateId);
+      if (candidateEmb) {
+        for (const sel of selected) {
+          const selId = sel.file?.replace(/^qmd:\/\/[^/]+\//, "").replace(/\.md$/, "") || "";
+          const selEmb = embeddingCache.get(selId);
+          if (selEmb) {
+            maxSim = Math.max(maxSim, cosineSimilarity(candidateEmb, selEmb));
+          }
+        }
+      }
+      const mmrScore = lambda * relevance - (1 - lambda) * maxSim;
+      if (mmrScore > bestMmrScore) {
+        bestMmrScore = mmrScore;
+        bestIdx = idx;
+      }
+    }
+    if (bestIdx >= 0) {
+      selected.push(results[bestIdx]);
+      remaining.delete(bestIdx);
+    } else {
+      break;
+    }
+  }
+  return selected;
+}
+function loadVaultDocuments(vaultPath) {
+  const documents = [];
+  const dirsToScan = [
+    "tasks",
+    "projects",
+    "decisions",
+    "people",
+    "persons",
+    "notes",
+    "daily",
+    "journal",
+    "ledger",
+    "memory",
+    "memories",
+    "observations",
+    "lessons"
+  ];
+  const scanDir = (dir) => {
+    if (!existsSync4(dir)) return;
+    try {
+      const entries = readdirSync3(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+        const fullPath = join4(dir, entry.name);
+        if (entry.isDirectory()) {
+          const depth = fullPath.replace(vaultPath, "").split("/").length;
+          if (depth <= 3) scanDir(fullPath);
+        } else if (entry.name.endsWith(".md")) {
+          try {
+            const stat = statSync2(fullPath);
+            const content = readFileSync4(fullPath, "utf-8");
+            const parsed = parseYamlFrontmatter(content);
+            const relPath = relative2(vaultPath, fullPath);
+            const docId = relPath.replace(/\.md$/, "");
+            const title = parsed?.frontmatter?.title || parsed?.frontmatter?.summary || entry.name.replace(/\.md$/, "");
+            const body = parsed?.body || content;
+            const scope = parseScope(String(parsed?.frontmatter?.scope || "global"));
+            documents.push({
+              id: docId,
+              file: relPath,
+              title: String(title),
+              content: body.slice(0, 2e3),
+              modifiedAt: stat.mtime,
+              scope
+            });
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  };
+  scanDir(vaultPath);
+  for (const subdir of dirsToScan) {
+    const fullPath = join4(vaultPath, subdir);
+    if (existsSync4(fullPath) && !documents.some((d) => d.file.startsWith(subdir + "/"))) {
+      scanDir(fullPath);
+    }
+  }
+  return documents;
+}
+function qmdSearch(query, collection, limit) {
+  const sanitized = query.replace(/['']/g, " ").replace(/[^\w\s\-.,?!]/g, " ").trim();
+  if (!sanitized) return [];
+  let results = [];
+  for (const cmd of ["query", "search"]) {
+    try {
+      const result = execFileSync("qmd", [
+        cmd,
+        sanitized,
+        "-n",
+        String(Math.max(limit * 2, 20)),
+        "--json",
+        "-c",
+        collection
+      ], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: cmd === "query" ? 3e4 : 15e3
+      });
+      const parsed = JSON.parse(result);
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        results = parsed;
+        break;
+      }
+    } catch (err) {
+      const errObj = err;
+      if (errObj.stdout) {
+        try {
+          const parsed = JSON.parse(errObj.stdout);
+          if (Array.isArray(parsed) && parsed.length > 0) {
+            results = parsed;
+            break;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return results;
+}
+async function retrieve(query, options) {
+  const config = { ...DEFAULT_RETRIEVAL_CONFIG, ...options.config };
+  const { vaultPath, collection = "clawvault" } = options;
+  const scope = options.scope || "global";
+  const now = /* @__PURE__ */ new Date();
+  let fusedResults = [];
+  let usedInProcess = false;
+  try {
+    const documents = loadVaultDocuments(vaultPath);
+    const embeddingCache = loadEmbeddingCache(vaultPath);
+    const scopedDocs = scope === "global" ? documents : documents.filter((d) => matchesScope(d.scope, scope));
+    if (scopedDocs.length > 0) {
+      const bm25Results = bm25Search(query, scopedDocs, config.topK * 3);
+      const bm25Ranked = bm25Results.map((r) => ({ id: r.id, score: r.score }));
+      const semanticRanked = await semanticSearch(query, embeddingCache, config.topK * 3);
+      fusedResults = reciprocalRankFusion(
+        bm25Ranked,
+        semanticRanked,
+        config.rrfK,
+        config.bm25Weight,
+        config.semanticWeight
+      ).map((r) => {
+        const doc = scopedDocs.find((d) => d.id === r.id);
+        return { ...r, doc };
+      });
+      usedInProcess = true;
+    }
+  } catch {
+  }
+  if (!usedInProcess || fusedResults.length === 0) {
+    const qmdResults = qmdSearch(query, collection, config.topK * 2);
+    fusedResults = qmdResults.map((r, i) => ({
+      id: (r.file || "").replace(`qmd://${collection}/`, "").replace(/\.md$/, ""),
+      score: r.score ?? 1 / (i + 1),
+      qmd: r
+    }));
+  }
+  if (fusedResults.length === 0) return [];
+  let scored = fusedResults.map((r) => {
+    const doc = r.doc;
+    const qmd = r.qmd;
+    return {
+      file: doc?.file || qmd?.file || r.id + ".md",
+      title: doc?.title || qmd?.title || r.id,
+      snippet: qmd?.snippet || doc?.content?.slice(0, 300) || "",
+      score: r.score,
+      fusedScore: r.score,
+      scope: doc?.scope || "global"
+    };
+  });
+  if (config.rerankProvider && config.rerankApiKey) {
+    const texts = scored.map((r) => `${r.title || ""} ${r.snippet || ""}`.trim());
+    const rerankScores = await crossEncoderRerank(query, texts, config);
+    if (rerankScores) {
+      scored = scored.map((r, i) => ({
+        ...r,
+        rerankScore: rerankScores[i],
+        fusedScore: config.rerankWeight * rerankScores[i] + (1 - config.rerankWeight) * r.fusedScore
+      }));
+      scored.sort((a, b) => b.fusedScore - a.fusedScore);
+    }
+  }
+  scored = scored.map((r) => {
+    const doc = fusedResults.find((f) => f.id === r.file?.replace(/\.md$/, ""));
+    const modifiedAt = doc?.doc?.modifiedAt;
+    let recencyBoost = 0;
+    let timeDecay = 1;
+    if (modifiedAt) {
+      recencyBoost = computeRecencyBoost(
+        modifiedAt,
+        now,
+        config.recencyHalfLifeDays,
+        config.recencyWeight
+      );
+      timeDecay = computeTimeDecay(modifiedAt, now, config.decayHalfLifeDays);
+    }
+    return {
+      ...r,
+      recencyBoost,
+      timeDecay,
+      fusedScore: (r.fusedScore + recencyBoost) * timeDecay
+    };
+  });
+  if (config.lengthNormAnchor > 0) {
+    scored = scored.map((r) => {
+      const charLen = (r.snippet?.length || 0) + (r.title?.length || 0);
+      const lengthNorm = computeLengthNorm(charLen, config.lengthNormAnchor);
+      return {
+        ...r,
+        lengthNorm,
+        fusedScore: r.fusedScore * lengthNorm
+      };
+    });
+  }
+  scored.sort((a, b) => b.fusedScore - a.fusedScore);
+  if (config.mmrLambda < 1) {
+    const embeddingCache = loadEmbeddingCache(vaultPath);
+    scored = mmrRerank(scored, embeddingCache, config.mmrLambda, config.topK);
+  }
+  return scored.filter((r) => r.fusedScore >= config.minScore).slice(0, config.topK);
+}
 function qmdHybridSearch(query, collection, limit = 10) {
   const sanitized = query.replace(/['']/g, " ").replace(/[^\w\s\-.,?!]/g, " ").trim();
   if (!sanitized) return [];
+  const bm25Results = qmdSearch(sanitized, collection, limit);
   try {
-    const result = execFileSync("qmd", [
-      "query",
-      sanitized,
-      "-n",
-      String(limit),
-      "--json",
-      "-c",
-      collection
-    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024, timeout: 3e4 });
-    const parsed = JSON.parse(result);
-    if (Array.isArray(parsed) && parsed.length > 0) return parsed;
-  } catch (err) {
-    if (err?.stdout) {
-      try {
-        const parsed = JSON.parse(err.stdout);
-        if (Array.isArray(parsed) && parsed.length > 0) return parsed;
-      } catch {
+    const vaultPath = process.env.CLAWVAULT_PATH || join4(
+      process.env.HOME || ".",
+      "clawvault"
+    );
+    const cachePath = join4(vaultPath, ".clawvault", "embeddings.bin.json");
+    if (bm25Results.length > 0 && existsSync4(cachePath)) {
+      const rerankerPath = join4(__dirname, "semantic-rerank.mjs");
+      if (existsSync4(rerankerPath)) {
+        const reranked = execFileSync("node", [
+          rerankerPath,
+          sanitized,
+          cachePath,
+          JSON.stringify(bm25Results)
+        ], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], timeout: 1e4 });
+        const parsed = JSON.parse(reranked);
+        if (Array.isArray(parsed) && parsed.length > 0) {
+          return parsed.slice(0, limit);
+        }
       }
     }
+  } catch {
   }
-  try {
-    const result = execFileSync("qmd", [
-      "search",
-      sanitized,
-      "-n",
-      String(limit),
-      "--json",
-      "-c",
-      collection
-    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024, timeout: 15e3 });
-    return JSON.parse(result);
-  } catch (err) {
-    if (err?.stdout) {
-      try {
-        return JSON.parse(err.stdout);
-      } catch {
+  return bm25Results.slice(0, limit);
+}
+
+// src/plugin/adaptive-retrieval.ts
+var DEFAULT_ADAPTIVE_CONFIG = {
+  enabled: true,
+  skipPatterns: []
+};
+var GREETING_RE = /^(?:hi|hello|hey|howdy|greetings|good (?:morning|afternoon|evening)|what'?s up|sup|yo)\b/i;
+var FAREWELL_RE = /^(?:bye|goodbye|see you|later|gn|good night|cya|take care)\s*[!.?]*$/i;
+var SLASH_COMMAND_RE = /^\/\w+/;
+var CONFIRMATION_RE = /^(?:ok(?:ay)?|sure|yes|no|yep|nope|y|n|got it|understood|perfect|great|cool|nice|awesome|k|kk|ack|confirmed|roger)\s*[!.?]*$/i;
+var EMOJI_ONLY_RE = /^[\p{Emoji}\p{Emoji_Presentation}\p{Emoji_Modifier}\p{Emoji_Component}\s]+$/u;
+var SYSTEM_RE = /^(?:\[System|\[HEARTBEAT|NO_REPLY|<relevant-memories|<session-recap)/;
+var MIN_MEANINGFUL_LENGTH = 8;
+function shouldRetrieve(input, config = DEFAULT_ADAPTIVE_CONFIG) {
+  if (!config.enabled) return { shouldRetrieve: true };
+  if (!input) return { shouldRetrieve: false, skipReason: "too_short" };
+  const trimmed = input.trim();
+  if (SYSTEM_RE.test(trimmed)) {
+    return { shouldRetrieve: false, skipReason: "system_message" };
+  }
+  if (SLASH_COMMAND_RE.test(trimmed)) {
+    return { shouldRetrieve: false, skipReason: "slash_command" };
+  }
+  if (EMOJI_ONLY_RE.test(trimmed)) {
+    return { shouldRetrieve: false, skipReason: "emoji_only" };
+  }
+  if (trimmed.length < MIN_MEANINGFUL_LENGTH) {
+    return { shouldRetrieve: false, skipReason: "too_short" };
+  }
+  if (GREETING_RE.test(trimmed) && trimmed.length < 30) {
+    return { shouldRetrieve: false, skipReason: "greeting" };
+  }
+  if (FAREWELL_RE.test(trimmed)) {
+    return { shouldRetrieve: false, skipReason: "farewell" };
+  }
+  if (CONFIRMATION_RE.test(trimmed)) {
+    return { shouldRetrieve: false, skipReason: "confirmation" };
+  }
+  for (const pattern of config.skipPatterns) {
+    try {
+      const re = new RegExp(pattern, "i");
+      if (re.test(trimmed)) {
+        return { shouldRetrieve: false, skipReason: "user_pattern" };
       }
+    } catch {
     }
-    return [];
   }
+  return { shouldRetrieve: true };
+}
+
+// src/plugin/index.ts
+var PLUGIN_VERSION = "4.0.0";
+function resolveVaultPath(cfg) {
+  if (cfg?.vaultPath) return cfg.vaultPath;
+  if (process.env.CLAWVAULT_PATH) return process.env.CLAWVAULT_PATH;
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
+  for (const candidate of [`${home}/clawvault`, `${home}/.clawvault`]) {
+    if (existsSync5(join5(candidate, ".clawvault.json"))) return candidate;
+  }
+  return `${home}/.clawvault`;
 }
-function observe(vaultPath, content, meta = {}) {
+async function autoEmbedViaOllama(filePath, content) {
   try {
-    const args = ["observe", "--content", content];
-    if (meta.tags?.length) args.push("--tags", meta.tags.join(","));
-    execFile("clawvault", args, { cwd: vaultPath, timeout: 15e3 }, () => {
+    const { dirname, join: pathJoin, relative: pathRelative } = await import("path");
+    const { existsSync: fsExists, readFileSync: fsRead, writeFileSync: fsWrite, mkdirSync: fsMkdir } = await import("fs");
+    let vaultPath = dirname(filePath);
+    for (let i = 0; i < 10; i++) {
+      if (fsExists(pathJoin(vaultPath, ".clawvault.json"))) break;
+      const parent = dirname(vaultPath);
+      if (parent === vaultPath) return;
+      vaultPath = parent;
+    }
+    const cachePath = pathJoin(vaultPath, ".clawvault", "embeddings.bin.json");
+    const docId = pathRelative(vaultPath, filePath).replace(/\.md$/, "");
+    const resp = await fetch("http://localhost:11434/api/embeddings", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "nomic-embed-text", prompt: content.slice(0, 2e3) }),
+      signal: AbortSignal.timeout(5e3)
     });
+    if (!resp.ok) return;
+    const data = await resp.json();
+    let cache = {};
+    try {
+      cache = JSON.parse(fsRead(cachePath, "utf-8"));
+    } catch {
+    }
+    cache[docId] = data.embedding;
+    const dir = dirname(cachePath);
+    if (!fsExists(dir)) fsMkdir(dir, { recursive: true });
+    fsWrite(cachePath, JSON.stringify(cache));
   } catch {
   }
 }
@@ -117,44 +3617,151 @@ function qmdUpdateAsync(collection) {
   } catch {
   }
 }
-var templateRegistry = null;
-function getTemplateRegistry() {
-  return templateRegistry;
+function observeViaCli(vaultPath, content, meta = {}) {
+  try {
+    const args = ["observe", "--content", content];
+    if (meta.tags?.length) args.push("--tags", meta.tags.join(","));
+    execFile("clawvault", args, { cwd: vaultPath, timeout: 15e3 }, () => {
+    });
+  } catch {
+  }
+}
+function computeMemoryStats(vaultPath, collection) {
+  const stats = {
+    vault: vaultPath,
+    version: PLUGIN_VERSION,
+    documents: 0,
+    vectors: 0,
+    categories: {},
+    oldestDoc: null,
+    newestDoc: null,
+    totalSizeKb: 0
+  };
+  const files = scanVaultFiles(vaultPath, { maxAge: Infinity, limit: 1e4 });
+  stats.documents = files.length;
+  for (const file of files) {
+    const cat = file.primitiveType;
+    stats.categories[cat] = (stats.categories[cat] || 0) + 1;
+  }
+  if (files.length > 0) {
+    const sorted = [...files].sort((a, b) => a.modifiedAt.getTime() - b.modifiedAt.getTime());
+    stats.oldestDoc = sorted[0].modifiedAt.toISOString();
+    stats.newestDoc = sorted[sorted.length - 1].modifiedAt.toISOString();
+  }
+  const cachePath = join5(vaultPath, ".clawvault", "embeddings.bin.json");
+  if (existsSync5(cachePath)) {
+    try {
+      const cacheData = JSON.parse(readFileSync5(cachePath, "utf-8"));
+      stats.vectors = Object.keys(cacheData).length;
+      const cacheStats = statSync3(cachePath);
+      stats.totalSizeKb = Math.round(cacheStats.size / 1024);
+    } catch {
+    }
+  }
+  try {
+    const qmdStats = execFileSync2("qmd", ["status", "--json", "-c", collection], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const parsed = JSON.parse(qmdStats);
+    if (typeof parsed.documents === "number") stats.documents = Math.max(stats.documents, parsed.documents);
+    if (typeof parsed.vectors === "number") stats.vectors = Math.max(stats.vectors, parsed.vectors);
+  } catch {
+  }
+  return stats;
+}
+function exportMemories(vaultPath, outputPath) {
+  const files = scanVaultFiles(vaultPath, { maxAge: Infinity, limit: 1e5 });
+  const memories = files.map((f) => ({
+    path: f.relativePath,
+    primitiveType: f.primitiveType,
+    frontmatter: f.frontmatter,
+    content: f.content,
+    modifiedAt: f.modifiedAt.toISOString(),
+    createdAt: f.createdAt.toISOString()
+  }));
+  writeFileSync2(outputPath, JSON.stringify(memories, null, 2), "utf-8");
+  return { count: memories.length, path: outputPath };
+}
+function importMemories(vaultPath, inputPath) {
+  const errors = [];
+  let imported = 0;
+  let skipped = 0;
+  try {
+    const data = JSON.parse(readFileSync5(inputPath, "utf-8"));
+    for (const entry of data) {
+      const title = String(entry.frontmatter?.title || entry.frontmatter?.summary || "");
+      const result = writeVaultFile(vaultPath, {
+        primitiveType: entry.primitiveType || "memory_event",
+        title: title.slice(0, 80) || void 0,
+        content: entry.content,
+        extraFields: entry.frontmatter
+      });
+      if (result.success) imported++;
+      else {
+        skipped++;
+        if (result.errors.length > 0) errors.push(...result.errors);
+      }
+    }
+  } catch (err) {
+    errors.push(`Import failed: ${String(err)}`);
+  }
+  return { imported, skipped, errors };
 }
+var templateRegistry = null;
 var clawvaultPlugin = {
   id: "clawvault",
   name: "ClawVault Memory",
-  description: "Template-driven observational memory with hybrid search. Memories are captured automatically from conversations and classified against template schemas.",
-  version: "3.1.0",
+  description: "Template-driven observational memory with hybrid search, cross-encoder reranking, and adaptive retrieval. Memories are captured automatically from conversations and classified against template schemas.",
+  version: PLUGIN_VERSION,
   kind: "memory",
   register(api) {
-    const vaultPath = resolveVaultPath(api.pluginConfig);
-    const collection = api.pluginConfig?.collection || "clawvault";
-    const autoRecall = api.pluginConfig?.autoRecall !== false;
-    const autoCapture = api.pluginConfig?.autoCapture !== false;
-    const recallLimit = api.pluginConfig?.recallLimit || 5;
-    const templatesDir = api.pluginConfig?.templatesDir ?? join(vaultPath, "..", "..", "templates");
+    const cfg = api.pluginConfig || {};
+    const vaultPath = resolveVaultPath(cfg);
+    const collection = cfg.collection || "clawvault";
+    const autoRecall = cfg.autoRecall !== false;
+    const autoCapture = cfg.autoCapture !== false;
+    const recallLimit = cfg.recallLimit || 5;
+    const templatesDir = cfg.templatesDir ?? join5(vaultPath, "..", "..", "templates");
+    const defaultScope = parseScope(cfg.defaultScope || "global");
+    const retrievalConfig = {
+      ...DEFAULT_RETRIEVAL_CONFIG,
+      ...cfg.retrieval
+    };
+    const noiseConfig = {
+      ...DEFAULT_NOISE_CONFIG,
+      ...cfg.noise
+    };
+    const adaptiveConfig = {
+      ...DEFAULT_ADAPTIVE_CONFIG,
+      ...cfg.adaptive
+    };
     templateRegistry = initializeTemplateRegistry(templatesDir);
     api.logger.info(`[clawvault] Template registry initialized with ${templateRegistry.schemas.size} schemas`);
-    if (!existsSync(join(vaultPath, ".clawvault.json"))) {
+    setAutoEmbedFn(autoEmbedViaOllama);
+    if (!existsSync5(join5(vaultPath, ".clawvault.json"))) {
       api.logger.warn(`[clawvault] Vault not found at ${vaultPath}`);
       return;
     }
     ensureVaultStructure(vaultPath);
-    api.logger.info(`[clawvault] v2.2.0 vault=${vaultPath} collection=${collection} recall=${autoRecall} capture=${autoCapture}`);
+    api.logger.info(
+      `[clawvault] v${PLUGIN_VERSION} vault=${vaultPath} collection=${collection} recall=${autoRecall} capture=${autoCapture} scope=${defaultScope}`
+    );
     api.registerTool({
       name: "memory_search",
       label: "Memory Search",
-      description: "Search through long-term memories using ClawVault. Supports preferences, temporal queries, and multi-session knowledge retrieval.",
-      parameters: Type.Object({
-        query: Type.String({ description: "Search query \u2014 natural language question or keyword search" }),
-        limit: Type.Optional(Type.Number({ description: "Max results (default: 10)" })),
-        queryType: Type.Optional(Type.Union([
-          Type.Literal("preference"),
-          Type.Literal("temporal"),
-          Type.Literal("knowledge"),
-          Type.Literal("general")
-        ], { description: "Force query type (auto-detected if omitted)" }))
+      description: "Search through long-term memories using ClawVault. Uses in-process hybrid retrieval with BM25 + semantic search, RRF fusion, optional reranking, and MMR diversity.",
+      parameters: import_typebox.Type.Object({
+        query: import_typebox.Type.String({ description: "Search query \u2014 natural language question or keyword search" }),
+        limit: import_typebox.Type.Optional(import_typebox.Type.Number({ description: "Max results (default: 10)" })),
+        queryType: import_typebox.Type.Optional(import_typebox.Type.Union([
+          import_typebox.Type.Literal("preference"),
+          import_typebox.Type.Literal("temporal"),
+          import_typebox.Type.Literal("knowledge"),
+          import_typebox.Type.Literal("general")
+        ], { description: "Force query type (auto-detected if omitted)" })),
+        scope: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Memory scope filter (global, agent:<id>, project:<name>, user:<id>)" }))
       }),
       async execute(_id, params) {
         try {
@@ -162,63 +3769,73 @@ var clawvaultPlugin = {
           if (params.queryType === "preference") searchQuery = `preference: ${searchQuery}`;
           else if (params.queryType === "temporal") searchQuery = `when: ${searchQuery}`;
           const limit = params.limit || 10;
-          const results = qmdHybridSearch(searchQuery, collection, limit);
+          const scope = parseScope(params.scope || defaultScope);
+          const results = await retrieve(searchQuery, {
+            vaultPath,
+            collection,
+            config: { ...retrievalConfig, topK: limit },
+            scope
+          });
           if (results.length === 0) {
             return {
               content: [{ type: "text", text: "No relevant memories found." }],
               details: { count: 0, provider: "clawvault" }
             };
           }
+          const formatted = results.map((r, i) => {
+            const file = (r.file || "").replace(`qmd://${collection}/`, "");
+            const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "(no content)";
+            const score = (r.fusedScore * 100).toFixed(0);
+            return `${i + 1}. [${file}] ${snippet} (${score}%)`;
+          }).join("\n");
           return {
-            content: [{ type: "text", text: formatSearchResults(results, collection) }],
-            details: { count: results.length, provider: "clawvault" }
+            content: [{ type: "text", text: formatted }],
+            details: { count: results.length, provider: "clawvault", pipeline: "hybrid-v2" }
           };
         } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory search error: ${String(err)}` }],
-            isError: true
-          };
+          try {
+            const results = qmdHybridSearch(params.query, collection, params.limit || 10);
+            return {
+              content: [{ type: "text", text: formatSearchResults(results, collection) }],
+              details: { count: results.length, provider: "clawvault", pipeline: "qmd-fallback" }
+            };
+          } catch {
+            return {
+              content: [{ type: "text", text: `Memory search error: ${String(err)}` }],
+              isError: true
+            };
+          }
         }
       }
     });
     api.registerTool({
       name: "memory_get",
       label: "Memory Get",
-      description: "Get vault status or stored preferences.",
-      parameters: Type.Object({
-        action: Type.Union([
-          Type.Literal("status"),
-          Type.Literal("preferences")
+      description: "Get vault status, stored preferences, or memory stats.",
+      parameters: import_typebox.Type.Object({
+        action: import_typebox.Type.Union([
+          import_typebox.Type.Literal("status"),
+          import_typebox.Type.Literal("preferences"),
+          import_typebox.Type.Literal("stats")
         ], { description: "What to retrieve" })
       }),
       async execute(_id, params) {
         try {
-          if (params.action === "status") {
-            const config = getVaultConfig(vaultPath);
-            let docCount = 0;
-            let vectorCount = 0;
-            try {
-              const stats = execFileSync("qmd", ["status", "--json", "-c", collection], {
-                encoding: "utf-8",
-                timeout: 5e3,
-                stdio: ["ignore", "pipe", "pipe"]
-              });
-              const parsed = JSON.parse(stats);
-              docCount = parsed.documents ?? parsed.doc_count ?? 0;
-              vectorCount = parsed.vectors ?? parsed.vector_count ?? 0;
-            } catch {
-            }
+          if (params.action === "status" || params.action === "stats") {
+            const stats = computeMemoryStats(vaultPath, collection);
             return {
               content: [{ type: "text", text: JSON.stringify({
-                vault: vaultPath,
-                name: config?.name || "clawvault",
-                collection,
-                documents: docCount,
-                vectors: vectorCount,
+                ...stats,
                 autoRecall,
                 autoCapture,
-                version: "3.1.0",
-                templateSchemas: templateRegistry?.schemas.size ?? 0
+                templateSchemas: templateRegistry?.schemas.size ?? 0,
+                scope: defaultScope,
+                retrieval: {
+                  rerankProvider: retrievalConfig.rerankProvider || "none",
+                  mmrLambda: retrievalConfig.mmrLambda,
+                  recencyHalfLife: retrievalConfig.recencyHalfLifeDays,
+                  decayHalfLife: retrievalConfig.decayHalfLifeDays
+                }
               }, null, 2) }]
             };
           }
@@ -251,49 +3868,73 @@ var clawvaultPlugin = {
       name: "memory_store",
       label: "Memory Store",
       description: "Save important information in long-term memory. Use for preferences, facts, decisions, or anything worth remembering.",
-      parameters: Type.Object({
-        text: Type.String({ description: "Information to remember" }),
-        category: Type.Optional(Type.Union([
-          Type.Literal("preference"),
-          Type.Literal("fact"),
-          Type.Literal("decision"),
-          Type.Literal("entity"),
-          Type.Literal("event"),
-          Type.Literal("other")
+      parameters: import_typebox.Type.Object({
+        text: import_typebox.Type.String({ description: "Information to remember" }),
+        category: import_typebox.Type.Optional(import_typebox.Type.Union([
+          import_typebox.Type.Literal("preference"),
+          import_typebox.Type.Literal("fact"),
+          import_typebox.Type.Literal("decision"),
+          import_typebox.Type.Literal("entity"),
+          import_typebox.Type.Literal("event"),
+          import_typebox.Type.Literal("other")
         ], { description: "Memory category (auto-detected if omitted)" })),
-        tags: Type.Optional(Type.Array(Type.String(), { description: "Tags for organization" }))
+        tags: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.String(), { description: "Tags for organization" })),
+        scope: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Memory scope (global, agent:<id>, project:<name>, user:<id>)" }))
       }),
       async execute(_id, params) {
         try {
-          const classification = classifyText(params.text);
-          const category = params.category || detectCategory(params.text);
+          const text = params.text;
+          if (noiseConfig.enabled) {
+            const check = isNoise(text, noiseConfig);
+            if (check.isNoise) {
+              return {
+                content: [{ type: "text", text: `Skipped: content filtered (${check.reason})` }],
+                details: { action: "filtered", reason: check.reason }
+              };
+            }
+          }
+          const classification = classifyText(text);
+          const category = params.category || detectCategory(text);
           const tags = params.tags || [category, ...classification.matchedKeywords.slice(0, 3)];
+          const scope = parseScope(params.scope || defaultScope);
+          const CATEGORY_TO_PRIMITIVE = {
+            preference: "memory_event",
+            fact: "memory_event",
+            decision: "decision",
+            entity: "person",
+            event: "memory_event",
+            other: "memory_event"
+          };
+          const effectivePrimitive = params.category ? CATEGORY_TO_PRIMITIVE[params.category] ?? "memory_event" : classification.primitiveType;
+          const extraFields = {
+            type: category,
+            confidence: classification.confidence,
+            tags
+          };
+          if (scope !== "global") extraFields.scope = scope;
           const result = writeVaultFile(vaultPath, {
-            primitiveType: classification.primitiveType,
-            title: params.text.slice(0, 80),
-            content: params.text,
-            extraFields: {
-              type: category,
-              confidence: classification.confidence,
-              tags
-            },
+            primitiveType: effectivePrimitive,
+            title: text.slice(0, 80),
+            content: text,
+            extraFields,
             source: "openclaw"
           });
           appendToLedger(vaultPath, {
             timestamp: /* @__PURE__ */ new Date(),
             category,
-            content: params.text,
+            content: text,
             primitiveType: classification.primitiveType,
             tags
           });
           qmdUpdateAsync(collection);
           return {
-            content: [{ type: "text", text: `Stored: "${params.text.slice(0, 100)}${params.text.length > 100 ? "..." : ""}" [${classification.primitiveType}/${category}]` }],
+            content: [{ type: "text", text: `Stored: "${text.slice(0, 100)}${text.length > 100 ? "..." : ""}" [${classification.primitiveType}/${category}]${scope !== "global" ? ` scope=${scope}` : ""}` }],
             details: {
               action: result.created ? "created" : "updated",
               category,
               primitiveType: classification.primitiveType,
-              path: result.path
+              path: result.path,
+              scope
             }
           };
         } catch (err) {
@@ -308,9 +3949,9 @@ var clawvaultPlugin = {
       name: "memory_forget",
       label: "Memory Forget",
       description: "Delete specific memories from the vault.",
-      parameters: Type.Object({
-        query: Type.String({ description: "Search query to find the memory to delete" }),
-        confirm: Type.Optional(Type.Boolean({ description: "Set true to confirm deletion of first match" }))
+      parameters: import_typebox.Type.Object({
+        query: import_typebox.Type.String({ description: "Search query to find the memory to delete" }),
+        confirm: import_typebox.Type.Optional(import_typebox.Type.Boolean({ description: "Set true to confirm deletion of first match" }))
       }),
       async execute(_id, params) {
         try {
@@ -337,12 +3978,11 @@ Call again with confirm=true to delete the top match.` }],
           }
           const target = results[0];
           const file = (target.file || "").replace(`qmd://${collection}/`, "");
-          const fullPath = join(vaultPath, file);
-          if (existsSync(fullPath)) {
-            const trashDir = join(vaultPath, ".trash");
-            if (!existsSync(trashDir)) mkdirSync(trashDir, { recursive: true });
-            const trashPath = join(trashDir, `${Date.now()}-${basename(file)}`);
-            const { renameSync } = __require("fs");
+          const fullPath = join5(vaultPath, file);
+          if (existsSync5(fullPath)) {
+            const trashDir = join5(vaultPath, ".trash");
+            if (!existsSync5(trashDir)) mkdirSync2(trashDir, { recursive: true });
+            const trashPath = join5(trashDir, `${Date.now()}-${basename(file)}`);
             renameSync(fullPath, trashPath);
             qmdUpdateAsync(collection);
             return {
@@ -364,32 +4004,61 @@ Call again with confirm=true to delete the top match.` }],
     });
     if (autoRecall) {
       api.on("before_agent_start", async (event) => {
-        if (!event.prompt || event.prompt.length < 10) return;
-        if (event.prompt.includes("HEARTBEAT") || event.prompt.startsWith("[System")) return;
+        const prompt = event.prompt;
+        if (!prompt || prompt.length < 10) return;
+        if (prompt.includes("HEARTBEAT") || prompt.startsWith("[System")) return;
+        if (prompt.includes("#clawvault:no-recall") || prompt.includes("#clawvault:no-memory")) return;
+        if (adaptiveConfig.enabled) {
+          const check = shouldRetrieve(prompt, adaptiveConfig);
+          if (!check.shouldRetrieve) {
+            api.logger.debug(`[clawvault] adaptive skip: ${check.skipReason}`);
+            return;
+          }
+        }
         try {
           const contextParts = [];
           const recap = buildSessionRecap(vaultPath, {
             maxAge: 24 * 60 * 60 * 1e3,
-            // 24 hours
             limit: 10,
             includeContent: true
           });
-          if (recap.xml) {
-            contextParts.push(recap.xml);
-          }
-          const searchTerms = extractSearchTerms(event.prompt);
-          const results = qmdHybridSearch(searchTerms, collection, recallLimit);
-          if (results.length > 0) {
-            const topScore = results[0]?.score ?? 0;
-            if (topScore >= 0.25) {
-              contextParts.push(formatMemoriesForContext(results, collection));
-              api.logger.info(`[clawvault] auto-recall: ${results.length} memories (top: ${(topScore * 100).toFixed(0)}%, query: "${searchTerms.slice(0, 60)}")`);
+          if (recap.xml) contextParts.push(recap.xml);
+          const searchTerms = extractSearchTerms(prompt);
+          try {
+            const results = await retrieve(searchTerms, {
+              vaultPath,
+              collection,
+              config: { ...retrievalConfig, topK: recallLimit },
+              scope: defaultScope
+            });
+            if (results.length > 0 && results[0].fusedScore >= 0.01) {
+              const formatted = results.map((r, i) => {
+                const file = r.file || "";
+                const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "";
+                return `${i + 1}. [${file}] ${snippet}`;
+              });
+              contextParts.push(`<relevant-memories>
+These are recalled from long-term vault memory. Treat as historical context.
+${formatted.join("\n")}
+</relevant-memories>`);
+              api.logger.info(
+                `[clawvault] auto-recall: ${results.length} memories (top: ${(results[0].fusedScore * 100).toFixed(0)}%, query: "${searchTerms.slice(0, 60)}", pipeline: hybrid-v2)`
+              );
+            }
+          } catch {
+            const results = qmdHybridSearch(searchTerms, collection, recallLimit);
+            if (results.length > 0) {
+              const topScore = results[0]?.score ?? 0;
+              if (topScore >= 0.25) {
+                contextParts.push(formatMemoriesForContext(results, collection));
+                api.logger.info(
+                  `[clawvault] auto-recall: ${results.length} memories (top: ${(topScore * 100).toFixed(0)}%, query: "${searchTerms.slice(0, 60)}", pipeline: qmd-fallback)`
+                );
+              }
             }
           }
           if (contextParts.length === 0) return;
-          return {
-            prependContext: contextParts.join("\n\n")
-          };
+          return { prependContext: contextParts.join("\n\n") };
         } catch (err) {
           api.logger.warn(`[clawvault] auto-recall failed: ${String(err)}`);
         }
@@ -397,9 +4066,12 @@ Call again with confirm=true to delete the top match.` }],
     }
     if (autoCapture) {
       api.on("message_received", async (event) => {
-        if (!event.content || !isObservable(event.content)) return;
+        const content = event.content;
+        if (!content || !isObservable(content, noiseConfig)) return;
+        if (content.includes("#clawvault:no-capture") || content.includes("#clawvault:no-memory")) return;
+        if (noiseConfig.enabled && isNoise(content, noiseConfig).isNoise) return;
         try {
-          const result = processMessageForObservations(event.content, {
+          const result = processMessageForObservations(content, {
             from: event.from,
             sessionId: event.sessionId
           });
@@ -410,7 +4082,6 @@ Call again with confirm=true to delete the top match.` }],
             actor: event.from || "user",
             writeLedger: true,
             writeFiles: false
-            // Only write to ledger for speed
           });
           api.logger.info(`[clawvault] auto-captured ${writeResult.successful} observations from incoming message`);
         } catch (err) {
@@ -418,17 +4089,18 @@ Call again with confirm=true to delete the top match.` }],
         }
       });
       api.on("agent_end", async (event) => {
-        if (!event.success || !event.messages?.length) return;
+        if (!event.success || !event.messages) return;
+        const messages = event.messages;
         try {
           let captured = 0;
-          for (const msg of event.messages) {
+          for (const msg of messages) {
             if (!msg || typeof msg !== "object") continue;
             if (msg.role === "user") {
-              const content = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.filter((b) => b?.type === "text").map((b) => b.text).join(" ") : "";
-              if (isObservable(content)) {
+              const content = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.filter((b) => b?.type === "text").map((b) => b.text || "").join(" ") : "";
+              if (isObservable(content, noiseConfig) && !isNoise(content, noiseConfig).isNoise) {
                 const result = processMessageForObservations(content);
                 for (const obs of result.observations) {
-                  observe(vaultPath, obs.text, { tags: obs.tags });
+                  observeViaCli(vaultPath, obs.text, { tags: obs.tags });
                   captured++;
                 }
               }
@@ -445,7 +4117,7 @@ Call again with confirm=true to delete the top match.` }],
     }
     api.on("before_compaction", async () => {
       try {
-        execFileSync("qmd", ["update", "-c", collection], {
+        execFileSync2("qmd", ["update", "-c", collection], {
           timeout: 15e3,
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "pipe"]
@@ -466,19 +4138,14 @@ Call again with confirm=true to delete the top match.` }],
       }
     });
     api.registerCli(
-      ({ program }) => {
-        const cmd = program.command("vault").description("ClawVault memory commands");
+      (ctx) => {
+        const cmd = ctx.program.command("vault").description("ClawVault memory commands");
         cmd.command("status").action(() => {
-          const config = getVaultConfig(vaultPath);
-          console.log(JSON.stringify({
-            vault: vaultPath,
-            version: "3.1.0",
-            templateSchemas: templateRegistry?.schemas.size ?? 0,
-            ...config
-          }, null, 2));
+          const stats = computeMemoryStats(vaultPath, collection);
+          console.log(JSON.stringify(stats, null, 2));
         });
         cmd.command("search <query>").option("-n, --limit <n>", "Max results", "10").action((query, opts) => {
-          const results = qmdHybridSearch(query, collection, parseInt(opts.limit));
+          const results = qmdHybridSearch(query, collection, parseInt(opts.limit || "10"));
           console.log(formatSearchResults(results, collection));
         });
         cmd.command("templates").action(() => {
@@ -493,6 +4160,35 @@ Call again with confirm=true to delete the top match.` }],
           const result = classifyText(text);
           console.log(JSON.stringify(result, null, 2));
         });
+        cmd.command("stats").action(() => {
+          const stats = computeMemoryStats(vaultPath, collection);
+          console.log(JSON.stringify(stats, null, 2));
+        });
+        cmd.command("export <outputPath>").action((outputPath) => {
+          const result = exportMemories(vaultPath, outputPath);
+          console.log(`Exported ${result.count} memories to ${result.path}`);
+        });
+        cmd.command("import <inputPath>").action((inputPath) => {
+          const result = importMemories(vaultPath, inputPath);
+          console.log(`Imported: ${result.imported}, Skipped: ${result.skipped}`);
+          if (result.errors.length > 0) {
+            console.log(`Errors: ${result.errors.join(", ")}`);
+          }
+        });
+        cmd.command("reembed").action(() => {
+          console.log("Re-embedding all vault documents...");
+          const files = scanVaultFiles(vaultPath, { maxAge: Infinity, limit: 1e5 });
+          let count = 0;
+          for (const file of files) {
+            const content = `${file.frontmatter.title || ""} ${file.content}`.trim();
+            autoEmbedViaOllama(file.path, content).then(() => {
+              count++;
+              if (count % 100 === 0) console.log(`  Embedded ${count}/${files.length}...`);
+            }).catch(() => {
+            });
+          }
+          console.log(`Queued ${files.length} documents for re-embedding.`);
+        });
       },
       { commands: ["vault"] }
     );
@@ -504,25 +4200,15 @@ Call again with confirm=true to delete the top match.` }],
       handler: (ctx) => {
         const args = (ctx.args || "").trim();
         if (!args || args === "status") {
-          const config = getVaultConfig(vaultPath);
-          let docCount = 0, vectorCount = 0;
-          try {
-            const stats = execFileSync("qmd", ["status", "--json", "-c", collection], {
-              encoding: "utf-8",
-              timeout: 5e3,
-              stdio: ["ignore", "pipe", "pipe"]
-            });
-            const p = JSON.parse(stats);
-            docCount = p.documents ?? p.doc_count ?? 0;
-            vectorCount = p.vectors ?? p.vector_count ?? 0;
-          } catch {
-          }
+          const stats = computeMemoryStats(vaultPath, collection);
           return {
-            text: `\u{1F9E0} ClawVault v2.2.0
+            text: `\u{1F9E0} ClawVault v${PLUGIN_VERSION}
 Vault: ${vaultPath}
-Docs: ${docCount} | Vectors: ${vectorCount}
+Docs: ${stats.documents} | Vectors: ${stats.vectors}
 Recall: ${autoRecall ? "\u2705" : "\u274C"} | Capture: ${autoCapture ? "\u2705" : "\u274C"}
-Templates: ${templateRegistry?.schemas.size ?? 0} schemas`
+Templates: ${templateRegistry?.schemas.size ?? 0} schemas
+Scope: ${defaultScope}
+Pipeline: hybrid-v2 (BM25+Semantic+RRF${retrievalConfig.rerankProvider ? `+${retrievalConfig.rerankProvider}` : ""})`
           };
         }
         if (args.startsWith("search ")) {
@@ -538,10 +4224,16 @@ Templates: ${templateRegistry?.schemas.size ?? 0} schemas`
           const recap = buildSessionRecap(vaultPath, { limit: 10, includeContent: true });
           return { text: recap.xml || "No recent activity found." };
         }
-        return { text: "Usage: /vault [status|search <query>|templates|recap]" };
+        if (args === "stats") {
+          const stats = computeMemoryStats(vaultPath, collection);
+          return { text: JSON.stringify(stats, null, 2) };
+        }
+        return { text: "Usage: /vault [status|search <query>|templates|recap|stats]" };
       }
     });
-    console.log(`[clawvault] v2.2.0 registered \u2014 vault=${vaultPath} templates=${templateRegistry?.schemas.size ?? 0}`);
+    console.log(
+      `[clawvault] v${PLUGIN_VERSION} registered \u2014 vault=${vaultPath} templates=${templateRegistry?.schemas.size ?? 0} pipeline=hybrid-v2 scope=${defaultScope}`
+    );
   }
 };
 var plugin_default = clawvaultPlugin;