@astramindapp/openclaw-mind 0.1.0

package/dist/index.js

@@ -0,0 +1,1499 @@
+// src/index.ts
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+
+// src/mind-client.ts
+var MindClientError = class extends Error {
+  constructor(message, status, path3, body) {
+    super(message);
+    this.status = status;
+    this.path = path3;
+    this.body = body;
+    this.name = "MindClientError";
+  }
+  status;
+  path;
+  body;
+};
+var MindClient = class {
+  apiKey;
+  baseUrl;
+  logger;
+  timeoutMs;
+  maxRetries;
+  constructor(opts) {
+    if (!opts.apiKey) {
+      throw new Error("MindClient: apiKey is required");
+    }
+    this.apiKey = opts.apiKey;
+    this.baseUrl = (opts.baseUrl ?? "https://www.m-i-n-d.ai").replace(/\/$/, "");
+    this.logger = opts.logger;
+    this.timeoutMs = opts.timeoutMs ?? 3e4;
+    this.maxRetries = opts.maxRetries ?? 2;
+  }
+  // ─── Query / Search ───
+  async query(req) {
+    return this.request("POST", "/developer/v1/query", req);
+  }
+  // ─── Documents ───
+  async createDocument(req) {
+    return this.request("POST", "/developer/v1/documents", req);
+  }
+  async listDocuments(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+    if (opts.offset !== void 0) params.set("offset", String(opts.offset));
+    const qs = params.toString();
+    return this.request(
+      "GET",
+      `/developer/v1/documents${qs ? `?${qs}` : ""}`
+    );
+  }
+  async getDocument(id) {
+    return this.request("GET", `/developer/v1/documents/${id}`);
+  }
+  async deleteDocument(id) {
+    return this.request("DELETE", `/developer/v1/documents/${id}`);
+  }
+  // ─── Entries (lighter-weight than documents) ───
+  async createEntry(req) {
+    return this.request("POST", "/developer/v1/entries", req);
+  }
+  async listEntries(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+    if (opts.offset !== void 0) params.set("offset", String(opts.offset));
+    const qs = params.toString();
+    return this.request(
+      "GET",
+      `/developer/v1/entries${qs ? `?${qs}` : ""}`
+    );
+  }
+  async searchEntries(query, limit = 10) {
+    const params = new URLSearchParams({ q: query, limit: String(limit) });
+    return this.request(
+      "GET",
+      `/developer/v1/entries/search?${params}`
+    );
+  }
+  async deleteEntry(id) {
+    return this.request("DELETE", `/developer/v1/entries/${id}`);
+  }
+  // ─── Graph ───
+  async getGraphInfo() {
+    return this.request("GET", "/developer/v1/graph");
+  }
+  async getGraphDiagnostics() {
+    return this.request("GET", "/developer/v1/graph/diagnostics");
+  }
+  // ─── Life Management ───
+  async createLifeItem(req) {
+    return this.request("POST", "/developer/v1/life/items", req);
+  }
+  async listLifeItems(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.status) params.set("status", opts.status);
+    if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    return this.request(
+      "GET",
+      `/developer/v1/life/items${qs ? `?${qs}` : ""}`
+    );
+  }
+  async completeLifeItem(id) {
+    return this.request("POST", `/developer/v1/life/items/${id}/complete`, {});
+  }
+  // ─── CRM ───
+  async createCrmContact(req) {
+    return this.request("POST", "/developer/v1/crm/contacts", req);
+  }
+  async listCrmContacts(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    return this.request(
+      "GET",
+      `/developer/v1/crm/contacts${qs ? `?${qs}` : ""}`
+    );
+  }
+  async logCrmActivity(contactId, req) {
+    return this.request(
+      "POST",
+      `/developer/v1/crm/contacts/${contactId}/activities`,
+      req
+    );
+  }
+  // ─── Internal HTTP layer ───
+  async request(method, path3, body) {
+    const url = `${this.baseUrl}${path3}`;
+    const headers = {
+      "X-API-Key": this.apiKey,
+      Accept: "application/json",
+      "User-Agent": "openclaw-mind/0.1.0"
+    };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const resp = await fetch(url, {
+          method,
+          headers,
+          body: body !== void 0 ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          let parsed = text;
+          try {
+            parsed = JSON.parse(text);
+          } catch {
+          }
+          if ([429, 500, 502, 503, 504].includes(resp.status) && attempt < this.maxRetries) {
+            const backoff = 500 * Math.pow(2, attempt);
+            this.logger?.warn?.(
+              `MIND ${method} ${path3} \u2192 ${resp.status}, retrying in ${backoff}ms (attempt ${attempt + 1}/${this.maxRetries + 1})`
+            );
+            await sleep(backoff);
+            continue;
+          }
+          throw new MindClientError(
+            `MIND API ${resp.status} ${resp.statusText} on ${method} ${path3}`,
+            resp.status,
+            path3,
+            parsed
+          );
+        }
+        const ct = resp.headers.get("content-type") ?? "";
+        if (ct.includes("application/json")) {
+          return await resp.json();
+        }
+        return await resp.text();
+      } catch (err) {
+        clearTimeout(timeout);
+        lastError = err;
+        if (err instanceof MindClientError) throw err;
+        if (attempt < this.maxRetries) {
+          const backoff = 500 * Math.pow(2, attempt);
+          this.logger?.warn?.(
+            `MIND ${method} ${path3} network error, retrying in ${backoff}ms: ${err.message}`
+          );
+          await sleep(backoff);
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError ?? new Error("MindClient: exhausted retries");
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://www.m-i-n-d.ai";
+var DEFAULT_TOP_K = 10;
+var DEFAULT_SEARCH_THRESHOLD = 0.5;
+var DEFAULT_QUERY_MODE = "hybrid";
+function resolveConfig(raw) {
+  const apiKey = raw?.apiKey ?? process.env.MIND_API_KEY ?? process.env.MINDAPP_API_KEY;
+  const baseUrl = raw?.baseUrl ?? process.env.MIND_BASE_URL ?? DEFAULT_BASE_URL;
+  return {
+    apiKey,
+    baseUrl,
+    userId: raw?.userId ?? process.env.MIND_USER_ID,
+    autoCapture: raw?.autoCapture ?? true,
+    autoRecall: raw?.autoRecall ?? true,
+    topK: raw?.topK ?? DEFAULT_TOP_K,
+    searchThreshold: raw?.searchThreshold ?? DEFAULT_SEARCH_THRESHOLD,
+    queryMode: raw?.queryMode ?? DEFAULT_QUERY_MODE,
+    enableMindsense: raw?.enableMindsense ?? true,
+    enableLifeIntegration: raw?.enableLifeIntegration ?? true,
+    enableCrmLogging: raw?.enableCrmLogging ?? true,
+    skills: raw?.skills,
+    needsSetup: !apiKey
+  };
+}
+
+// src/tools/search.ts
+import { Type } from "@sinclair/typebox";
+var SearchParameters = Type.Object({
+  query: Type.String({ description: "What to search for" }),
+  mode: Type.Optional(
+    Type.Union(
+      [
+        Type.Literal("hybrid"),
+        Type.Literal("mix"),
+        Type.Literal("global"),
+        Type.Literal("local"),
+        Type.Literal("naive")
+      ],
+      {
+        description: "Query mode. 'hybrid' (default) blends vector + graph. 'global' synthesizes across the full graph. 'local' is entity-focused."
+      }
+    )
+  ),
+  top_k: Type.Optional(
+    Type.Number({
+      description: "Maximum number of memories to return. Default: 10",
+      minimum: 1,
+      maximum: 100
+    })
+  )
+});
+function createMindSearchTool(deps) {
+  return {
+    name: "mind_search",
+    label: "MIND Search",
+    description: "Search the MIND knowledge graph using hybrid semantic + graph queries. Returns an AI-synthesized answer grounded in stored memories. Use this whenever the agent needs prior context, decisions, preferences, or facts about the user. MIND's true KG beats vector-only tools because it follows entity relationships, not just text similarity.",
+    parameters: SearchParameters,
+    async execute(_toolCallId, params) {
+      try {
+        const result = await deps.client.query({
+          query: params.query,
+          mode: params.mode ?? deps.config.queryMode,
+          top_k: params.top_k ?? deps.config.topK
+        });
+        const sources = result.sources ?? [];
+        const sourceList = sources.length > 0 ? `
+
+Sources:
+${sources.slice(0, 5).map((s, i) => `${i + 1}. ${s.title ?? "(untitled)"}`).join("\n")}` : "";
+        return {
+          content: [{ type: "text", text: `${result.answer}${sourceList}` }],
+          details: {
+            answer: result.answer,
+            sources,
+            model_used: result.model_used
+          }
+        };
+      } catch (err) {
+        const msg = err.message;
+        return {
+          content: [{ type: "text", text: `MIND search failed: ${msg}` }],
+          details: { error: msg }
+        };
+      }
+    }
+  };
+}
+
+// src/tools/add.ts
+import { Type as Type2 } from "@sinclair/typebox";
+var AddParameters = Type2.Object({
+  content: Type2.String({
+    description: "The fact or memory to store. Any length \u2014 short thoughts to multi-paragraph documents."
+  }),
+  title: Type2.Optional(
+    Type2.String({ description: "Optional title. Auto-generated from content if omitted." })
+  ),
+  type: Type2.Optional(
+    Type2.Union(
+      [Type2.Literal("document"), Type2.Literal("entry"), Type2.Literal("thought")],
+      {
+        description: "Storage type. 'document' (long-form), 'entry' (medium), 'thought' (quick). Default: auto-decide by content length."
+      }
+    )
+  ),
+  tags: Type2.Optional(
+    Type2.Array(Type2.String(), { description: "Optional tags for retrieval." })
+  )
+});
+function createMindAddTool(deps) {
+  return {
+    name: "mind_add",
+    label: "MIND Add Memory",
+    description: "Store a memory in the MIND knowledge graph. Auto-extracts entities (people, places, concepts, events) and the relationships between them. If MINDsense is enabled, also assigns valence/arousal emotional weights that determine encoding depth \u2014 emotionally significant content is encoded more deeply, mirroring biological memory consolidation.",
+    parameters: AddParameters,
+    async execute(_toolCallId, params) {
+      try {
+        const type = params.type ?? autoDecideType(params.content);
+        const title = params.title ?? deriveTitle(params.content);
+        if (type === "document") {
+          const doc = await deps.client.createDocument({
+            title,
+            content: params.content,
+            tags: params.tags,
+            source: "openclaw-mind"
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Stored as document "${doc.title}" (id: ${doc.id})`
+              }
+            ],
+            details: { id: doc.id, type: "document", title: doc.title }
+          };
+        }
+        const entry = await deps.client.createEntry({
+          title,
+          content: params.content,
+          type: type === "thought" ? "thought" : "entry",
+          tags: params.tags,
+          source: "openclaw-mind"
+        });
+        return {
+          content: [
+            { type: "text", text: `Stored as ${type} "${entry.title ?? title}" (id: ${entry.id})` }
+          ],
+          details: { id: entry.id, type, title: entry.title ?? title }
+        };
+      } catch (err) {
+        const msg = err.message;
+        return {
+          content: [{ type: "text", text: `mind_add failed: ${msg}` }],
+          details: { error: msg }
+        };
+      }
+    }
+  };
+}
+function autoDecideType(content) {
+  const words = content.trim().split(/\s+/).length;
+  if (words >= 200) return "document";
+  if (words >= 30) return "entry";
+  return "thought";
+}
+function deriveTitle(content) {
+  const firstLine = content.trim().split("\n")[0] ?? content;
+  return firstLine.slice(0, 100).trim() || "Untitled memory";
+}
+
+// src/tools/get.ts
+import { Type as Type3 } from "@sinclair/typebox";
+var GetParameters = Type3.Object({
+  id: Type3.String({ description: "The memory ID to retrieve" }),
+  type: Type3.Optional(
+    Type3.Union(
+      [Type3.Literal("document"), Type3.Literal("entry")],
+      { description: "Storage type. Default: 'document'" }
+    )
+  )
+});
+function createMindGetTool(deps) {
+  return {
+    name: "mind_get",
+    label: "MIND Get Memory",
+    description: "Retrieve a single memory by its ID. Returns full content, metadata, tags, timestamps.",
+    parameters: GetParameters,
+    async execute(_toolCallId, params) {
+      try {
+        const type = params.type ?? "document";
+        let result;
+        if (type === "document") {
+          result = await deps.client.getDocument(params.id);
+        } else {
+          const list = await deps.client.listEntries({ limit: 100 });
+          result = list.entries.find((e) => e.id === params.id);
+          if (!result) {
+            return {
+              content: [{ type: "text", text: `Entry ${params.id} not found` }],
+              details: { error: "not_found" }
+            };
+          }
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result
+        };
+      } catch (err) {
+        const msg = err.message;
+        return {
+          content: [{ type: "text", text: `mind_get failed: ${msg}` }],
+          details: { error: msg }
+        };
+      }
+    }
+  };
+}
+
+// src/tools/list.ts
+import { Type as Type4 } from "@sinclair/typebox";
+var ListParameters = Type4.Object({
+  type: Type4.Optional(
+    Type4.Union(
+      [Type4.Literal("document"), Type4.Literal("entry"), Type4.Literal("all")],
+      { description: "Filter by storage type. Default: 'all'" }
+    )
+  ),
+  limit: Type4.Optional(
+    Type4.Number({ description: "Maximum number to return. Default: 20", minimum: 1, maximum: 100 })
+  ),
+  offset: Type4.Optional(Type4.Number({ description: "Pagination offset. Default: 0", minimum: 0 }))
+});
+function createMindListTool(deps) {
+  return {
+    name: "mind_list",
+    label: "MIND List",
+    description: "List stored memories with pagination. Returns IDs, titles, types, tags, timestamps. Use for browsing or when the agent needs to enumerate before deciding what to retrieve.",
+    parameters: ListParameters,
+    async execute(_toolCallId, params) {
+      try {
+        const limit = params.limit ?? 20;
+        const offset = params.offset ?? 0;
+        const type = params.type ?? "all";
+        const result = {};
+        if (type === "document" || type === "all") {
+          const docs = await deps.client.listDocuments({ limit, offset });
+          result.documents = docs.documents;
+        }
+        if (type === "entry" || type === "all") {
+          const entries = await deps.client.listEntries({ limit, offset });
+          result.entries = entries.entries;
+        }
+        const summary = [
+          `${result.documents?.length ?? 0} documents`,
+          `${result.entries?.length ?? 0} entries`
+        ].join(", ");
+        return {
+          content: [{ type: "text", text: `${summary}
+
+${JSON.stringify(result, null, 2)}` }],
+          details: result
+        };
+      } catch (err) {
+        const msg = err.message;
+        return {
+          content: [{ type: "text", text: `mind_list failed: ${msg}` }],
+          details: { error: msg }
+        };
+      }
+    }
+  };
+}
+
+// src/tools/update.ts
+import { Type as Type5 } from "@sinclair/typebox";
+var UpdateParameters = Type5.Object({
+  id: Type5.String({ description: "The memory ID to update" }),
+  content: Type5.String({ description: "New content. Replaces the existing content." }),
+  title: Type5.Optional(Type5.String({ description: "New title." })),
+  tags: Type5.Optional(Type5.Array(Type5.String())),
+  type: Type5.Optional(
+    Type5.Union(
+      [Type5.Literal("document"), Type5.Literal("entry")],
+      { description: "Storage type. Default: 'document'" }
+    )
+  )
+});
+function createMindUpdateTool(deps) {
+  return {
+    name: "mind_update",
+    label: "MIND Update Memory",
+    description: "Update an existing memory's content, title, or tags. The KG is re-extracted from the new content automatically. Use when a stored fact has changed (e.g., user's role, deadline shift, decision update).",
+    parameters: UpdateParameters,
+    async execute(_toolCallId, params) {
+      try {
+        const type = params.type ?? "document";
+        if (type === "document") {
+          const original = await deps.client.getDocument(params.id);
+          await deps.client.deleteDocument(params.id);
+          const created = await deps.client.createDocument({
+            title: params.title ?? original.title,
+            content: params.content,
+            tags: params.tags ?? original.tags,
+            source: "openclaw-mind"
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Updated memory. New id: ${created.id} (was: ${params.id})`
+              }
+            ],
+            details: { id: created.id, previous_id: params.id, title: created.title }
+          };
+        }
+        await deps.client.deleteEntry(params.id);
+        const entry = await deps.client.createEntry({
+          title: params.title,
+          content: params.content,
+          type: "entry",
+          tags: params.tags,
+          source: "openclaw-mind"
+        });
+        return {
+          content: [
+            { type: "text", text: `Updated entry. New id: ${entry.id} (was: ${params.id})` }
+          ],
+          details: { id: entry.id, previous_id: params.id, title: entry.title }
+        };
+      } catch (err) {
+        const msg = err.message;
+        return {
+          content: [{ type: "text", text: `mind_update failed: ${msg}` }],
+          details: { error: msg }
+        };
+      }
+    }
+  };
+}
+
+// src/tools/delete.ts
+import { Type as Type6 } from "@sinclair/typebox";
+var DeleteParameters = Type6.Object({
+  id: Type6.String({ description: "The memory ID to delete" }),
+  type: Type6.Optional(
+    Type6.Union(
+      [Type6.Literal("document"), Type6.Literal("entry")],
+      { description: "Storage type. Default: 'document'" }
+    )
+  )
+});
+function createMindDeleteTool(deps) {
+  return {
+    name: "mind_delete",
+    label: "MIND Delete Memory",
+    description: "Delete a memory by its ID. KG entities and relationships sourced from this memory are removed. Use sparingly \u2014 prefer mind_update if content is just changing.",
+    parameters: DeleteParameters,
+    async execute(_toolCallId, params) {
+      try {
+        const type = params.type ?? "document";
+        if (type === "document") {
+          await deps.client.deleteDocument(params.id);
+        } else {
+          await deps.client.deleteEntry(params.id);
+        }
+        return {
+          content: [{ type: "text", text: `Deleted ${type} ${params.id}` }],
+          details: { id: params.id, status: "deleted" }
+        };
+      } catch (err) {
+        const msg = err.message;
+        return {
+          content: [{ type: "text", text: `mind_delete failed: ${msg}` }],
+          details: { error: msg }
+        };
+      }
+    }
+  };
+}
+
+// src/tools/query-graph.ts
+import { Type as Type7 } from "@sinclair/typebox";
+var QueryGraphParameters = Type7.Object({
+  question: Type7.String({
+    description: "A graph-shaped question. Examples: 'Who is connected to Sarah?', 'What concepts cluster around the KGC pitch?', 'What decisions are linked to the auth migration?'"
+  }),
+  mode: Type7.Optional(
+    Type7.Union([Type7.Literal("global"), Type7.Literal("local"), Type7.Literal("mix")], {
+      description: "Graph query mode. 'global' (default) synthesizes across the full graph. 'local' is entity-focused. 'mix' balances both."
+    })
+  )
+});
+function createMindQueryGraphTool(deps) {
+  return {
+    name: "mind_query_graph",
+    label: "MIND Graph Query",
+    description: "Query the MIND knowledge graph by structure, not just similarity. Use for questions about RELATIONSHIPS between entities. Example: mind_search answers 'what did the user say about Sarah?'; mind_query_graph answers 'who is Sarah connected to and how?'. This is a true KG capability vector-only memory tools cannot match.",
+    parameters: QueryGraphParameters,
+    async execute(_toolCallId, params) {
+      try {
+        const result = await deps.client.query({
+          query: params.question,
+          mode: params.mode ?? "global",
+          top_k: 30
+        });
+        return {
+          content: [{ type: "text", text: result.answer }],
+          details: {
+            answer: result.answer,
+            sources: result.sources ?? [],
+            mode: params.mode ?? "global"
+          }
+        };
+      } catch (err) {
+        const msg = err.message;
+        return {
+          content: [{ type: "text", text: `mind_query_graph failed: ${msg}` }],
+          details: { error: msg }
+        };
+      }
+    }
+  };
+}
+
+// src/tools/recall-emotional.ts
+import { Type as Type8 } from "@sinclair/typebox";
+var RecallEmotionalParameters = Type8.Object({
+  query: Type8.String({
+    description: "What to search for, biased toward emotionally salient memories."
+  }),
+  emotion_filter: Type8.Optional(
+    Type8.Union(
+      [
+        Type8.Literal("positive"),
+        Type8.Literal("negative"),
+        Type8.Literal("high_arousal"),
+        Type8.Literal("low_arousal"),
+        Type8.Literal("triumph"),
+        Type8.Literal("warning"),
+        Type8.Literal("any")
+      ],
+      {
+        description: "Filter by emotional category. 'positive'=high valence. 'negative'=low valence. 'high_arousal'=intense moments. 'triumph' / 'warning' = MINDsense semantic categories."
+      }
+    )
+  ),
+  min_intensity: Type8.Optional(
+    Type8.Number({
+      description: "Minimum emotional intensity (0-1). Default: 0.3",
+      minimum: 0,
+      maximum: 1
+    })
+  ),
+  top_k: Type8.Optional(
+    Type8.Number({ description: "Maximum results. Default: 10", minimum: 1, maximum: 50 })
+  )
+});
+function createMindRecallEmotionalTool(deps) {
+  return {
+    name: "mind_recall_emotional",
+    label: "MIND Emotional Recall",
+    description: "Recall memories weighted by emotional significance (MINDsense, patented). Use when the agent needs to understand the user's strong feelings, important moments, frustrations, wins, or warnings. Example queries: 'what frustrates the user about deployment', 'what wins did the user celebrate this month'.",
+    parameters: RecallEmotionalParameters,
+    async execute(_toolCallId, params) {
+      try {
+        const emotionTag = params.emotion_filter ?? "any";
+        const intensityHint = params.min_intensity ?? 0.3;
+        const augmentedQuery = `${params.query}
+
+[Emotional context: ${emotionTag}, min_intensity=${intensityHint}]`;
+        const result = await deps.client.query({
+          query: augmentedQuery,
+          mode: "hybrid",
+          top_k: params.top_k ?? 10
+        });
+        return {
+          content: [{ type: "text", text: result.answer }],
+          details: {
+            answer: result.answer,
+            sources: result.sources ?? [],
+            emotion_filter: emotionTag,
+            min_intensity: intensityHint
+          }
+        };
+      } catch (err) {
+        const msg = err.message;
+        return {
+          content: [{ type: "text", text: `mind_recall_emotional failed: ${msg}` }],
+          details: { error: msg }
+        };
+      }
+    }
+  };
+}
+
+// src/tools/context.ts
+import { Type as Type9 } from "@sinclair/typebox";
+var ContextParameters = Type9.Object({
+  sections: Type9.Optional(
+    Type9.Array(
+      Type9.Union([
+        Type9.Literal("soul"),
+        Type9.Literal("user"),
+        Type9.Literal("rules"),
+        Type9.Literal("priorities"),
+        Type9.Literal("recent")
+      ]),
+      {
+        description: "Which context sections to load. Default: all 5. 'soul'=identity. 'user'=preferences. 'rules'=constraints. 'priorities'=current goals. 'recent'=last 7 days."
+      }
+    )
+  )
+});
+var SECTION_QUERIES = {
+  soul: "user identity mission personality core values",
+  user: "user preferences role responsibilities personal details",
+  rules: "operating rules constraints guardrails behavioral preferences",
+  priorities: "current priorities goals deadlines active projects this quarter",
+  recent: "recent activity last 7 days outcomes decisions"
+};
+function createMindContextTool(deps) {
+  return {
+    name: "mind_context",
+    label: "MIND Context",
+    description: "Load structured persistent context at session start. Returns 5 sections: soul, user, rules, priorities, recent. Call FIRST in any session to ground the agent in who the user is and what matters now.",
+    parameters: ContextParameters,
+    async execute(_toolCallId, params) {
+      const sections = params.sections ?? ["soul", "user", "rules", "priorities", "recent"];
+      const result = {};
+      await Promise.all(
+        sections.map(async (section) => {
+          const queryStr = SECTION_QUERIES[section] ?? section;
+          try {
+            const resp = await deps.client.query({
+              query: queryStr,
+              mode: "hybrid",
+              top_k: 8
+            });
+            result[section] = {
+              summary: resp.answer,
+              sources: (resp.sources ?? []).slice(0, 5)
+            };
+          } catch (err) {
+            result[section] = { error: err.message };
+          }
+        })
+      );
+      const summary = sections.map((s) => {
+        const sec = result[s];
+        if (sec?.error) return `## ${s.toUpperCase()}
+[Error: ${sec.error}]`;
+        return `## ${s.toUpperCase()}
+${sec?.summary ?? ""}`;
+      }).join("\n\n");
+      return {
+        content: [{ type: "text", text: summary }],
+        details: result
+      };
+    }
+  };
+}
+
+// src/tools/life.ts
+import { Type as Type10 } from "@sinclair/typebox";
+var LifeParameters = Type10.Object({
+  action: Type10.Union(
+    [Type10.Literal("create"), Type10.Literal("list"), Type10.Literal("complete")],
+    { description: "What to do" }
+  ),
+  title: Type10.Optional(Type10.String({ description: "Item title (required for create)" })),
+  description: Type10.Optional(Type10.String()),
+  type: Type10.Optional(
+    Type10.Union(
+      [Type10.Literal("task"), Type10.Literal("goal"), Type10.Literal("project")],
+      { description: "Item type. Default: 'task'" }
+    )
+  ),
+  priority: Type10.Optional(
+    Type10.Union(
+      [
+        Type10.Literal("low"),
+        Type10.Literal("medium"),
+        Type10.Literal("high"),
+        Type10.Literal("urgent")
+      ],
+      { description: "Priority. Default: 'medium'" }
+    )
+  ),
+  due_date: Type10.Optional(Type10.String({ description: "ISO date or datetime" })),
+  status: Type10.Optional(
+    Type10.Union(
+      [
+        Type10.Literal("todo"),
+        Type10.Literal("in_progress"),
+        Type10.Literal("blocked"),
+        Type10.Literal("done"),
+        Type10.Literal("all")
+      ],
+      { description: "Filter for list. Default: 'todo'" }
+    )
+  ),
+  limit: Type10.Optional(Type10.Number({ description: "Max results for list. Default: 20" })),
+  item_id: Type10.Optional(Type10.String({ description: "Item ID for complete" }))
+});
+function createMindLifeTool(deps) {
+  return {
+    name: "mind_life",
+    label: "MIND Life",
+    description: "Manage MIND Life items (tasks, goals, projects). Use when the user mentions something to do, a deadline, a goal, or a project. Actions: 'create', 'list', 'complete'. MIND Life syncs to web and mobile apps.",
+    parameters: LifeParameters,
+    async execute(_toolCallId, params) {
+      try {
+        switch (params.action) {
+          case "create": {
+            if (!params.title) {
+              return {
+                content: [{ type: "text", text: "'title' is required for action='create'" }],
+                details: { error: "missing_title" }
+              };
+            }
+            const item = await deps.client.createLifeItem({
+              title: params.title,
+              description: params.description,
+              type: params.type ?? "task",
+              status: "todo",
+              priority: params.priority ?? "medium",
+              due_date: params.due_date
+            });
+            return {
+              content: [{ type: "text", text: `Created life item "${item.title}" (id: ${item.id})` }],
+              details: item
+            };
+          }
+          case "list": {
+            const status = params.status ?? "todo";
+            const items = await deps.client.listLifeItems({
+              status: status === "all" ? void 0 : status,
+              limit: params.limit ?? 20
+            });
+            const list = items.items.map((i) => `- [${i.status}] ${i.title} ${i.due_date ? `(due ${i.due_date})` : ""}`).join("\n");
+            return {
+              content: [{ type: "text", text: `${items.items.length} items:
+${list}` }],
+              details: items
+            };
+          }
+          case "complete": {
+            if (!params.item_id) {
+              return {
+                content: [{ type: "text", text: "'item_id' is required for action='complete'" }],
+                details: { error: "missing_item_id" }
+              };
+            }
+            await deps.client.completeLifeItem(params.item_id);
+            return {
+              content: [{ type: "text", text: `Completed life item ${params.item_id}` }],
+              details: { id: params.item_id, status: "completed" }
+            };
+          }
+        }
+      } catch (err) {
+        const msg = err.message;
+        return {
+          content: [{ type: "text", text: `mind_life failed: ${msg}` }],
+          details: { error: msg }
+        };
+      }
+    }
+  };
+}
+
+// src/tools/crm-log.ts
+import { Type as Type11 } from "@sinclair/typebox";
+var CrmLogParameters = Type11.Object({
+  action: Type11.Union(
+    [
+      Type11.Literal("create_contact"),
+      Type11.Literal("list_contacts"),
+      Type11.Literal("log_activity")
+    ],
+    { description: "What to do" }
+  ),
+  name: Type11.Optional(Type11.String({ description: "Contact name (required for create_contact)" })),
+  email: Type11.Optional(Type11.String()),
+  phone: Type11.Optional(Type11.String()),
+  company: Type11.Optional(Type11.String()),
+  type: Type11.Optional(Type11.String({ description: "Relationship type: investor, partner, customer" })),
+  stage: Type11.Optional(Type11.String({ description: "Pipeline stage" })),
+  notes: Type11.Optional(Type11.String()),
+  contact_id: Type11.Optional(Type11.String({ description: "Contact ID for log_activity" })),
+  activity_type: Type11.Optional(
+    Type11.Union(
+      [
+        Type11.Literal("call"),
+        Type11.Literal("email"),
+        Type11.Literal("meeting"),
+        Type11.Literal("note"),
+        Type11.Literal("other")
+      ],
+      { description: "Activity type" }
+    )
+  ),
+  summary: Type11.Optional(Type11.String({ description: "What happened" })),
+  occurred_at: Type11.Optional(Type11.String({ description: "ISO datetime" })),
+  limit: Type11.Optional(Type11.Number({ description: "Max contacts to list" }))
+});
+function createMindCrmLogTool(deps) {
+  return {
+    name: "mind_crm_log",
+    label: "MIND CRM",
+    description: "Manage MIND CRM contacts and log interactions. Use when the user mentions a person they're working with, a meeting, an email, or a relationship. Actions: 'create_contact', 'list_contacts', 'log_activity'.",
+    parameters: CrmLogParameters,
+    async execute(_toolCallId, params) {
+      try {
+        switch (params.action) {
+          case "create_contact": {
+            if (!params.name) {
+              return {
+                content: [{ type: "text", text: "'name' is required for create_contact" }],
+                details: { error: "missing_name" }
+              };
+            }
+            const contact = await deps.client.createCrmContact({
+              name: params.name,
+              email: params.email,
+              phone: params.phone,
+              company: params.company,
+              type: params.type,
+              stage: params.stage,
+              notes: params.notes
+            });
+            return {
+              content: [{ type: "text", text: `Created contact ${contact.name} (id: ${contact.id})` }],
+              details: contact
+            };
+          }
+          case "list_contacts": {
+            const contacts = await deps.client.listCrmContacts({ limit: params.limit ?? 20 });
+            const list = contacts.contacts.map((c) => `- ${c.name} ${c.company ? `(${c.company})` : ""}`).join("\n");
+            return {
+              content: [{ type: "text", text: `${contacts.contacts.length} contacts:
+${list}` }],
+              details: contacts
+            };
+          }
+          case "log_activity": {
+            if (!params.contact_id || !params.activity_type || !params.summary) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: "'contact_id', 'activity_type', and 'summary' are required for log_activity"
+                  }
+                ],
+                details: { error: "missing_required" }
+              };
+            }
+            await deps.client.logCrmActivity(params.contact_id, {
+              type: params.activity_type,
+              summary: params.summary,
+              occurred_at: params.occurred_at
+            });
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Logged ${params.activity_type} activity for contact ${params.contact_id}`
+                }
+              ],
+              details: { contact_id: params.contact_id, activity_type: params.activity_type }
+            };
+          }
+        }
+      } catch (err) {
+        const msg = err.message;
+        return {
+          content: [{ type: "text", text: `mind_crm_log failed: ${msg}` }],
+          details: { error: msg }
+        };
+      }
+    }
+  };
+}
+
+// src/tools/index.ts
+function registerAllTools(api, client, config) {
+  const deps = { client, config };
+  api.registerTool(createMindSearchTool(deps));
+  api.registerTool(createMindAddTool(deps));
+  api.registerTool(createMindGetTool(deps));
+  api.registerTool(createMindListTool(deps));
+  api.registerTool(createMindUpdateTool(deps));
+  api.registerTool(createMindDeleteTool(deps));
+  api.registerTool(createMindQueryGraphTool(deps));
+  if (config.enableMindsense) {
+    api.registerTool(createMindRecallEmotionalTool(deps));
+  }
+  api.registerTool(createMindContextTool(deps));
+  if (config.enableLifeIntegration) {
+    api.registerTool(createMindLifeTool(deps));
+  }
+  if (config.enableCrmLogging) {
+    api.registerTool(createMindCrmLogTool(deps));
+  }
+}
+
+// src/cli/auth-file.ts
+import { promises as fs } from "fs";
+import * as path from "path";
+import * as os from "os";
+var AUTH_DIR = path.join(os.homedir(), ".openclaw", "plugins");
+var AUTH_FILE = path.join(AUTH_DIR, "openclaw-mind.json");
+async function writeAuthFile(auth) {
+  await fs.mkdir(AUTH_DIR, { recursive: true, mode: 448 });
+  await fs.writeFile(AUTH_FILE, JSON.stringify(auth, null, 2), { mode: 384 });
+}
+
+// src/cli/init.ts
+async function initCommand(api, opts, config) {
+  const baseUrl = opts.baseUrl ?? config.baseUrl;
+  if (opts.apiKey) {
+    return setupWithApiKey(api, opts.apiKey, baseUrl);
+  }
+  if (opts.email) {
+    return setupWithMagicLink(api, opts.email, baseUrl);
+  }
+  api.logger.info(
+    [
+      "To set up MIND, provide an API key or email:",
+      "",
+      "  openclaw mind init --api-key mind_your_key_here",
+      "  openclaw mind init --email you@example.com",
+      "",
+      "Get an API key at https://www.m-i-n-d.ai \u2192 Settings \u2192 Developer \u2192 Create API Key"
+    ].join("\n")
+  );
+}
+async function setupWithApiKey(api, apiKey, baseUrl) {
+  if (!apiKey.startsWith("mind_")) {
+    api.logger.error("Invalid API key format. Keys must start with 'mind_'.");
+    return;
+  }
+  const client = new MindClient({ apiKey, baseUrl, logger: api.logger });
+  try {
+    const info = await client.getGraphInfo();
+    api.logger.info(
+      [
+        "\u2713 Connected to MIND",
+        `  Entities: ${info.entity_count ?? "?"}`,
+        `  Relationships: ${info.relationship_count ?? "?"}`,
+        `  Credits remaining: ${info.credits_remaining ?? "?"}`
+      ].join("\n")
+    );
+    await writeAuthFile({ apiKey, baseUrl });
+    api.logger.info("\u2713 API key saved. MIND auto-recall and auto-capture are now active.");
+  } catch (err) {
+    api.logger.error(
+      `Failed to verify MIND API key: ${err.message}
+Double-check the key at https://www.m-i-n-d.ai/settings/developer`
+    );
+  }
+}
+async function setupWithMagicLink(api, _email, _baseUrl) {
+  api.logger.error(
+    [
+      "Magic-link auth is coming in v0.2. For now, use --api-key:",
+      "",
+      "  openclaw mind init --api-key mind_your_key_here",
+      "",
+      "Get a key at https://www.m-i-n-d.ai \u2192 Settings \u2192 Developer."
+    ].join("\n")
+  );
+}
+
+// src/cli/status.ts
+async function statusCommand(api, client, config) {
+  if (!client || config.needsSetup) {
+    api.logger.info(
+      [
+        "MIND: NOT CONNECTED",
+        "",
+        "Run: openclaw mind init --api-key mind_your_key_here",
+        "Get a key at https://www.m-i-n-d.ai \u2192 Settings \u2192 Developer"
+      ].join("\n")
+    );
+    return;
+  }
+  try {
+    const info = await client.getGraphInfo();
+    api.logger.info(
+      [
+        "MIND: CONNECTED",
+        `  Base URL:        ${config.baseUrl}`,
+        `  Entities:        ${info.entity_count ?? "?"}`,
+        `  Relationships:   ${info.relationship_count ?? "?"}`,
+        `  Storage health:  ${info.storage_health ?? "?"}`,
+        `  Credits left:    ${info.credits_remaining ?? "?"}`,
+        "",
+        "Settings:",
+        `  Auto-recall:      ${config.autoRecall}`,
+        `  Auto-capture:     ${config.autoCapture}`,
+        `  Top-K recall:     ${config.topK}`,
+        `  Query mode:       ${config.queryMode}`,
+        `  MINDsense:        ${config.enableMindsense}`,
+        `  Life integration: ${config.enableLifeIntegration}`,
+        `  CRM logging:      ${config.enableCrmLogging}`
+      ].join("\n")
+    );
+  } catch (err) {
+    api.logger.error(`Failed to reach MIND: ${err.message}`);
+  }
+}
+
+// src/cli/import.ts
+import { promises as fs2 } from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+var ALWAYS_IMPORT = ["SOUL.md", "IDENTITY.md", "USER.md", "MEMORY.md"];
+var SKIP = /* @__PURE__ */ new Set(["AGENTS.md", "BOOTSTRAP.md", "HEARTBEAT.md", "TOOLS.md"]);
+var WORDS_PER_DOCUMENT_THRESHOLD = 2e3;
+async function importCommand(api, client, config, opts) {
+  if (!client || config.needsSetup) {
+    api.logger.error("MIND not configured. Run: openclaw mind init --api-key mind_...");
+    return;
+  }
+  const workspace = opts.workspace ?? path2.join(os2.homedir(), ".openclaw", "workspace");
+  const days = parseInt(opts.days ?? "30", 10);
+  if (!await pathExists(workspace)) {
+    api.logger.error(`Workspace not found: ${workspace}`);
+    return;
+  }
+  api.logger.info(`Scanning ${workspace}...`);
+  const items = [];
+  for (const filename of ALWAYS_IMPORT) {
+    const filepath = path2.join(workspace, filename);
+    if (await pathExists(filepath)) {
+      const content = await fs2.readFile(filepath, "utf8");
+      items.push(...splitFile(filename, content, ["openclaw-import", "core-memory"]));
+    }
+  }
+  const memoryDir = path2.join(workspace, "memory");
+  if (await pathExists(memoryDir)) {
+    const files = await fs2.readdir(memoryDir);
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
+    const dateFiles = files.filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse();
+    for (const file of dateFiles) {
+      const dateStr = file.replace(".md", "");
+      const fileTime = new Date(dateStr).getTime();
+      if (Number.isNaN(fileTime) || fileTime < cutoff) continue;
+      const filepath = path2.join(memoryDir, file);
+      const content = await fs2.readFile(filepath, "utf8");
+      items.push(...splitFile(file, content, ["openclaw-import", "daily-memory", dateStr]));
+    }
+  }
+  if (items.length === 0) {
+    api.logger.info("Nothing to import.");
+    return;
+  }
+  api.logger.info(`Found ${items.length} memory chunks. Importing to MIND...`);
+  let succeeded = 0;
+  let failed = 0;
+  for (const item of items) {
+    try {
+      await client.createDocument({
+        title: item.title,
+        content: item.content,
+        tags: item.tags,
+        source: "openclaw-mind-import"
+      });
+      succeeded++;
+    } catch (err) {
+      failed++;
+      api.logger?.warn(`Failed to import "${item.title}": ${err.message}`);
+    }
+  }
+  api.logger.info(
+    `Done. Imported: ${succeeded}, failed: ${failed}. Run \`openclaw mind status\` to see updated entity count.`
+  );
+}
+function splitFile(filename, content, tags) {
+  if (SKIP.has(filename)) return [];
+  const wordCount = content.trim().split(/\s+/).length;
+  if (wordCount <= WORDS_PER_DOCUMENT_THRESHOLD) {
+    return [
+      {
+        title: `${filename}`,
+        content: content.trim(),
+        tags
+      }
+    ];
+  }
+  const sections = [];
+  const lines = content.split("\n");
+  let currentTitle = filename;
+  let currentBuffer = [];
+  const flush = () => {
+    const text = currentBuffer.join("\n").trim();
+    if (text.length > 0) {
+      sections.push({ title: currentTitle, content: text, tags });
+    }
+  };
+  for (const line of lines) {
+    if (line.startsWith("# ")) {
+      flush();
+      currentBuffer = [line];
+      currentTitle = `${filename} \u2014 ${line.replace(/^#\s*/, "").trim()}`;
+    } else {
+      currentBuffer.push(line);
+    }
+  }
+  flush();
+  return sections;
+}
+async function pathExists(p) {
+  try {
+    await fs2.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/search.ts
+async function searchCommand(api, client, opts) {
+  if (!client) {
+    api.logger.error("MIND not configured. Run: openclaw mind init --api-key mind_...");
+    return;
+  }
+  if (!opts.query) {
+    api.logger.error('Usage: openclaw mind search "your query"');
+    return;
+  }
+  const mode = opts.mode ?? "hybrid";
+  const topK = parseInt(opts.topK ?? "5", 10);
+  try {
+    const result = await client.query({
+      query: opts.query,
+      mode,
+      top_k: topK
+    });
+    api.logger.info(`
+${result.answer}
+`);
+    if (result.sources && result.sources.length > 0) {
+      const sourceLines = result.sources.map((s, i) => {
+        const score = s.score ? `(score: ${s.score.toFixed(2)})` : "";
+        return `  ${i + 1}. ${s.title ?? "(untitled)"} ${score}`;
+      });
+      api.logger.info(`Sources:
+${sourceLines.join("\n")}`);
+    }
+  } catch (err) {
+    api.logger.error(`Search failed: ${err.message}`);
+  }
+}
+
+// src/cli/index.ts
+function registerCliCommands(api, client, config) {
+  api.registerCli(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (ctx) => {
+      const program = ctx.program;
+      const mind = program.command("mind").description("MIND personal knowledge graph commands");
+      mind.command("init").description("Set up your MIND API key and verify the connection").option("--api-key <key>", "MIND API key (mind_...)").option("--email <email>", "Email for magic-link auth (alternative to api-key)").option("--base-url <url>", "Override the MIND base URL (for self-hosting)").action(async (opts) => {
+        await initCommand(
+          api,
+          { apiKey: opts.apiKey, email: opts.email, baseUrl: opts.baseUrl },
+          config
+        );
+      });
+      mind.command("status").description("Verify the MIND connection and show your account info").action(async () => {
+        await statusCommand(api, client, config);
+      });
+      mind.command("import").description("Import OpenClaw workspace memory files into MIND").option(
+        "--workspace <path>",
+        "Path to OpenClaw workspace dir (default: ~/.openclaw/workspace)"
+      ).option("--days <n>", "How many days of recent memory files to import (default: 30)").action(async (opts) => {
+        await importCommand(api, client, config, {
+          workspace: opts.workspace,
+          days: opts.days
+        });
+      });
+      mind.command("search").description("Quick CLI search of the MIND knowledge graph").argument("<query>", "What to search for").option("--mode <mode>", "Query mode (hybrid/mix/global/local/naive)").option("--top-k <n>", "Max results (default: 5)").action(async (query, opts) => {
+        await searchCommand(api, client, {
+          query,
+          mode: opts.mode,
+          topK: opts.topK
+        });
+      });
+    },
+    { commands: ["mind"] }
+  );
+}
+
+// src/lib/session.ts
+var NON_INTERACTIVE_TRIGGERS = /* @__PURE__ */ new Set(["cron", "scheduled", "webhook", "event", "system"]);
+var SUBAGENT_PATTERN = /:subagent:/;
+var CRON_SESSION_PATTERN = /:cron:/;
+function isNonInteractiveTrigger(trigger, sessionKey) {
+  if (trigger && NON_INTERACTIVE_TRIGGERS.has(trigger.toLowerCase())) {
+    return true;
+  }
+  if (sessionKey && CRON_SESSION_PATTERN.test(sessionKey)) {
+    return true;
+  }
+  return false;
+}
+function isSubagentSession(sessionKey) {
+  if (!sessionKey) return false;
+  return SUBAGENT_PATTERN.test(sessionKey);
+}
+
+// src/lib/filter.ts
+var NOISE_PATTERNS = [
+  /^heartbeat\b/i,
+  /^cron:/i,
+  /^ping$/i,
+  /^pong$/i,
+  /^ok$/i,
+  /^thanks$/i,
+  /^thank you$/i,
+  /^got it$/i,
+  /^sure$/i,
+  /^yes$/i,
+  /^no$/i
+];
+var GENERIC_ASSISTANT_PATTERNS = [
+  /^how can i (help|assist) you/i,
+  /^what (can|would you like)/i,
+  /^i('m| am) (here to help|happy to help)/i,
+  /^sure[,.!]? (i can|let me)/i,
+  /^certainly[,.!]/i
+];
+var NOISE_FRAGMENTS = [
+  /<routing-metadata>[\s\S]*?<\/routing-metadata>/g,
+  /<compaction-audit>[\s\S]*?<\/compaction-audit>/g,
+  /<openclaw:heartbeat>[\s\S]*?<\/openclaw:heartbeat>/g
+];
+var MAX_MESSAGE_CHARS = 4e3;
+function isNoiseMessage(content) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return true;
+  if (trimmed.length < 4) return true;
+  return NOISE_PATTERNS.some((p) => p.test(trimmed));
+}
+function isGenericAssistantMessage(content) {
+  const trimmed = content.trim();
+  if (trimmed.length > 200) return false;
+  return GENERIC_ASSISTANT_PATTERNS.some((p) => p.test(trimmed));
+}
+function stripNoiseFromContent(content) {
+  let result = content;
+  for (const pattern of NOISE_FRAGMENTS) {
+    result = result.replace(pattern, "");
+  }
+  return result.trim();
+}
+function filterMessagesForExtraction(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  const filtered = [];
+  for (const msg of messages) {
+    let content = stripNoiseFromContent(msg.content);
+    if (isNoiseMessage(content)) continue;
+    if (msg.role === "assistant" && isGenericAssistantMessage(content)) continue;
+    if (content.length > MAX_MESSAGE_CHARS) {
+      content = `${content.slice(0, MAX_MESSAGE_CHARS)}\u2026[truncated]`;
+    }
+    const key = `${msg.role}:${content}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    filtered.push({ role: msg.role, content });
+  }
+  return filtered;
+}
+
+// src/hooks/index.ts
+function registerLifecycleHooks(api, client, config) {
+  if (config.autoRecall) {
+    api.on(
+      "before_prompt_build",
+      async (event, ctx) => {
+        try {
+          if (isNonInteractiveTrigger(ctx?.trigger, ctx?.sessionKey)) return;
+          if (isSubagentSession(ctx?.sessionKey)) return;
+          const recallQuery = pickRecallQuery(event);
+          if (!recallQuery || recallQuery.length < 5) return;
+          const result = await client.query({
+            query: recallQuery,
+            mode: config.queryMode,
+            top_k: config.topK
+          });
+          if (!result.answer) return;
+          const memoryContext = formatRecallContext(result);
+          api.logger.debug?.(
+            `mind auto-recall: injected ${result.sources?.length ?? 0} sources`
+          );
+          return { prependContext: memoryContext };
+        } catch (err) {
+          api.logger.warn(`mind auto-recall failed: ${err.message}`);
+          return;
+        }
+      }
+    );
+  }
+  if (config.autoCapture) {
+    api.on(
+      "agent_end",
+      async (event, ctx) => {
+        try {
+          if (isNonInteractiveTrigger(ctx?.trigger, ctx?.sessionKey)) return;
+          if (isSubagentSession(ctx?.sessionKey)) return;
+          if (!event.success) return;
+          const messages = event.messages ?? [];
+          const normalized = messages.filter(
+            (m) => typeof m.role === "string" && typeof m.content === "string"
+          ).map((m) => ({ role: m.role, content: m.content }));
+          const filtered = filterMessagesForExtraction(normalized);
+          if (filtered.length === 0) return;
+          const conversationText = filtered.map((m) => `${m.role.toUpperCase()}: ${m.content}`).join("\n\n").slice(0, 8e3);
+          await client.createEntry({
+            content: conversationText,
+            type: "entry",
+            tags: ["openclaw", "auto-capture"],
+            source: "openclaw-mind"
+          });
+          api.logger.debug?.("mind auto-capture: stored turn");
+        } catch (err) {
+          api.logger.warn(`mind auto-capture failed: ${err.message}`);
+        }
+      }
+    );
+  }
+}
+function pickRecallQuery(event) {
+  if (event.prompt) return event.prompt;
+  const messages = event.messages ?? [];
+  const lastUser = [...messages].reverse().find((m) => m.role === "user");
+  return typeof lastUser?.content === "string" ? lastUser.content : void 0;
+}
+function formatRecallContext(result) {
+  const sourceList = (result.sources ?? []).slice(0, 5).map((s, i) => `${i + 1}. ${s.title ?? "(untitled)"}`).join("\n");
+  return [
+    "## Persistent Memory (MIND knowledge graph)",
+    "",
+    "Context retrieved from the user's MIND knowledge graph based on the current request. Use it to inform your response.",
+    "",
+    result.answer,
+    sourceList ? `
+**Sources:**
+${sourceList}` : ""
+  ].join("\n");
+}
+
+// src/index.ts
+var SETUP_MESSAGE = [
+  "openclaw-mind: MIND_API_KEY not configured. Memory features are disabled.",
+  "  To set up:",
+  "    1. Get a key at https://www.m-i-n-d.ai \u2192 Settings \u2192 Developer",
+  "    2. Run: openclaw mind init --api-key mind_your_key_here",
+  "  Or set MIND_API_KEY in your environment."
+].join("\n");
+var index_default = definePluginEntry({
+  id: "openclaw-mind",
+  name: "MIND",
+  description: "MIND personal knowledge graph for OpenClaw \u2014 true KG, 50+ AI models, MINDsense emotional intelligence, life management, CRM. The most complete memory plugin for AI agents.",
+  kind: "memory",
+  register(api) {
+    const cfg = resolveConfig(api.pluginConfig);
+    if (cfg.needsSetup) {
+      api.logger.warn(SETUP_MESSAGE);
+      registerCliCommands(api, null, cfg);
+      api.registerService({
+        id: "openclaw-mind",
+        start: () => {
+          api.logger.info("openclaw-mind: waiting for API key configuration");
+        }
+      });
+      return;
+    }
+    const client = new MindClient({
+      apiKey: cfg.apiKey,
+      baseUrl: cfg.baseUrl,
+      logger: api.logger
+    });
+    registerAllTools(api, client, cfg);
+    registerCliCommands(api, client, cfg);
+    if (cfg.autoRecall || cfg.autoCapture) {
+      registerLifecycleHooks(api, client, cfg);
+    }
+    api.registerService({
+      id: "openclaw-mind",
+      start: () => {
+        api.logger.info(
+          `openclaw-mind v0.1.0 ready \u2014 autoRecall=${cfg.autoRecall} autoCapture=${cfg.autoCapture} baseUrl=${cfg.baseUrl}`
+        );
+      }
+    });
+  }
+});
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.js.map