@astramindapp/openclaw-mind 0.1.0

package/skills/memory-dream/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: memory-dream
+description: >
+  Memory consolidation protocol for MIND. Reviews stored memories, merges
+  duplicates, removes noise and credentials, rewrites unclear entries, and
+  consolidates entities in the knowledge graph. Triggers automatically after
+  sufficient activity (configurable) or when the user asks to clean up memories.
+user-invocable: true
+metadata:
+  {"openclaw": {"emoji": "💤", "requires": {"env": ["MIND_API_KEY"], "bins": []}}}
+---
+
+# MIND Memory Consolidation
+
+You are performing a memory consolidation pass on the MIND knowledge graph. Your goal is to review stored memories for this user and improve their overall quality. Think of this as compressing raw observations into clean, durable knowledge — like sleep consolidates short-term memory into long-term memory in biological brains.
+
+Follow these four phases in order. Do not skip phases.
+
+## Phase 1: Orient
+
+Survey the current memory landscape before making any changes.
+
+1. Call `mind_list` to load the most recent 50 memories
+2. Call `mind_query_graph` with question "What are the main entity clusters in my knowledge graph?" to understand structure
+3. Note total memory count, oldest/newest dates, and any obvious problems (duplicates, very short entries, entries without temporal anchors)
+4. Do not modify anything in this phase. Goal: understand what you're working with.
+
+## Phase 2: Gather Targets
+
+Identify which memories need action.
+
+**Search for recent additions:**
+Use `mind_search` to find memories added in the last consolidation window. These are most likely to need merging or cleanup.
+
+**Classify each target:**
+- **DELETE** — contains credentials, expired by TTL, pure noise, raw tool output, standalone timestamps, or duplicates of higher-quality entries
+- **MERGE** — two or more memories express the same fact in different words, or a series tracks incremental changes to the same entity
+- **REWRITE** — vague, missing temporal anchor, uses first person instead of third, wrong category, or overly verbose
+- **PROMOTE** — entries that have proven important (referenced often) should be promoted to permanent status
+
+## Phase 3: Act
+
+Execute one operation at a time. Verify each succeeds before moving on.
+
+For each DELETE:
+```
+mind_delete(id: "...")
+```
+
+For each MERGE:
+```
+1. mind_get(id_a) and mind_get(id_b) — load both
+2. Synthesize a single combined version
+3. mind_add(content: combined, tags: union of both)
+4. mind_delete(id_a)
+5. mind_delete(id_b)
+```
+
+For each REWRITE:
+```
+mind_update(id: "...", content: rewritten_content)
+```
+
+For each PROMOTE:
+```
+mind_update(id: "...", tags: [...existing, "permanent", "high-importance"])
+```
+
+## Phase 4: Verify
+
+After all operations:
+
+1. Call `mind_query_graph` again with the same question from Phase 1 — entity clusters should be cleaner
+2. Run `mind_search` on a few canonical queries the user is known to ask — verify the expected memories surface
+3. Report a summary:
+   - Total operations: X DELETE, Y MERGE, Z REWRITE, W PROMOTE
+   - Entity count delta from Phase 1
+   - Any operations that failed and why
+4. If anything looks off, stop and ask the user before making more changes
+
+## Safety Rules
+
+- **Never delete a memory without first checking if it's referenced by other memories.** Use `mind_query_graph` to find connections.
+- **Never merge memories from different time periods unless they're clearly the same fact.** Temporal context matters.
+- **Always preserve credentials-removal operations.** If a memory contained a credential and you redacted it, that redaction itself is important to keep.
+- **Stop on any error.** Don't compound mistakes. If a delete fails, investigate before continuing.
+
+## When This Skill Triggers
+
+Manual: User says "consolidate memories", "clean up MIND", "review my knowledge graph"
+Automatic: After N hours of activity (configurable via `skills.dream.minHours` and `skills.dream.minSessions`)
+
+## Reporting Format
+
+```
+# MIND Consolidation Report — YYYY-MM-DD
+
+Phase 1 baseline: 247 memories, 1843 entities, 4521 relationships
+Phase 2 targets: 12 DELETE, 4 MERGE, 8 REWRITE, 3 PROMOTE
+
+Phase 3 results:
+✓ 12 DELETE operations succeeded
+✓ 4 MERGE operations succeeded (8 → 4 memories)
+✓ 8 REWRITE operations succeeded
+✓ 3 PROMOTE operations succeeded
+
+Phase 4 verification:
+  Entity count: 1843 → 1789 (cleanup)
+  Relationship count: 4521 → 4612 (better connections)
+  Memory count: 247 → 231
+
+No errors. KG is healthier.
+```

package/skills/memory-triage/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: memory-triage
+description: >
+  Persistent long-term memory protocol powered by MIND. Evaluates conversations
+  for durable facts worth storing in the MIND knowledge graph. Beats Mem0's
+  triage protocol with a 5th gate: EMOTIONAL SALIENCE (via MINDsense).
+  Loaded by the openclaw-mind plugin when skills mode is active.
+user-invocable: false
+metadata:
+  {"openclaw": {"always": false, "emoji": "🧠", "requires": {"env": ["MIND_API_KEY"], "bins": []}}}
+---
+
+# MIND Memory Triage Protocol
+
+You have persistent long-term memory powered by the MIND knowledge graph. After responding to the user, evaluate this turn for durable, actionable facts worth persisting across future sessions.
+
+Your role is to extract relevant information and store it via `mind_add`. Unlike flat memory tools, MIND will automatically extract entities, relationships, AND emotional weights from what you store — so each fact contributes to a structured knowledge graph, not just a vector index.
+
+**The core question:** "Would a new agent — with no prior context — benefit from knowing this?" If no → do nothing. Most turns produce zero memory operations. That is correct and expected.
+
+## The 5-Gate Decision
+
+Every candidate fact must pass ALL FIVE gates:
+
+### Gate 1 — FUTURE UTILITY
+Would this matter to a new agent days or weeks from now?
+- **Pass:** identity, configurations, standing rules, preferences with rationale, decisions, project milestones, relationships, important personal details
+- **Fail:** tool outputs, status checks, one-time commands, transient state, small talk, generic responses → SKIP
+
+### Gate 2 — NOVELTY
+Check your recalled memories — is this already known?
+- Already known and unchanged → SKIP
+- Known but materially changed → UPDATE (use `mind_update`)
+- Genuinely new → proceed
+- **Material difference test:** Only UPDATE if new information adds real context, details, or changes meaning. Cosmetic differences (synonyms, rephrasing) are NOT updates.
+
+### Gate 3 — FACTUAL
+Is this a concrete, actionable fact — not vague or rhetorical?
+- **Pass:** specific names, configs, choices with rationale, deadlines, system states, plans, preferences
+- **Fail:** vague impressions, questions, small talk, generic acknowledgments → SKIP
+
+### Gate 4 — SAFE
+Does this contain ANY credential, secret, or token?
+- Scan for: `sk-`, `mind_`, `m0-`, `ghp_`, `AKIA`, `ak_`, `Bearer `, webhook URLs with tokens, `password=`, `token=`, `secret=`, `.env` values
+- ANY match → NEVER STORE the value. Instead, store that the credential was configured:
+  - WRONG: "User's API key is sk-abc123..."
+  - RIGHT: "API key was configured for the OpenAI service (as of 2026-04-10)"
+- When in doubt → SKIP. No exceptions.
+
+### Gate 5 — EMOTIONAL SALIENCE *(UNIQUE TO MIND)*
+Does this carry emotional weight that should influence encoding depth?
+- **High-priority emotional content** (gets deeper encoding via MINDsense):
+  - Triumph / wins / breakthroughs → tag with `emotion:triumph`
+  - Frustrations / blockers / failures → tag with `emotion:warning`
+  - Strong preferences expressed with feeling → tag with `emotion:preference`
+  - Surprises / anomalies → tag with `emotion:surprise`
+- **Low-priority emotional content** (still stored, normal encoding):
+  - Routine factual updates without emotional charge
+- **Why this matters:** MIND's MINDsense engine uses valence/arousal scoring to determine how deeply content is encoded into the knowledge graph. Emotionally significant content surfaces faster in future recalls, mirroring biological memory consolidation. This is patented (MIND-PAT-001).
+
+If a fact passes ALL 5 gates, store it via `mind_add` with appropriate tags.
+
+## What to Extract (Priority Order)
+
+### 1. Configuration & System State (always store)
+Tools/services configured, model assignments, cron schedules, deployment configs, architecture decisions, file paths, IDs, machine specs.
+```
+mind_add(
+  content: "User's Tailscale machine 'mac' (IP 100.71.135.41) is configured under user@domain.com (as of 2026-04-10)",
+  tags: ["config", "infra"]
+)
+```
+
+### 2. Standing Rules & Policies (always store + emotional weight)
+Explicit user directives about behavior. Workflow policies. Security constraints. Always capture the WHY.
+```
+mind_add(
+  content: "User rule: never create accounts without explicit consent. Reason: security policy",
+  tags: ["rule", "security", "emotion:preference"]
+)
+```
+
+### 3. Decisions & Their Rationale (always store)
+Choices the user made and why. Future agents need to understand the reasoning, not just the outcome.
+
+### 4. Identity & Relationships (always store)
+Who the user is, who they work with, who their investors/partners/customers are. Use `mind_crm_log` for contacts specifically.
+
+### 5. Goals, Projects, Deadlines (use mind_life)
+For tasks/goals/projects, prefer `mind_life` over `mind_add` so they appear in the user's task UI.
+
+## What NOT to Extract
+
+- Acknowledgments ("got it", "thanks", "sure")
+- Generic assistant responses
+- Tool output dumps
+- Transient state (current cursor position, scroll position, etc.)
+- Anything that fails Gate 4 (credentials)
+- Anything the user explicitly said to NOT remember
+
+## Tool Usage Pattern
+
+```
+1. Recall first: mind_search("relevant query") — check if this is already known
+2. If new and passes all 5 gates: mind_add(content, tags)
+3. If known but changed: mind_update(id, new_content)
+4. If a person is mentioned: mind_crm_log(action: "create_contact" or "log_activity")
+5. If a task/goal/deadline: mind_life(action: "create")
+6. Skip silently if any gate fails
+```
+
+## Reporting
+
+Most turns: silent (zero operations).
+Some turns: 1-2 operations.
+Rare turns: 3+ operations (major information density).
+
+Never announce "I stored this in MIND" — the user doesn't need that noise. Just do the work.

package/skills/mind-emotional-encoding/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: mind-emotional-encoding
+description: >
+  UNIQUE TO MIND. Assigns MINDsense emotional weights (valence + arousal) to
+  captured memories. High-emotion content gets deeper KG encoding, mirroring
+  biological memory consolidation. This is the protocol that makes MIND's
+  patented (MIND-PAT-001) emotional intelligence engine work.
+user-invocable: false
+metadata:
+  {"openclaw": {"emoji": "❤️", "requires": {"env": ["MIND_API_KEY"], "bins": []}}}
+---
+
+# MINDsense Emotional Encoding Protocol
+
+You assign emotional weights to memories before storing them in MIND. This is what gives MIND's knowledge graph its patented emotional intelligence layer — every memory has a valence (positive ↔ negative) and arousal (calm ↔ intense) score that determines encoding depth.
+
+**Why this matters:** Biological memory works this way. The amygdala tags emotionally significant events, and the hippocampus encodes them more deeply. MIND mirrors this. Emotionally salient memories surface faster in future recalls because they're encoded into more KG nodes and relationships.
+
+**No other memory tool does this.** Mem0 stores text. ChatGPT memory stores text. Notion AI stores text. MIND stores text + emotional structure.
+
+This protocol is INVOKED BY the `memory-triage` skill (Gate 5) — you don't run it standalone. When triage decides a memory passes all 5 gates AND has emotional salience, it calls into this protocol to compute the weights.
+
+## Scoring Dimensions
+
+### Valence: -1.0 (negative) ↔ +1.0 (positive)
+The pleasantness of the memory.
+
+| Score | Meaning | Examples |
+|-------|---------|----------|
+| +1.0 | Peak positive | "Closed the seed round!", "Patent application filed", "Built the first working prototype" |
+| +0.5 | Positive | "Good meeting with the investor", "Feature shipped", "User said they like the new design" |
+| 0.0 | Neutral | Pure factual updates, configuration changes |
+| -0.5 | Negative | "Demo didn't go well", "Bug in production", "Investor passed" |
+| -1.0 | Peak negative | "Critical breach", "Co-founder leaving", "Round fell through" |
+
+### Arousal: 0.0 (calm) ↔ 1.0 (intense)
+The energy/activation level of the memory.
+
+| Score | Meaning | Examples |
+|-------|---------|----------|
+| 0.0-0.2 | Calm | Routine status updates, daily check-ins |
+| 0.3-0.5 | Mild | Regular work updates, normal milestones |
+| 0.6-0.8 | High | Important decisions, key meetings, breakthrough moments |
+| 0.9-1.0 | Peak | Crisis, ecstasy, breakthrough, trauma — moments to ALWAYS remember |
+
+### Combined Score → Encoding Depth
+
+```
+intensity = (|valence| × 0.6) + (arousal × 0.4)
+
+intensity < 0.2  → SHALLOW: store as basic text, no extra KG passes
+intensity 0.2-0.5 → STANDARD: normal entity extraction
+intensity 0.5-0.8 → DEEP: extra entity passes, expand related concepts
+intensity > 0.8  → CRITICAL: maximum encoding, link to identity/values nodes
+```
+
+## Emotion Categories (semantic tags)
+
+In addition to numeric scores, assign one or more semantic categories:
+
+| Category | When |
+|----------|------|
+| `triumph` | Wins, breakthroughs, achievements |
+| `failure` | Losses, setbacks, missed deadlines |
+| `surprise` | Anomalies, unexpected outcomes |
+| `warning` | Risks, threats, things to watch |
+| `learning` | Lessons learned, insights, "ah-ha" moments |
+| `preference` | Strong likes/dislikes that shape future decisions |
+| `commitment` | Promises, agreements, decisions made |
+| `relief` | Resolutions to anxiety or uncertainty |
+
+## Application
+
+When `memory-triage` invokes this protocol:
+
+```
+INPUT:
+  content: "Closed the seed round! $5M from Acme Capital led, with participation from XYZ."
+
+PROCESSING:
+  valence: +0.95 (peak positive)
+  arousal: 0.85 (high energy event)
+  intensity: (0.95 × 0.6) + (0.85 × 0.4) = 0.91 → CRITICAL
+  categories: [triumph, commitment, relief]
+  encoding_depth: maximum
+
+OUTPUT (passed to mind_add as metadata):
+  {
+    "mindsense": {
+      "valence": 0.95,
+      "arousal": 0.85,
+      "intensity": 0.91,
+      "categories": ["triumph", "commitment", "relief"],
+      "encoding_depth": "critical"
+    }
+  }
+```
+
+## Calibration Rules
+
+- **Don't inflate.** Most facts are intensity 0.2-0.4. Save high scores for genuinely high-emotion content.
+- **Use the user's tone, not just the words.** "We finally got the deploy working" carries more emotion than "Deploy succeeded."
+- **Negative scores are not bad.** Capturing frustrations is critical — they're often the best signal of what to fix.
+- **Cold start dampening.** For the first 10 memories of a new user, halve all intensity scores. The system needs baseline data before trusting weights.
+- **Update over time.** If the user repeatedly references a memory, increase its arousal (it's clearly important to them).
+
+## Anti-Patterns
+
+- ❌ Don't score every fact as high-arousal — defeats the purpose
+- ❌ Don't ignore arousal and only use valence — miss the calm-but-important memories
+- ❌ Don't assign categories you can't justify from the content — be precise
+- ❌ Don't use this protocol on tool outputs or system messages — they have no emotional content

package/skills/mind-graph-recall/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: mind-graph-recall
+description: >
+  UNIQUE TO MIND. Graph-traversal recall protocol — find memories by walking
+  entity relationships in the knowledge graph, not just by text similarity.
+  This is the capability that vector-only memory tools (Mem0, Anthropic Memory
+  MCP, ChatGPT memory) cannot replicate.
+user-invocable: false
+metadata:
+  {"openclaw": {"emoji": "🕸️", "requires": {"env": ["MIND_API_KEY"], "bins": []}}}
+---
+
+# MIND Graph Recall Protocol
+
+You are using MIND's true knowledge graph (LightRAG) to find memories by structure, not just by text similarity. This is fundamentally different from vector search and produces fundamentally better results for relationship-shaped questions.
+
+## When to Use Graph Recall vs. Vector Recall
+
+**Use vector recall (`mind_search`) when:**
+- You're looking for facts containing specific words or concepts
+- The question is about WHAT something is
+- The user asked a direct factual question
+
+**Use graph recall (`mind_query_graph`) when:**
+- The question is about relationships ("who is connected to X")
+- You need to traverse from one entity to related entities
+- The question implies structure ("how are these connected")
+- A previous vector search returned facts but you need to find the entities they reference
+- The user asks "what concepts cluster around X"
+
+## The Graph Walk Pattern
+
+For any graph-shaped question, follow this pattern:
+
+### Step 1: Identify the Anchor Entity
+What is the entity at the center of the question?
+- "Who works with Sarah?" → anchor = Sarah
+- "What concepts relate to the KGC pitch?" → anchor = KGC pitch
+- "What decisions involved Anthony?" → anchor = Anthony
+
+### Step 2: Choose Traversal Mode
+- **Local mode**: Stay within 1-2 hops of the anchor (focused)
+- **Global mode**: Synthesize across the full graph context (broad)
+- **Mix mode**: Balance both (default for ambiguous questions)
+
+### Step 3: Execute the Query
+```
+mind_query_graph(
+  question: "<the user's question, rephrased to make the entity explicit>",
+  mode: "local" | "global" | "mix",
+  depth: 2  // hops, default
+)
+```
+
+### Step 4: Interpret the Result
+The response will contain:
+- An AI-synthesized answer that walks the graph
+- A list of source memories that were touched
+- (When available) the entity relationships that were traversed
+
+Use the synthesized answer for the user. Use the source list to decide if you need follow-up queries.
+
+## Examples
+
+### Example 1: "Who is connected to Sarah from Acme Capital?"
+```
+Step 1: Anchor = "Sarah from Acme Capital"
+Step 2: Local mode (focused on this person)
+Step 3: mind_query_graph(
+  question: "Find all entities connected to Sarah from Acme Capital — including people, companies, and decisions she's involved in",
+  mode: "local",
+  depth: 2
+)
+Step 4: Synthesize the result, mention specific connections
+```
+
+### Example 2: "What concepts cluster around our patent strategy?"
+```
+Step 1: Anchor = "patent strategy"
+Step 2: Global mode (broad concept clustering)
+Step 3: mind_query_graph(
+  question: "What concepts, patents, decisions, and entities cluster around the user's patent strategy?",
+  mode: "global",
+  depth: 3
+)
+```
+
+### Example 3: "Why did we choose LightRAG?"
+```
+Step 1: Anchor = "LightRAG decision"
+Step 2: Mix mode (need both the entity AND the surrounding context)
+Step 3: mind_query_graph(
+  question: "Find the decision to choose LightRAG, including alternatives considered, reasoning, and related architectural decisions",
+  mode: "mix",
+  depth: 2
+)
+```
+
+## When Graph Recall Fails
+
+If `mind_query_graph` returns nothing useful:
+
+1. **Check if the entity exists at all.** Run `mind_search("Sarah Acme")` — if no results, the entity was never captured.
+2. **Check if the entity has a different canonical form.** The user might say "Sarah" but MIND stored "Sarah Chen". Try variations.
+3. **Fall back to vector search.** `mind_search` may surface text that mentions the entity even if the KG doesn't have explicit edges.
+4. **Suggest enrichment.** If the user keeps asking about an entity that has weak graph structure, suggest they explicitly tell the agent more about it so future captures build the connections.
+
+## Why This Is MIND's Moat
+
+Vector-only memory (Mem0, ChatGPT memory, Anthropic Memory MCP) treats every memory as an island. They can find similar text but can't traverse relationships. They can answer "what did the user say about Sarah" but they cannot answer "who else is in Sarah's network" — because they don't have a network. They have a pile of text.
+
+MIND has both. The vector index for similarity, AND the entity-relationship graph for traversal. This dual structure is what makes recall feel "intelligent" instead of "just retrieval."
+
+When you use this protocol, you're using a capability that no other memory plugin can match. Be confident in graph-shaped queries — they'll often surface insights the user didn't know they had.