@signetai/signet-memory-openclaw 0.157.4 → 0.158.0

package/dist/index.js

@@ -600,6 +600,8 @@ var require_Alias = __commonJS((exports) => {
       });
     }
     resolve(doc, ctx) {
+      if (ctx?.maxAliasCount === 0)
+        throw new ReferenceError("Alias resolution is disabled");
       let nodes;
       if (ctx?.aliasResolveCache) {
         nodes = ctx.aliasResolveCache;
@@ -1629,18 +1631,18 @@ var require_merge = __commonJS((exports) => {
   };
   var isMergeKey = (ctx, key) => (merge.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default);
   function addMergeToJSMap(ctx, map, value) {
-    value = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
-    if (identity.isSeq(value))
-      for (const it of value.items)
+    const source = resolveAliasValue(ctx, value);
+    if (identity.isSeq(source))
+      for (const it of source.items)
         mergeValue(ctx, map, it);
-    else if (Array.isArray(value))
-      for (const it of value)
+    else if (Array.isArray(source))
+      for (const it of source)
         mergeValue(ctx, map, it);
     else
-      mergeValue(ctx, map, value);
+      mergeValue(ctx, map, source);
   }
   function mergeValue(ctx, map, value) {
-    const source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
+    const source = resolveAliasValue(ctx, value);
     if (!identity.isMap(source))
       throw new Error("Merge sources must be maps or map aliases");
     const srcMap = source.toJSON(null, ctx, Map);
@@ -1661,6 +1663,9 @@ var require_merge = __commonJS((exports) => {
     }
     return map;
   }
+  function resolveAliasValue(ctx, value) {
+    return ctx && identity.isAlias(value) ? value.resolve(ctx.doc, ctx) : value;
+  }
   exports.addMergeToJSMap = addMergeToJSMap;
   exports.isMergeKey = isMergeKey;
   exports.merge = merge;
@@ -2214,7 +2219,7 @@ var require_stringifyNumber = __commonJS((exports) => {
     if (!isFinite(num))
       return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
     let n = Object.is(value, -0) ? "-0" : JSON.stringify(value);
-    if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) {
+    if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^-?\d/.test(n) && !n.includes("e")) {
       let i = n.indexOf(".");
       if (i < 0) {
         i = n.length;
@@ -4382,7 +4387,7 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
           while (next === " " || next === "\t")
             next = source[++i + 1];
         } else if (next === "x" || next === "u" || next === "U") {
-          const length = { x: 2, u: 4, U: 8 }[next];
+          const length = next === "x" ? 2 : next === "u" ? 4 : 8;
           res += parseCharCode(source, i + 1, length, onError);
           i += length;
         } else {
@@ -4451,12 +4456,13 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
     const cc = source.substr(offset, length);
     const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
     const code = ok ? parseInt(cc, 16) : NaN;
-    if (isNaN(code)) {
+    try {
+      return String.fromCodePoint(code);
+    } catch {
       const raw = source.substr(offset - 2, length + 2);
       onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
       return raw;
     }
-    return String.fromCodePoint(code);
   }
   exports.resolveFlowScalar = resolveFlowScalar;
 });
@@ -4785,8 +4791,10 @@ ${cb}` : comment;
         }
       }
       if (afterDoc) {
-        Array.prototype.push.apply(doc.errors, this.errors);
-        Array.prototype.push.apply(doc.warnings, this.warnings);
+        for (let i = 0;i < this.errors.length; ++i)
+          doc.errors.push(this.errors[i]);
+        for (let i = 0;i < this.warnings.length; ++i)
+          doc.warnings.push(this.warnings[i]);
       } else {
         doc.errors = this.errors;
         doc.warnings = this.warnings;
@@ -5488,7 +5496,7 @@ var require_lexer = __commonJS((exports) => {
         const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
         this.indentNext = this.indentValue + 1;
         this.indentValue += n;
-        return yield* this.parseBlockStart();
+        return "block-start";
       }
       return "doc";
     }
@@ -5795,26 +5803,37 @@ var require_lexer = __commonJS((exports) => {
       return 0;
     }
     *pushIndicators() {
-      switch (this.charAt(0)) {
-        case "!":
-          return (yield* this.pushTag()) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
-        case "&":
-          return (yield* this.pushUntil(isNotAnchorChar)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
-        case "-":
-        case "?":
-        case ":": {
-          const inFlow = this.flowLevel > 0;
-          const ch1 = this.charAt(1);
-          if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
-            if (!inFlow)
-              this.indentNext = this.indentValue + 1;
-            else if (this.flowKey)
-              this.flowKey = false;
-            return (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+      let n = 0;
+      loop:
+        while (true) {
+          switch (this.charAt(0)) {
+            case "!":
+              n += yield* this.pushTag();
+              n += yield* this.pushSpaces(true);
+              continue loop;
+            case "&":
+              n += yield* this.pushUntil(isNotAnchorChar);
+              n += yield* this.pushSpaces(true);
+              continue loop;
+            case "-":
+            case "?":
+            case ":": {
+              const inFlow = this.flowLevel > 0;
+              const ch1 = this.charAt(1);
+              if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
+                if (!inFlow)
+                  this.indentNext = this.indentValue + 1;
+                else if (this.flowKey)
+                  this.flowKey = false;
+                n += yield* this.pushCount(1);
+                n += yield* this.pushSpaces(true);
+                continue loop;
+              }
+            }
           }
+          break loop;
         }
-      }
-      return 0;
+      return n;
     }
     *pushTag() {
       if (this.charAt(1) === "<") {
@@ -5965,6 +5984,13 @@ var require_parser = __commonJS((exports) => {
     while (prev[++i]?.type === "space") {}
     return prev.splice(i, prev.length);
   }
+  function arrayPushArray(target, source) {
+    if (source.length < 1e5)
+      Array.prototype.push.apply(target, source);
+    else
+      for (let i = 0;i < source.length; ++i)
+        target.push(source[i]);
+  }
   function fixFlowSeqItems(fc) {
     if (fc.start.type === "flow-seq-start") {
       for (const it of fc.items) {
@@ -5974,11 +6000,11 @@ var require_parser = __commonJS((exports) => {
           delete it.key;
           if (isFlowToken(it.value)) {
             if (it.value.end)
-              Array.prototype.push.apply(it.value.end, it.sep);
+              arrayPushArray(it.value.end, it.sep);
             else
               it.value.end = it.sep;
           } else
-            Array.prototype.push.apply(it.start, it.sep);
+            arrayPushArray(it.start, it.sep);
           delete it.sep;
         }
       }
@@ -6318,7 +6344,7 @@ var require_parser = __commonJS((exports) => {
               const prev = map.items[map.items.length - 2];
               const end = prev?.value?.end;
               if (Array.isArray(end)) {
-                Array.prototype.push.apply(end, it.start);
+                arrayPushArray(end, it.start);
                 end.push(this.sourceToken);
                 map.items.pop();
                 return;
@@ -6506,7 +6532,7 @@ var require_parser = __commonJS((exports) => {
               const prev = seq.items[seq.items.length - 2];
               const end = prev?.value?.end;
               if (Array.isArray(end)) {
-                Array.prototype.push.apply(end, it.start);
+                arrayPushArray(end, it.start);
                 end.push(this.sourceToken);
                 seq.items.pop();
                 return;
@@ -7142,6 +7168,7 @@ function buildRememberRequestBody(content, options = {}) {
     source: options.source
   });
 }
+var DAEMON_DERIVED_MEMORY_SOURCE_TYPES = ["extract", "aggregate-recall", "session_end", "checkpoint", "dreaming"];
 var MEMORIES_FTS_TOKENIZER = "unicode61";
 function normalizeSql(sql) {
   return sql.replace(/\s+/g, " ").trim().toLowerCase();
@@ -10239,6 +10266,243 @@ function up92(db) {
 			ON embeddings_staging(agent_id, source_type, source_id);
 	`);
 }
+function up93(db) {
+  const columns = db.prepare("PRAGMA table_info(dreaming_state)").all();
+  if (!columns.some((column) => column.name === "evidence_cursor")) {
+    db.exec("ALTER TABLE dreaming_state ADD COLUMN evidence_cursor TEXT");
+  }
+}
+var DERIVED_SOURCE_TYPES = DAEMON_DERIVED_MEMORY_SOURCE_TYPES;
+function hasColumn13(db, table, column) {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  return rows.some((r) => r.name === column);
+}
+function up94(db) {
+  const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = 'memories'").all();
+  if (tables.length === 0)
+    return;
+  if (!hasColumn13(db, "memories", "memory_kind")) {
+    db.exec("ALTER TABLE memories ADD COLUMN memory_kind TEXT");
+  }
+  if (!hasColumn13(db, "memories", "evidence_meta")) {
+    db.exec("ALTER TABLE memories ADD COLUMN evidence_meta TEXT");
+  }
+  if (hasColumn13(db, "memories", "source_type")) {
+    const placeholders = DERIVED_SOURCE_TYPES.map(() => "?").join(", ");
+    db.prepare(`UPDATE memories
+				 SET memory_kind = 'episodic'
+				 WHERE memory_kind IS NULL
+				   AND (source_type IS NULL OR source_type NOT IN (${placeholders}))`).run(...DERIVED_SOURCE_TYPES);
+  } else {
+    db.exec(`UPDATE memories
+			 SET memory_kind = 'episodic'
+			 WHERE memory_kind IS NULL`);
+  }
+}
+function hasColumn14(db, table, column) {
+  return db.prepare(`PRAGMA table_info(${table})`).all().some((row) => row.name === column);
+}
+function up95(db) {
+  const hasMemories = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'memories'").get();
+  if (!hasMemories || !hasColumn14(db, "memories", "memory_kind") || !hasColumn14(db, "memories", "type"))
+    return;
+  db.exec("UPDATE memories SET memory_kind = NULL WHERE type = 'session_summary'");
+}
+function up96(db) {
+  db.exec("DROP TABLE IF EXISTS ingestion_jobs");
+}
+function up97(db) {
+  const columns = db.prepare("PRAGMA table_info(dreaming_state)").all();
+  if (!columns.some((column) => column.name === "last_failure_at")) {
+    db.exec("ALTER TABLE dreaming_state ADD COLUMN last_failure_at TEXT");
+  }
+  db.exec("UPDATE dreaming_state SET last_failure_at = updated_at WHERE consecutive_failures > 0 AND last_failure_at IS NULL");
+}
+function up98(db) {
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS dreaming_evidence_exclusions (
+			agent_id TEXT NOT NULL,
+			source_kind TEXT NOT NULL CHECK (source_kind IN ('memory', 'artifact', 'transcript', 'summary')),
+			source_id TEXT NOT NULL,
+			reason TEXT NOT NULL,
+			pass_id TEXT NOT NULL,
+			excluded_at TEXT NOT NULL DEFAULT (datetime('now')),
+			requeue_requested_at TEXT,
+			resolved_at TEXT,
+			PRIMARY KEY (agent_id, source_kind, source_id)
+		);
+		CREATE INDEX IF NOT EXISTS idx_dreaming_evidence_exclusions_active
+			ON dreaming_evidence_exclusions (agent_id, resolved_at, requeue_requested_at, excluded_at DESC);
+	`);
+}
+function up99(db) {
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS dreaming_tool_calls (
+			id TEXT PRIMARY KEY,
+			agent_id TEXT NOT NULL,
+			pass_id TEXT NOT NULL,
+			sequence INTEGER NOT NULL,
+			tool_call_id TEXT,
+			tool_name TEXT NOT NULL,
+			input_json TEXT NOT NULL,
+			output_json TEXT NOT NULL,
+			success INTEGER NOT NULL,
+			latency_ms INTEGER NOT NULL,
+			created_at TEXT NOT NULL DEFAULT (datetime('now')),
+			UNIQUE(agent_id, pass_id, sequence)
+		);
+		CREATE INDEX IF NOT EXISTS idx_dreaming_tool_calls_pass
+			ON dreaming_tool_calls (agent_id, pass_id, sequence ASC);
+	`);
+}
+function up100(db) {
+  const columns = db.prepare("PRAGMA table_info(dreaming_passes)").all();
+  if (!columns.some((column) => column.name === "evidence_window_json")) {
+    db.exec("ALTER TABLE dreaming_passes ADD COLUMN evidence_window_json TEXT");
+  }
+  if (!columns.some((column) => column.name === "runbook_json")) {
+    db.exec("ALTER TABLE dreaming_passes ADD COLUMN runbook_json TEXT");
+  }
+}
+function up101(db) {
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS dreaming_attention (
+			id TEXT PRIMARY KEY,
+			agent_id TEXT NOT NULL,
+			kind TEXT NOT NULL CHECK (kind IN ('review_due', 'hygiene', 'contested_claim', 'evidence_requeue')),
+			subject_ref TEXT NOT NULL,
+			details_json TEXT NOT NULL DEFAULT '{}',
+			priority INTEGER NOT NULL DEFAULT 0 CHECK (priority >= 0 AND priority <= 100),
+			created_at TEXT NOT NULL DEFAULT (datetime('now')),
+			generation INTEGER NOT NULL DEFAULT 0,
+			resolved_at TEXT,
+			resolved_by_pass_id TEXT,
+			UNIQUE(agent_id, kind, subject_ref)
+		);
+		CREATE INDEX IF NOT EXISTS idx_dreaming_attention_pending
+			ON dreaming_attention (agent_id, resolved_at, priority DESC, created_at ASC);
+	`);
+}
+function hasColumn15(db, table, column) {
+  return db.prepare(`PRAGMA table_info(${table})`).all().some((row) => row.name === column);
+}
+function up102(db) {
+  const requiredMemoryColumns = [
+    "content_hash",
+    "normalized_content",
+    "memory_kind",
+    "source_type",
+    "source_path",
+    "agent_id",
+    "visibility",
+    "is_deleted",
+    "extraction_status"
+  ];
+  if (!hasColumn15(db, "entity_attributes", "memory_id") || !requiredMemoryColumns.every((column) => hasColumn15(db, "memories", column))) {
+    return;
+  }
+  db.exec(`
+		INSERT OR IGNORE INTO memories
+		 (id, content, normalized_content, content_hash, who, why, project,
+		  importance, type, tags, pinned, is_deleted, extraction_status,
+		  created_at, updated_at, updated_by, source_type, source_id, source_path,
+		  agent_id, visibility, memory_kind)
+		SELECT attr.id, attr.content, attr.normalized_content,
+		       'semantic-attribute:' || attr.id, 'dreaming', 'Derived semantic attribute', NULL,
+		       attr.importance, 'semantic', 'semantic,attribute', 0,
+		       CASE WHEN attr.status = 'active' THEN 0 ELSE 1 END, 'completed',
+		       attr.created_at, attr.updated_at, 'dreaming', 'dreaming', attr.source_id, attr.source_path,
+		       attr.agent_id, 'global', 'derived'
+		FROM entity_attributes attr
+		WHERE attr.memory_id IS NULL
+	`);
+  db.exec(`
+		UPDATE entity_attributes
+		SET memory_id = id
+		WHERE memory_id IS NULL
+		  AND EXISTS (SELECT 1 FROM memories WHERE memories.id = entity_attributes.id)
+	`);
+  db.exec(`
+		INSERT OR IGNORE INTO memory_entity_mentions (memory_id, entity_id)
+		SELECT attr.memory_id, aspect.entity_id
+		FROM entity_attributes attr
+		JOIN entity_aspects aspect ON aspect.id = attr.aspect_id AND aspect.agent_id = attr.agent_id
+		WHERE attr.memory_id IS NOT NULL
+	`);
+  db.exec(`
+		UPDATE entities
+		SET mentions = (
+			SELECT COUNT(*) FROM memory_entity_mentions WHERE entity_id = entities.id
+		)
+		WHERE EXISTS (SELECT 1 FROM memory_entity_mentions WHERE entity_id = entities.id)
+	`);
+}
+function up103(db) {
+  const tables = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name IN ('memories', 'entity_attributes')").all();
+  if (tables.length !== 2)
+    return;
+  const memoryColumns = db.prepare("PRAGMA table_info(memories)").all().map((row) => row.name);
+  const attributeColumns = db.prepare("PRAGMA table_info(entity_attributes)").all().map((row) => row.name);
+  if (!memoryColumns.includes("memory_kind") || !attributeColumns.includes("memory_id"))
+    return;
+  db.exec(`
+		UPDATE memories
+		SET memory_kind = 'derived'
+		WHERE memory_kind IS NULL
+		  AND id IN (
+			SELECT memory_id FROM entity_attributes WHERE memory_id IS NOT NULL
+		  )
+	`);
+}
+function tableExists(db, table) {
+  return db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(table) !== undefined;
+}
+function hasColumn16(db, table, column) {
+  return db.prepare(`PRAGMA table_info(${table})`).all().some((row) => row.name === column);
+}
+function up104(db) {
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS derived_memory_sources (
+			derived_memory_id TEXT NOT NULL,
+			source_kind TEXT NOT NULL,
+			source_id TEXT NOT NULL,
+			source_path TEXT,
+			agent_id TEXT NOT NULL,
+			created_at TEXT NOT NULL,
+			PRIMARY KEY (derived_memory_id, source_kind, source_id)
+		);
+		CREATE INDEX IF NOT EXISTS idx_derived_memory_sources_derived
+			ON derived_memory_sources(agent_id, derived_memory_id);
+		CREATE INDEX IF NOT EXISTS idx_derived_memory_sources_source
+			ON derived_memory_sources(agent_id, source_kind, source_id);
+	`);
+  if (tableExists(db, "aggregate_evidence_sources")) {
+    db.exec(`
+			INSERT OR IGNORE INTO derived_memory_sources
+			 (derived_memory_id, source_kind, source_id, source_path, agent_id, created_at)
+			SELECT aggregate_memory_id, source_kind, source_id, source_path, agent_id, created_at
+			FROM aggregate_evidence_sources
+		`);
+  }
+  if (tableExists(db, "aggregate_memory_sources")) {
+    db.exec(`
+			INSERT OR IGNORE INTO derived_memory_sources
+			 (derived_memory_id, source_kind, source_id, source_path, agent_id, created_at)
+			SELECT aggregate_memory_id, 'memory', source_memory_id, NULL, agent_id, created_at
+			FROM aggregate_memory_sources
+		`);
+  }
+  if (tableExists(db, "memories") && !hasColumn16(db, "memories", "stale_at")) {
+    db.exec("ALTER TABLE memories ADD COLUMN stale_at TEXT");
+  }
+  if (tableExists(db, "memories")) {
+    db.exec(`
+			CREATE INDEX IF NOT EXISTS idx_memories_stale_derived
+			ON memories(agent_id, stale_at)
+			WHERE stale_at IS NOT NULL AND is_deleted = 0
+		`);
+  }
+}
 var MIGRATIONS = [
   {
     version: 1,
@@ -10323,7 +10587,6 @@ var MIGRATIONS = [
     name: "ingestion-tracking",
     up: up13,
     artifacts: {
-      tables: ["ingestion_jobs"],
       columns: [
         { table: "memories", column: "source_path" },
         { table: "memories", column: "source_section" }
@@ -10986,6 +11249,87 @@ var MIGRATIONS = [
     name: "embedding-staging-store",
     up: up92,
     artifacts: { tables: ["embeddings_staging"] }
+  },
+  {
+    version: 93,
+    name: "dreaming-evidence-cursor",
+    up: up93,
+    artifacts: { columns: [{ table: "dreaming_state", column: "evidence_cursor" }] }
+  },
+  {
+    version: 94,
+    name: "memory-kind",
+    up: up94,
+    artifacts: {
+      columns: [
+        { table: "memories", column: "memory_kind" },
+        { table: "memories", column: "evidence_meta" }
+      ]
+    }
+  },
+  {
+    version: 95,
+    name: "compaction-recall-projections",
+    up: up95
+  },
+  {
+    version: 96,
+    name: "retire-legacy-ingestion",
+    up: up96
+  },
+  {
+    version: 97,
+    name: "dreaming-failure-backoff",
+    up: up97,
+    artifacts: { columns: [{ table: "dreaming_state", column: "last_failure_at" }] }
+  },
+  {
+    version: 98,
+    name: "dreaming-evidence-exclusions",
+    up: up98,
+    artifacts: { tables: ["dreaming_evidence_exclusions"] }
+  },
+  {
+    version: 99,
+    name: "dreaming-tool-calls",
+    up: up99,
+    artifacts: { tables: ["dreaming_tool_calls"] }
+  },
+  {
+    version: 100,
+    name: "dreaming-runbook",
+    up: up100,
+    artifacts: {
+      columns: [
+        { table: "dreaming_passes", column: "evidence_window_json" },
+        { table: "dreaming_passes", column: "runbook_json" }
+      ]
+    }
+  },
+  {
+    version: 101,
+    name: "dreaming-attention",
+    up: up101,
+    artifacts: { tables: ["dreaming_attention"] }
+  },
+  {
+    version: 102,
+    name: "attribute-semantic-memories",
+    up: up102
+  },
+  {
+    version: 103,
+    name: "semantic-memory-kind",
+    up: up103
+  },
+  {
+    version: 104,
+    name: "derived-memory-provenance",
+    up: up104,
+    artifacts: {
+      tables: ["derived_memory_sources"],
+      columns: [{ table: "memories", column: "stale_at" }]
+    }
   }
 ];
 var LATEST_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
@@ -11322,122 +11666,6 @@ ${parts.join(`
 `)}`;
 }
 var home = homedir8();
-var SKIP_SUBTYPES = new Set([
-  "channel_join",
-  "channel_leave",
-  "channel_topic",
-  "channel_purpose",
-  "channel_name",
-  "channel_archive",
-  "channel_unarchive",
-  "group_join",
-  "group_leave",
-  "group_topic",
-  "group_purpose",
-  "group_name",
-  "group_archive",
-  "group_unarchive",
-  "pinned_item",
-  "unpinned_item",
-  "bot_add",
-  "bot_remove",
-  "tombstone",
-  "file_comment",
-  "sh_room_created",
-  "sh_room_shared"
-]);
-var SKIP_TYPES = new Set([
-  "RecipientAdd",
-  "RecipientRemove",
-  "ChannelNameChange",
-  "ChannelIconChange",
-  "ChannelPinnedMessage",
-  "GuildMemberJoin",
-  "UserPremiumGuildSubscription",
-  "UserPremiumGuildSubscriptionTier1",
-  "UserPremiumGuildSubscriptionTier2",
-  "UserPremiumGuildSubscriptionTier3",
-  "ChannelFollowAdd",
-  "GuildDiscoveryDisqualified",
-  "GuildDiscoveryRequalified",
-  "GuildDiscoveryGracePeriodInitialWarning",
-  "GuildDiscoveryGracePeriodFinalWarning",
-  "ThreadCreated",
-  "ApplicationCommand"
-]);
-var SKIP_DIRS = new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "out",
-  "target",
-  ".next",
-  ".nuxt",
-  "__pycache__",
-  ".tox",
-  ".mypy_cache",
-  ".pytest_cache",
-  "venv",
-  ".venv",
-  "env",
-  "vendor",
-  "coverage",
-  ".cache",
-  ".turbo"
-]);
-var DOCUMENT_VALID_TYPES = new Set([
-  "fact",
-  "decision",
-  "rationale",
-  "preference",
-  "procedural",
-  "semantic",
-  "system",
-  "configuration",
-  "architectural",
-  "relationship",
-  "episodic",
-  "daily-log"
-]);
-var ENTIRE_VALID_TYPES = new Set(["skill", "preference", "decision", "rationale", "procedural", "semantic", "fact"]);
-var CHAT_VALID_TYPES = new Set(["fact", "decision", "rationale", "preference", "procedural", "semantic", "system"]);
-var MARKDOWN_EXTS = new Set([".md", ".mdx", ".markdown"]);
-var TXT_EXTS = new Set([".txt", ".text", ".log", ".rst"]);
-var PDF_EXTS = new Set([".pdf"]);
-var CODE_EXTS = new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".py",
-  ".rs",
-  ".go",
-  ".java",
-  ".rb",
-  ".php",
-  ".swift",
-  ".kt",
-  ".scala",
-  ".c",
-  ".cpp",
-  ".h",
-  ".hpp",
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".sql",
-  ".yaml",
-  ".yml",
-  ".toml",
-  ".json",
-  ".xml",
-  ".css",
-  ".scss",
-  ".html",
-  ".htm"
-]);
-var SKIP_FILES = new Set([".DS_Store", "Thumbs.db", ".gitkeep", "node_modules", ".git", ".env", ".env.local"]);
 
 // ../../../libs/sdk/dist/index.js
 function isRecord2(value) {
@@ -11652,18 +11880,12 @@ class SignetClientP2 {
   async deduplicateMemories(opts) {
     return this.transport.post("/api/repair/deduplicate", opts ?? {});
   }
-  async reclassifyEntities() {
-    return this.transport.post("/api/repair/reclassify-entities", {});
-  }
   async pruneChunkGroups() {
     return this.transport.post("/api/repair/prune-chunk-groups", {});
   }
   async pruneSingletonEntities(opts) {
     return this.transport.post("/api/repair/prune-singleton-entities", opts ?? {});
   }
-  async structuralBackfill() {
-    return this.transport.post("/api/repair/structural-backfill", {});
-  }
   async listAgentPresence(opts) {
     return this.transport.get("/api/cross-agent/presence", opts);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signetai/signet-memory-openclaw",
-  "version": "0.157.4",
+  "version": "0.158.0",
   "description": "Signet adapter for OpenClaw — runtime plugin for AI agent memory",
   "type": "module",
   "main": "dist/index.js",