"Which components do you want to deploy? I'll check prerequisites for all of them and then walk through each one.

Available components:

[A] Memory Stack — qmd (semantic search) + LosslessClaw (context compression)

[B] Memory Manager Skill — agent memory protocol (clawhub install)

[C] vid2md — video → structured Markdown converter

[D] WeChat Plugin — WeChat group chat integration

[E] Cron Jobs — automated memory maintenance

Reply with the letters you want (e.g. A B E), or all to deploy everything."

Wait for confirmation before proceeding.

Phase 0 — Prerequisites Check

Run these checks for all selected components. Report status in a table before proceeding.

# Core tools
which git && git --version
which python3 && python3 --version
which brew && brew --version
which ffmpeg && ffmpeg -version 2>&1 | head -1
which ollama && ollama --version

# OpenClaw
openclaw --version

# Node / bun (for qmd)
which node && node --version
which bun && bun --version
which npm && npm --version

Report as a table:

Tool	Status	Version
git	✅/❌	...
python3	✅/❌	...
brew	✅/❌	...
ffmpeg	✅/❌	...
ollama	✅/❌	...
openclaw	✅/❌	...
bun/node	✅/❌	...

If any required tool is missing, tell the user what to install and wait for confirmation before continuing:

brew: https://brew.sh
ffmpeg: brew install ffmpeg
ollama: https://ollama.com
bun: curl -fsSL https://bun.sh/install | bash

Phase A — Memory Stack

A1: Install qmd

# Check if already installed
which qmd && qmd --version

If not installed:

bun install -g @tobilu/qmd
# or: npm install -g @tobilu/qmd

Verify:

qmd --version
qmd status

A2: Create memory collections

Ask the user for their workspace path:

"What is your OpenClaw workspace path? (default: ~/.openclaw/workspace)"

Wait for answer, then substitute <WORKSPACE> below:

# Check existing collections
qmd collection list

Only add collections that don't already exist:

# Memory collection
qmd collection add memory-root <WORKSPACE>/memory --pattern "**/*.md"

# Blackboard collection
qmd collection add blackboard <WORKSPACE>/blackboard --pattern "**/*.md"

# Initial index build
qmd update
qmd status

Verify by running a test search:

qmd vsearch "project status" -c blackboard 2>/dev/null | head -5

A3: Configure openclaw.json

Check if qmd is already configured:

cat ~/.openclaw/openclaw.json | python3 -c "
import sys, json; d=json.load(sys.stdin)
print('already configured' if d.get('memory',{}).get('backend') == 'qmd' else 'not configured')
"

If not configured, show the user this config block to add to openclaw.json:

// Add to ~/.openclaw/openclaw.json
{
  "memory": {
    "backend": "qmd",
    "qmd": {
      "command": "<path-from: which qmd>",
      "searchMode": "vsearch",
      "includeDefaultMemory": true,
      "update": {
        "interval": "5m",
        "onBoot": true,
        "waitForBootSync": false
      },
      "limits": {
        "maxResults": 10,
        "maxSnippetChars": 500
      },
      "scope": { "default": "allow" }
    }
  }
}

Get the qmd path:

which qmd

Then tell the user:

"Add the above block to ~/.openclaw/openclaw.json. Use the path <result of which qmd> for the command field. Tell me when done."

Wait for confirmation.

A4: Install LosslessClaw

Check if already installed:

cat ~/.openclaw/openclaw.json | python3 -c "
import sys, json; d=json.load(sys.stdin)
installed = d.get('plugins',{}).get('installs',{}).get('lossless-claw')
print('installed:', installed.get('version') if installed else 'not found')
"

If not installed:

openclaw plugins install @martian-engineering/lossless-claw

Show the user this config block to add under plugins.entries:

{
  "plugins": {
    "allow": ["lossless-claw"],
    "entries": {
      "lossless-claw": {
        "enabled": true,
        "config": {
          "summaryProvider": "anthropic",
          "summaryModel": "claude-haiku-4-5",
          "freshTailCount": 32,
          "contextThreshold": 0.75,
          "ignoreSessionPatterns": ["agent:*:cron:**"],
          "incrementalMaxDepth": 10
        }
      }
    }
  }
}

Ask: "Which model should be used for summarization? (default: claude-haiku-4-5 — cheap and fast; alternatives: google/gemini-3-flash-preview, openai/gpt-4o-mini)"

Wait for answer, substitute into config, then:

openclaw gateway restart

✅ Phase A complete. Confirm with user before Phase B.

Phase B — Memory Manager Skill

B1: Install via ClawHub

# Check if already installed
ls ~/.openclaw/workspace/skills/memory-manager/SKILL.md 2>/dev/null && echo "already installed"

If not installed:

cd ~/.openclaw/workspace
clawhub install agent-memory-protocol

B2: Verify SKILL.md is accessible

head -5 ~/.openclaw/workspace/skills/memory-manager/SKILL.md

B3: Initialize memory directory structure

Check if memory structure exists:

ls ~/.openclaw/workspace/memory/ 2>/dev/null | head -10

If MEMORY.md or memory/ doesn't exist, create the skeleton:

mkdir -p ~/.openclaw/workspace/memory/user/preferences
mkdir -p ~/.openclaw/workspace/memory/user/entities
mkdir -p ~/.openclaw/workspace/memory/user/events
mkdir -p ~/.openclaw/workspace/memory/agent/cases
mkdir -p ~/.openclaw/workspace/memory/agent/patterns
mkdir -p ~/.openclaw/workspace/memory/archive

# Create L0 index stub if missing
if [ ! -f ~/.openclaw/workspace/MEMORY.md ]; then
cat > ~/.openclaw/workspace/MEMORY.md << 'EOF'
# Memory Index (L0)
> Full contents in memory/INDEX.md; this file holds high-frequency entry points only.

## User
- Profile → memory/user/profile.md
- Preferences → memory/user/preferences/

## Agent
- Cases → memory/agent/cases/
- Patterns → memory/agent/patterns/
EOF
fi

✅ Phase B complete. Confirm with user before Phase C.

Phase C — vid2md

C1: Check / clone repository

Ask: "Where should vid2md be installed? (default: ~/Projects/vid2md)"

Wait for answer, substitute as <VID2MD_DIR>.

# Check if already exists
ls <VID2MD_DIR>/vid2md.py 2>/dev/null && echo "already exists"

If not exists:

mkdir -p "$(dirname <VID2MD_DIR>)"
git clone https://github.com/OttoPrua/vid2md.git <VID2MD_DIR>

C2: Install Python dependencies

cd <VID2MD_DIR>
pip3 install -r requirements.txt

For Apple Silicon Macs, also install:

pip3 install mlx-whisper

For Linux / CUDA:

pip3 install faster-whisper

C3: Download transcription models

Ask: "Will you primarily process Chinese or English videos? (zh/en/both)"

If zh or both:

# FunASR model (downloads on first run, ~300 MB)
MODELSCOPE_CACHE=/tmp/ms_models python3 -c "
from funasr import AutoModel
AutoModel(model='paraformer-zh', model_revision='v2.0.4')
print('FunASR model ready')
"

If en or both (Apple Silicon):

python3 -c "import mlx_whisper; print('mlx-whisper ready')"

C4: Configure wechat-ocr (optional, macOS only)

Ask: "Do you have wechat-ocr available? (y/n — skip if unsure, falls back to macOS Vision)"

If yes, ask for the path and set:

export WECHAT_OCR_BIN=/path/to/wechat-ocr
# Add to ~/.zshrc or ~/.bashrc:
echo 'export WECHAT_OCR_BIN=/path/to/wechat-ocr' >> ~/.zshrc

C5: Download VLM for frame descriptions (optional)

Ask: "Install AI frame descriptions? Requires Ollama + ~5 GB. (y/n)"

If yes:

ollama pull qwen2.5vl:7b

C6: Test run

cd <VID2MD_DIR>
python3 vid2md.py --help

Run a quick smoke test on a short public video:

python3 vid2md.py "https://www.youtube.com/watch?v=dQw4w9WgXcQ" \
  --lang en --no-ocr --no-desc --interval 60

Check output exists:

ls output/*/tutorial.md 2>/dev/null && echo "✅ vid2md working"

✅ Phase C complete. Confirm with user before Phase D.

Phase D — WeChat Plugin

⚠️ macOS only. Requires WeChat desktop app installed and logged in.

D1: Prerequisites

# Check WeChat is installed
ls /Applications/WeChat.app 2>/dev/null && echo "WeChat found"

# Check Peekaboo
which peekaboo || brew install peekaboo

# Check accessibility permission
osascript -e 'tell application "System Events" to return name of first process whose frontmost is true' 2>/dev/null \
  && echo "accessibility: OK" || echo "accessibility: NEEDS PERMISSION"

If accessibility not granted:

"Please grant Terminal (or whichever app runs OpenClaw) accessibility permission in: System Settings → Privacy & Security → Accessibility"

D2: Clone and install

Ask: "Where should the WeChat plugin be installed? (default: ~/.openclaw/workspace/plugins/openclaw-wechat-plugin)"

PLUGIN_DIR=~/.openclaw/workspace/plugins/openclaw-wechat-plugin

git clone https://github.com/OttoPrua/openclaw-wechat-bot.git "$PLUGIN_DIR"
cd "$PLUGIN_DIR"
npm install

D3: Configure openclaw.json

Ask the user for:

Agent ID to use (e.g. main, or a custom agent like rossi)
Allowed group names (comma-separated)

Show config block:

{
  "plugins": {
    "allow": ["wechat"],
    "load": {
      "paths": ["~/.openclaw/workspace/plugins/openclaw-wechat-plugin"]
    },
    "entries": {
      "wechat": {
        "enabled": true
      }
    }
  },
  "channels": {
    "wechat": {
      "enabled": true,
      "groupOnly": true,
      "botName": "<your-bot-name>",
      "botTrigger": "＆bot",
      "agent": "<agent-id>",
      "allowedGroups": ["<group-name>"],
      "rateLimitPerMinute": 20,
      "dailyTokenBudget": 50000
    }
  }
}

Tell user: "Fill in your bot name, agent ID, and allowed group names, then add to openclaw.json. Tell me when done."

Wait for confirmation.

D4: Configure WeChat

1. Open WeChat on macOS
2. Settings → General → confirm send shortcut is Enter
3. System Settings → Notifications → WeChat → Allow Notifications → Style: Persistent
4. Keep WeChat running in background (not foreground) when testing

D5: Restart and test

openclaw gateway restart

"To test: go to one of your allowed WeChat groups and send: ＆bot hello The bot should reply within ~10 seconds."

✅ Phase D complete. Confirm with user before Phase E.

Phase E — Maintenance Cron Jobs

E1: Check existing jobs

openclaw cron list

E2: Ask which jobs to add

"Which cron jobs do you want to add? (skip any already listed above)

[1] Dream Cycle — Weekly memory consolidation (Sunday 08:00)

[2] Daily Progress Sync — Sync project progress to Blackboard daily (04:00)

[3] Monthly Cleanup — Archive old session logs (1st of month, 03:00)"

Wait for answer. Ask: "What timezone? (e.g. Asia/Shanghai, America/New_York, Europe/London)"

E3: Add selected jobs

For job [1] Dream Cycle:

openclaw cron add \
  --name "Dream Cycle (Memory Consolidation)" \
  --cron "0 8 * * 0" \
  --tz "<TIMEZONE>" \
  --session isolated \
  --message "Run memory consolidation: scan memory/ root for dated session log files, refine each into a ≤30-line structured summary, move originals to memory/archive/YYYY-MM/, deduplicate patterns/." \
  --announce

For job [2] Daily Progress Sync:

openclaw cron add \
  --name "Daily Progress Sync" \
  --cron "0 4 * * *" \
  --tz "<TIMEZONE>" \
  --session isolated \
  --message "Read blackboard/REGISTRY.md and yesterday's calendar events. Update Blackboard project cards with any progress changes." \
  --announce

For job [3] Monthly Cleanup:

openclaw cron add \
  --name "Monthly Session Cleanup" \
  --cron "0 3 1 * *" \
  --tz "<TIMEZONE>" \
  --session isolated \
  --message "Archive memory/ root session log files (YYYY-MM-DD.md format) older than 7 days to memory/archive/YYYY-MM/. Create the archive folder if it does not exist." \
  --announce

E4: Verify

openclaw cron list

Show a summary table of all registered jobs.

✅ Phase E complete.

Final Verification

After all selected phases are complete:

# Memory stack
qmd status
qmd vsearch "test" 2>/dev/null | head -3

# OpenClaw gateway
openclaw gateway status

# Cron jobs
openclaw cron list

# vid2md (if installed)
python3 <VID2MD_DIR>/vid2md.py --help 2>/dev/null | head -3

Report final status table:

Component	Status
qmd index	✅/❌
LosslessClaw	✅/❌
Memory Manager skill	✅/❌
vid2md	✅/❌
WeChat plugin	✅/❌
Cron jobs	N registered

References

Repo	Link
Memory Architecture	https://github.com/OttoPrua/openclaw-memory-manager
vid2md	https://github.com/OttoPrua/vid2md
WeChat Plugin	https://github.com/OttoPrua/openclaw-wechat-bot
Memory Manager Skill	https://clawhub.ai/OttoPrua/agent-memory-protocol
OpenClaw	https://github.com/openclaw/openclaw

openclaw-deploy

OpenClaw Capabilities Deployment Guide

Before Starting