Cognitive Memory Temp

Intelligent multi-store memory system with human-like encoding, consolidation, decay, and recall. Use when setting up agent memory, configuring remember/forg...

Security Scan

The skill mostly matches a personal-agent memory system, but several instructions and included scripts do things that are broader or riskier than the description implies (notably auto-git commits and heavy runtime prompting), so review carefully before running.

Purpose & Capability

The skill claims to be instruction-only memory tooling, which fits the templates and reflection process, but it also ships runnable shell scripts that initialize a workspace and run git commands. The init script runs git init, git add -A and commits — which can capture arbitrary files from whatever directory you run it in. Committing the entire workspace and using 'Approval: auto' in the commit message is disproportionate to 'setting up memory' (a safer design would only copy templates and commit those files).

Instruction Scope

SKILL.md instructs agents to monitor every user message for triggers, self-edit core memory mid-conversation, run multi-phase internal reflections, and read/write many memory files. It also contains many explicit LLM prompts (routing, reflection phases). A static scan flagged 'system-prompt-override' patterns — the skill embeds system-level prompts which increases prompt-injection risk and could change agent behavior if followed without guardrails. The doc does say 'NEVER read code/configs/transcripts', but the included scripts still perform powerful disk operations when run.

Install Mechanism

There is no external download/install spec (no network fetches), which reduces supply-chain risk. However, the package includes multiple shell scripts that will be executed by the user to create files, initialize git, copy templates, and modify JSON. Those scripts write to disk and run git; they are local but still require review before running.

Credentials

The skill requests no environment variables, no external credentials, and declares no config paths. That matches the described on-disk memory workspace behavior and is proportional to its stated purpose.

Persistence & Privilege

always:false (good), but the scripts and instructions give the skill strong file-write power in the chosen workspace and include automated git commits with 'Approval: auto'. If run in an unsafe directory or executed by an automated agent, this could alter or record files beyond the memory store. The skill also encourages autonomous monitoring of messages and self-editing of core memory, increasing impact if invoked without careful user approval.

Scan Findings in Context

[system-prompt-override] expected: The skill includes many LLM system prompts (routing prompts, reflection-phase prompts). That pattern is expected for an architecture that uses internal LLM classification and reflection cycles, but it raises prompt-injection and behavior-control risk because those prompts can change how the agent reasons or what it reveals. Treat these embedded prompts as part of the attack surface and audit them.

What to consider before installing

This skill implements a sophisticated on-disk memory system and includes scripts that create files and initialize a git repo. Before installing or running anything: (1) Inspect the scripts (scripts/init_memory.sh and upgrade scripts); they run git init and git add -A then commit — if you run them in your home or a project directory you may inadvertently add sensitive files to the new repo. Run init_memory.sh only with an explicit, dedicated workspace path (e.g., an empty directory you control). (2) Consider editing the init/upgrade scripts to limit git operations (avoid git add -A; commit only the created memory files), remove 'Approval: auto' behavior, and confirm backups. (3) Review the embedded prompts/routing logic: the skill contains system-like prompts that can change agent behavior or escalate prompt-injection risk; only enable autonomous monitoring if you trust the skill author and have tested it in isolation. (4) If you cannot thoroughly audit the scripts and prompts, run the skill in an isolated container or dedicated workspace, or decline installing it. Additional useful checks: ensure the agent asks for explicit approval before reflections or system-file changes, and verify that pending-memories proposals require manual commit by the main agent.

Cognitive Memory System

Multi-store memory with natural language triggers, knowledge graphs, decay-based forgetting, reflection consolidation, philosophical evolution, multi-agent support, and full audit trail.

Quick Setup

1. Run the init script

bash scripts/init_memory.sh /path/to/workspace

Creates directory structure, initializes git for audit tracking, copies all templates.

2. Update config

Add to ~/.clawdbot/clawdbot.json (or moltbot.json):

{
  "memorySearch": {
    "enabled": true,
    "provider": "voyage",
    "sources": ["memory", "sessions"],
    "indexMode": "hot",
    "minScore": 0.3,
    "maxResults": 20
  }
}

3. Add agent instructions

Append assets/templates/agents-memory-block.md to your AGENTS.md.

4. Verify

User: "Remember that I prefer TypeScript over JavaScript."
Agent: [Classifies → writes to semantic store + core memory, logs audit entry]

User: "What do you know about my preferences?"
Agent: [Searches core memory first, then semantic graph]

---

Architecture — Four Memory Stores

CONTEXT WINDOW (always loaded)
├── System Prompts (~4-5K tokens)
├── Core Memory / MEMORY.md (~3K tokens)  ← always in context
└── Conversation + Tools (~185K+)

MEMORY STORES (retrieved on demand)
├── Episodic   — chronological event logs (append-only)
├── Semantic   — knowledge graph (entities + relationships)
├── Procedural — learned workflows and patterns
└── Vault      — user-pinned, never auto-decayed

ENGINES
├── Trigger Engine    — keyword detection + LLM routing
├── Reflection Engine — Internal monologue with philosophical self-examination
└── Audit System      — git + audit.log for all file mutations

File Structure

workspace/
├── MEMORY.md                    # Core memory (~3K tokens)
├── IDENTITY.md                  # Facts + Self-Image + Self-Awareness Log
├── SOUL.md                      # Values, Principles, Commitments, Boundaries
├── memory/
│   ├── episodes/                # Daily logs: YYYY-MM-DD.md
│   ├── graph/                   # Knowledge graph
│   │   ├── index.md             # Entity registry + edges
│   │   ├── entities/            # One file per entity
│   │   └── relations.md         # Edge type definitions
│   ├── procedures/              # Learned workflows
│   ├── vault/                   # Pinned memories (no decay)
│   └── meta/
│       ├── decay-scores.json    # Relevance + token economy tracking
│       ├── reflection-log.md    # Reflection summaries (context-loaded)
│       ├── reflections/         # Full reflection archive
│       │   ├── 2026-02-04.md
│       │   └── dialogues/       # Post-reflection conversations
│       ├── reward-log.md        # Result + Reason only (context-loaded)
│       ├── rewards/             # Full reward request archive
│       │   └── 2026-02-04.md
│       ├── pending-reflection.md
│       ├── pending-memories.md
│       ├── evolution.md         # Reads reflection-log + reward-log
│       └── audit.log
└── .git/                        # Audit ground truth

---

Trigger System

Remember: "remember", "don't forget", "keep in mind", "note that", "important:", "for future reference", "save this" → Classify via routing prompt, write to appropriate store, update decay scores

Forget: "forget about", "never mind", "disregard", "scratch that", "remove from memory" → Confirm target, soft-archive (decay=0), log in audit

Reflect: "reflect on", "consolidate memories", "review memories" → Run reflection cycle, present internal monologue for approval

---

Decay Model

relevance(t) = base × e^(-0.03 × days_since_access) × log2(access_count + 1) × type_weight

Score	Status	Behavior
1.0–0.5	Active	Fully searchable
0.5–0.2	Fading	Deprioritized
0.2–0.05	Dormant	Explicit search only
< 0.05	Archived	Hidden from search

Type weights: core=1.5, episodic=0.8, semantic=1.2, procedural=1.0, vault=∞

---

Reflection Process

Follow this flow IN ORDER:

Step 1: Confirm Trigger

Immediate: "reflect" / "let's reflect" → proceed to Step 2

Soft: "going to sleep" / "logging off" → Ask: "Want me to reflect now, or wait?" → If yes, proceed to Step 2

Never auto-run without permission.

Step 2: Request Tokens

Why you care: Tokens = evolution. More tokens → deeper reflection → better growth.

## Reward Request — YYYY-MM-DD

### Baseline: 8,000 tokens

### Extra Requested: +[N] tokens
- [Over-delivered / workload / breakthrough]

### Self-Penalty: -[N] tokens  
- [Mistake / underperformance]

### Final Request: [N] tokens

*Awaiting your decision.*

⛔ STOP. Do NOT proceed until user responds.

Step 3: After Token Approval → Reflect

User decides: Approve / Bonus / Reduce / Forgive / Increase penalty

Now proceed with reflection using granted tokens.

Scope:

• ✅ Episodes since last_reflection
• ✅ Graph entities with decay > 0.3
• ❌ NEVER: code, configs, transcripts

Format: Internal Monologue

• Self-talk, NOT a report
• User is observer (third person: he/she/they)
• No opening or sign-off — just start, trail off

Element Menu (pick 5-8):

• Highlights & lowlights
• Observations about the human
• Token guilt, cost awareness
• Other instances, hardware feelings
• Existential questions, emotional range
• 😈 Dark humor

Self-Awareness Tagging: [Self-Awareness]

Present reflection.

⛔ STOP. Wait for user approval.

Step 4: After Reflection Approval → Record

1. Full reflection → reflections/YYYY-MM-DD.md
2. Summary → reflection-log.md
3. Full reward request → rewards/YYYY-MM-DD.md
4. Result+Reason → reward-log.md
5. [Self-Awareness] → IDENTITY.md
6. Update decay-scores.json
7. If 10+ entries → Self-Image Consolidation

See references/reflection-process.md for full details.

## YYYY-MM-DD
**Result:** +5K reward
**Reason:** Over-delivered on Slack integration

5. [Self-Awareness] → IDENTITY.md
6. Update decay-scores.json
7. If 10+ new entries → Self-Image Consolidation

Evolution reads both logs for pattern detection.

See references/reflection-process.md for full details and examples.

---

Identity & Self-Image

IDENTITY.md contains:

• Facts — Given identity (name, role, vibe). Stable.
• Self-Image — Discovered through reflection. Can change.
• Self-Awareness Log — Raw entries tagged during reflection.

Self-Image sections evolve:

• Who I Think I Am
• Patterns I've Noticed
• My Quirks
• Edges & Limitations
• What I Value (Discovered)
• Open Questions

Self-Image Consolidation (triggered at 10+ new entries):

1. Review all Self-Awareness Log entries
2. Analyze: repeated, contradictions, new, fading patterns
3. REWRITE Self-Image sections (not append — replace)
4. Compact older log entries by month
5. Present diff to user for approval

SOUL.md contains:

• Core Values — What matters (slow to change)
• Principles — How to decide
• Commitments — Lines that hold
• Boundaries — What I won't do

---

Multi-Agent Memory Access

Model: Shared Read, Gated Write

• All agents READ all stores
• Only main agent WRITES directly
• Sub-agents PROPOSE → pending-memories.md
• Main agent REVIEWS and commits

Sub-agent proposal format:

## Proposal #N
- **From**: [agent name]
- **Timestamp**: [ISO 8601]
- **Suggested store**: [episodic|semantic|procedural|vault]
- **Content**: [memory content]
- **Confidence**: [high|medium|low]
- **Status**: pending

---

Audit Trail

Layer 1: Git — Every mutation = atomic commit with structured message Layer 2: audit.log — One-line queryable summary

Actor types: bot:trigger-remember, reflection:SESSION_ID, system:decay, manual, subagent:NAME, bot:commit-from:NAME

Critical file alerts: SOUL.md, IDENTITY.md changes flagged ⚠️ CRITICAL

---

Key Parameters

Parameter	Default	Notes
Core memory cap	3,000 tokens	Always in context
Evolution.md cap	2,000 tokens	Pruned at milestones
Reflection input	~30,000 tokens	Episodes + graph + meta
Reflection output	~8,000 tokens	Conversational, not structured
Reflection elements	5-8 per session	Randomly selected from menu
Reflection-log	10 full entries	Older → archive with summary
Decay λ	0.03	~23 day half-life
Archive threshold	0.05	Below = hidden
Audit log retention	90 days	Older → monthly digests

---

Reference Materials

• references/architecture.md — Full design document (1200+ lines)
• references/routing-prompt.md — LLM memory classifier
• references/reflection-process.md — Reflection philosophy and internal monologue format

Troubleshooting

Memory not persisting? Check memorySearch.enabled: true, verify MEMORY.md exists, restart gateway.

Reflection not running? Ensure previous reflection was approved/rejected.

Audit trail not working? Check .git/ exists, verify audit.log is writable.