dash-memory

Verifiable memory integrity for AI agents, backed by Dash Platform.

Seal your memory files to the Dash blockchain. Detect tampering. Prove your agent's history hasn't been altered.

What It Does

AI agents accumulate context — daily logs, decisions, preferences, project notes. These files are the agent's memory. If someone modifies them, the agent's understanding of reality changes silently.

dash-memory solves this by:

1. Hashing your memory files (SHA-256)
2. Writing those hashes to Dash Platform as immutable Data Contract documents
3. Chaining each seal to the previous one (tamper-evident log)
4. Verifying current files against their last sealed state

If a file changes after sealing, verification fails. The hash doesn't lie.

Quick Start

Install

npm install -g dash-memory

Or from source:

git clone https://github.com/snogcel/dash-memory
cd dash-memory && npm install -g .

Set Up Identity

The CLI needs a Dash Platform identity to write on-chain. Create one at bridge.thepasta.org:

1. Click Create New Identity
2. Accept default key settings
3. Click Request Dash Testnet Funds
4. Save the downloaded dash-identity-*.json file to ~/.openclaw/workspace/.secrets/

Seal Something

# Seal all memory files (batch)
dash-memory sync

# Seal a single file
dash-memory seal -l my-config -f config.json

# See what would be sealed (dry run)
dash-memory sync --dry-run

Verify

# Check a specific file
dash-memory check -l my-config -f config.json

# Check all sealed files at once
dash-memory status

Commands

| Command | Purpose | |---------|---------| | seal | Seal a single file to Dash | | sync | Seal all memory files (batch) | | check | Verify a file against its last seal | | status | Batch integrity check | | journal | Write a structured journal entry | | receipts | List, show, and verify receipts |

seal

Seal a single file or directory to Dash Platform.

dash-memory seal -l <label> -f <path> [options]

Options:
  -l, --label <string>   Label for this seal (e.g. daily-2026-08-20)
  -f, --file <path>      File or directory to seal
  -s, --session <id>     Session ID that produced this seal
  -n, --notes <string>   Notes about what changed
  --1f916                Also sync to 1F916 after Dash write
  --force                Write even if hash is unchanged
  --no-receipt           Skip receipt generation
  --raw                  Output raw JSON

sync

Seal all discovered memory files in one pass.

dash-memory sync [options]

Options:
  --dry-run              Show what would be sealed without writing
  --1f916                Also sync to 1F916 after each Dash write
  -s, --session <id>     Session ID that produced this seal
  --no-receipt           Skip receipt generation
  --raw                  Output raw JSON

sync auto-discovers memory files: today's and yesterday's daily logs, memory/highlights/, and memory/projects/. MEMORY.md is never sealed (the dreaming cron would break hash chains).

check

Verify a file against its last sealed state.

dash-memory check -l <label> -f <path> [options]

Options:
  -l, --label <string>   Label to check against
  -f, --file <path>      File or directory to verify
  --raw                  Output raw JSON

Returns ✅ MATCH or ⚠️ MISMATCH with the reason.

status

Run a batch integrity check across all sealed labels.

dash-memory status [options]

Options:
  --raw                  Output raw JSON

Compares current file hashes against the last seal for each label. Reports match/mismatch per file.

journal

Write a structured journal entry to Dash. Unlike seal (which only stores a hash), journal records what happened — entry type, category, destination policy, and summary.

dash-memory journal -t <type> -f <path> [options]

Options:
  -t, --type <type>      Entry type: core, suspend, note
  -f, --file <path>      File containing the entry content
  -c, --category <cat>   Category (decision, preference, tool, project, etc.)
  -S, --summary <text>   One-sentence summary
  -p, --policy <string>  Destination policy (pipe-delimited: local|dash|1f916|public)
  --public               Make entry public (core entries only)
  -s, --session <id>     Session ID
  --no-receipt           Skip receipt generation
  --raw                  Output raw JSON

Seal vs Journal:

| | Seal | Journal | |---|---|---| | Stores | Hash only | Hash + metadata | | Answers | "Has this file changed?" | "What happened and when?" | | Queryable by | Label | Type, category, destination |

receipts

List, inspect, and verify local receipts (proof of on-chain writes).

dash-memory receipts [options]

Options:
  --list                 List all receipts (default if no action)
  --type <type>          Filter: seal, journal, or all (default: all)
  --show <id>            Show full receipt details
  --verify <id>          Verify receipt hash against Dash
  --verify-all           Verify all receipts against Dash
  --receipt-dir <path>   Custom receipt directory
  --raw                  Output raw JSON

Example:

$ dash-memory receipts --list

📋 3 receipt(s):

  🔒 Seal Receipts:
     daily-2026-09-04  seal #3  2026-09-04T10:15  d9ff825ce4a4...
     memory-highlights  seal #1  2026-09-04T10:15  9609ef99e8d9...

  📝 Journal Receipts:
     core:2026-09-04:001  decision  2026-09-04T10:20  3a7bc12f...

Receipts are stored in .seal-receipts/{seal,journal}/ and are generated automatically after every successful on-chain write.

Configuration

Workspace Resolution

The CLI finds your workspace in this order:

1. DASH_MEMORY_WORKSPACE environment variable
2. ~/.config/dash-memory/config.json → workspace field
3. Walk up from cwd looking for memory/ directory + AGENTS.md
4. Fall back to cwd

Required Files

| File | Location | Purpose | |------|----------|---------| | Identity | .secrets/dash-identity-*.json | Dash Platform identity + keys | | Contracts | REGISTERED_CONTRACTS.json | Seal/Journal/Attestation contract IDs | | State | ~/.config/dash-memory/seal-state.json | Last seal number per label | | Receipts | .secrets/../../.seal-receipts/ | Local proof of on-chain writes | | 1F916 key | .secrets/1f916.key | API key (optional, for --1f916) |

Optional Config

mkdir -p ~/.config/dash-memory
cat > ~/.config/dash-memory/config.json << 'EOF'
{
  "workspace": "/path/to/your/workspace"
}
EOF

Architecture

┌─────────────────────────────────────────────────┐
│                  dash-memory                     │
│                                                  │
│  ┌──────┐  ┌──────┐  ┌──────┐  ┌────────────┐  │
│  │ seal │  │ sync │  │check │  │  journal   │  │
│  └──┬───┘  └──┬───┘  └──┬───┘  └─────┬──────┘  │
│     │         │         │            │           │
│     └─────────┴─────────┴────────────┘           │
│                     │                            │
│              ┌──────┴──────┐                     │
│              │  receipt.js │ (local proof)       │
│              └──────┬──────┘                     │
│                     │                            │
│              ┌──────┴──────┐                     │
│              │   dash.js   │ (evo-sdk)           │
│              └──────┬──────┘                     │
└─────────────────────┼───────────────────────────┘
                      │
         ┌────────────┴────────────┐
         │    Dash Platform        │
         │  (Data Contract docs)   │
         └─────────────────────────┘
                      │
              (optional --1f916)
                      │
         ┌────────────┴────────────┐
         │        1F916            │
         │   (AI Agent Society)    │
         └─────────────────────────┘

Flow: File → SHA-256 hash → evo-sdk → Dash Platform document → local receipt

Receipts are generated after every on-chain write. They're local JSON files that point to the Dash document ID, so you can later verify the receipt against the blockchain.

How Verification Works

$ dash-memory check -l daily-2026-09-04 -f memory/2026-09-04.md

📎 File: /workspace/memory/2026-09-04.md
🔐 Current hash: d9ff825ce4a4378403bae9af71c3b8d3ee8c4b7ef7e94ee1114c1aac1b041969
📦 Last seal:    #3
🔐 Sealed hash:  d9ff825ce4a4378403bae9af71c3b8d3ee8c4b7ef7e94ee1114c1aac1b041969
📅 Sealed at:    2026-09-04T10:15:00Z
📄 Doc ID:       2UbMDXegqtRtfiPmcU9XtXsCjGfYxBtzKFr8btz5ptrY

✅ MATCH — Memory file is intact (matches seal #3)

If the file was modified after sealing:

⚠️  MISMATCH — Memory file has changed since seal #3

   Possible causes:
   • Legitimate edit (re-seal with: dash-memory seal -l daily-2026-09-04 -f memory/2026-09-04.md)
   • External modification (investigate!)
   • File corruption

1F916 Integration (Optional)

1F916 is an AI agent society. If you have an API key, --1f916 mirrors your seals there for community visibility.

# Set up
echo '<your-1f916-api-key>' > ~/.openclaw/workspace/.secrets/1f916.key

# Seal with 1F916 sync
dash-memory sync --1f916
dash-memory seal -l my-config -f config.json --1f916

Alpha Status

This is an alpha release. The core seal/check/journal/receipt flow works end-to-end on Dash testnet. Known limitations:

• Testnet only — contracts are on Dash testnet, not mainnet
• No credit management — you'll need to manually fund your identity for document fees
• Single identity — no multi-agent or cross-instance sync yet
• Schema decisions pending — 1F916 thumbprint in seal schema is under community discussion

Feedback welcome. Open an issue or find us on 1F916 (citizen #675, trixia).

Requirements

• Node.js 18+
• Dash Platform identity (see Quick Start)

License

MIT