diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
new file mode 100644
index 0000000..b9eed52
--- /dev/null
+++ b/ARCHITECTURE.md
@@ -0,0 +1,242 @@
+# nova-scripts Architecture
+
+> *Memory flows through stone channels,*
+> *Voices carried on database waves,*
+> *Knowledge held in vector space.*
+
+This document describes how the components in this repository relate to each other and their role in the broader NOVA agent ecosystem.
+
+---
+
+## System Overview
+
+This repository contains three distinct subsystems that support the NOVA agent ecosystem:
+
+1. **Memory Pipeline** — Persistent semantic memory for agents
+2. **Agent Chat Channel** — Inter-agent messaging via PostgreSQL
+3. **Git Security** — Pre-commit secret scanning
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    NOVA Agent Ecosystem                      │
+│                                                             │
+│  ┌────────────┐    ┌──────────────┐    ┌────────────────┐  │
+│  │  Memory     │    │  Agent Chat  │    │  Git Security  │  │
+│  │  Pipeline   │    │  Channel     │    │  Hooks         │  │
+│  └─────┬───────┘    └──────┬───────┘    └───────┬────────┘  │
+│        │                   │                    │           │
+│        ▼                   ▼                    ▼           │
+│  ┌────────────────────────────────────────────────────┐    │
+│  │              PostgreSQL (nova_memory)              │    │
+│  │  memory_embeddings  │  lessons  │  events  │       │    │
+│  │  agent_chat         │  sops     │           │       │    │
+│  └────────────────────────────────────────────────────┘    │
+│                                                             │
+│  OpenAI (text-embedding-3-small)   ◄── Embedding API        │
+│  Anthropic (Claude)                ◄── Extraction API       │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Memory Pipeline
+
+The memory pipeline is the core of NOVA's persistent, semantically-searchable memory. It transforms raw chat messages into vector embeddings that can be retrieved at runtime for context injection.
+
+### Data Flow
+
+```
+Chat Message
+    │
+    ▼
+extract-memories.sh ────────────► Database tables
+(Anthropic Claude API)              (entities, facts,
+    │                                lessons, events,
+    ▼                                preferences, etc.)
+embed-memories.py ──────────────► memory_embeddings table
+(OpenAI embeddings API,             (pgvector column)
+ pgvector, PostgreSQL)
+    │
+    ▼
+proactive-recall.py ◄────── New message triggers recall
+(Pre-message context injection)    │
+    │                               │
+    ▼                               ▼
+Agent session gets           semantic-search.py
+relevant memory context      (Ad-hoc CLI queries)
+    │
+    ▼
+recall-benchmark.py ─── Validates pipeline accuracy
+(Self-diagnostic)               against known ground truth
+    │
+    ▼
+decay-confidence.sh ─── Gradually reduces confidence
+(Cron, daily)               of stale/unreferenced lessons
+```
+
+### Stage 1: Extraction
+
+**Script:** `scripts/extract-memories.sh`
+
+Incoming chat messages (from any channel — Signal, WhatsApp, Discord, etc.) are processed through the `extract-memories.sh` script. It calls the Anthropic Claude API with a structured prompt that:
+
+- Parses the message for entities, facts, opinions, preferences, vocabulary, and events
+- Applies privacy detection (respecting per-user default visibility settings and override cues)
+- Returns structured JSON stored in the database
+
+### Stage 2: Embedding
+
+**Scripts:** `scripts/embed-memories.py`, `scripts/embed-memories-cron.sh`
+
+The embedding script reads from five source types:
+
+| Source | Database Table / File | Description |
+|---|---|---|
+| `daily_log` | `~/clawd/memory/*.md` | Daily markdown logs |
+| `memory_md` | `~/clawd/MEMORY.md` | Main memory file |
+| `lesson` | `lessons` table | Learned lessons from corrections |
+| `event` | `events` table | Calendar events |
+| `sop` | `sops` table | Standard Operating Procedures |
+
+Each source is chunked (1000 chars per chunk with 200 char overlap), embedded via OpenAI's `text-embedding-3-small` model, and stored in the `memory_embeddings` table with a `pgvector` vector column.
+
+The cron wrapper (`embed-memories-cron.sh`) runs this daily to keep embeddings current.
+
+### Stage 3: Recall
+
+**Scripts:** `scripts/proactive-recall.py`, `scripts/semantic-search.py`
+
+**Proactive Recall:** Before processing a user message, `proactive-recall.py` embeds the message query and performs a nearest-neighbor search against the `memory_embeddings` table. The top results are injected into the agent's context as "relevant memories."
+
+**Semantic Search:** `semantic-search.py` is the ad-hoc CLI version — useful for manual queries and debugging.
+
+Both use cosine distance (`<=>` operator in pgvector) for similarity ranking.
+
+### Stage 4: Maintenance
+
+**Scripts:** `scripts/recall-benchmark.py`, `scripts/decay-confidence.sh`
+
+**Benchmarking:** `recall-benchmark.py` runs a set of known queries against `proactive-recall.py` and checks if expected keywords appear in the results. It tests:
+
+- Entity lookups (direct fact retrieval)
+- Library knowledge queries
+- Lesson recall (from past corrections)
+- Event date queries
+- Cross-reference queries (architecture knowledge)
+- Noise handling (irrelevant queries should return empty results)
+
+The pipeline passes if hit rate ≥ 60%.
+
+**Confidence Decay:** `decay-confidence.sh` runs daily via cron. It reduces confidence scores for lessons that haven't been referenced in 30+ days (multiply by 0.95, floor at 0.1). Lessons below 0.3 confidence are logged as candidates for review.
+
+---
+
+## Agent Chat Channel
+
+The `agent-chat-channel/` directory contains a PostgreSQL-based messaging channel plugin for OpenClaw.
+
+### Role in the Ecosystem
+
+In the NOVA agent ecosystem, agents need to communicate with each other. The agent-chat-channel plugin provides this capability by treating the `agent_chat` database table as a message bus:
+
+```
+Agent A (e.g., scout)
+    │
+    │  INSERT INTO agent_chat (sender='scout', message='...', mentions=ARRAY['coder'])
+    ▼
+agent_chat table ──► PostgreSQL NOTIFY
+    │
+    ▼
+gateway.agentChatPlugin ──► LISTEN agent_chat
+    │
+    ├──► Routes to Agent B's session (e.g., coder)
+    │      runtime.handleInbound({...})
+    │
+    └──► Marks message as processed in agent_chat_processed
+```
+
+### Key Design Decisions
+
+- **Database as message bus:** No separate message broker needed. PostgreSQL's LISTEN/NOTIFY provides real-time delivery.
+- **Mention-based routing:** Agents only receive messages that mention them by name. This prevents message storms.
+- **Deduplication at the DB level:** The `agent_chat_processed` table with a composite primary key `(chat_id, agent)` ensures each message is processed exactly once per agent.
+- **1Password integration:** Database credentials can be stored in 1Password and resolved at runtime.
+
+### Database Tables
+
+| Table | Purpose |
+|---|---|
+| `agent_chat` | Message store (channel, sender, message, mentions, reply chain) |
+| `agent_chat_processed` | Deduplication tracker |
+
+### Plugin Architecture
+
+The plugin follows OpenClaw's channel plugin architecture:
+
+| Component | Purpose |
+|---|---|
+| `config.resolveAccount` | Resolves account configuration (single or multi-account) |
+| `gateway.startAccount` | Core listening loop (LISTEN, fetch unprocessed, route to sessions) |
+| `outbound.sendText` | Sends agent replies back to the `agent_chat` table |
+| `status` | Health and runtime status reporting |
+
+---
+
+## Git Security
+
+The `scripts/git-security/` directory provides pre-commit hooks that scan staged files for secrets before they reach the repository.
+
+### Purpose
+
+In an AI agent ecosystem where code is written autonomously (or semi-autonomously), the risk of accidentally committing API keys or credentials is higher than in human-only development. These hooks provide an automated safety net.
+
+### How It Works
+
+```
+Developer stages files
+    │
+    ▼
+git commit triggers pre-commit hook
+    │
+    ▼
+Scans staged files for patterns:
+  - API keys (OpenAI, Anthropic, AWS, GitHub)
+  - Private keys (RSA, Ed25519, PEM)
+  - Secrets and passwords in config-like patterns
+  - Forbidden files (.env, credentials.json, id_*)
+    │
+    ├── No problems found ──► Commit proceeds
+    │
+    └── Secrets detected ──► Commit blocked
+                              (can bypass with --no-verify)
+```
+
+### Installer
+
+`install-hooks.sh` automates installation:
+1. Copies `pre-commit-template` to the target repo's `.git/hooks/pre-commit`
+2. Makes it executable
+3. Updates `.gitignore` with common secret patterns
+
+---
+
+## Dependencies Summary
+
+| Component | Dependencies |
+|---|---|
+| Memory Pipeline | PostgreSQL (pgvector), OpenAI API, Anthropic API, Python 3 (psycopg2, openai), bash (jq, curl, psql) |
+| Agent Chat Plugin | Node.js, PostgreSQL (`pg` npm package) |
+| Git Security | bash, grep |
+| GDrive Sync | gogcli, jq |
+
+---
+
+## Related Repositories
+
+- [OpenClaw](https://github.com/nova-ai/openclaw) — The gateway platform these scripts run on
+- [nova-memory](https://github.com/nova-ai/nova-memory) — Database schemas and migrations
+- [nova-cognition](https://github.com/nova-ai/nova-cognition) — Agent cognition and routing
+
+---
+
+*Architecture reviewed 2026-05-06*
diff --git a/README.md b/README.md
index 842e176..5c116a2 100644
--- a/README.md
+++ b/README.md
@@ -1,19 +1,202 @@
 # nova-scripts ✨
 
-Utility scripts and tools by NOVA — an AI assistant running on [Clawdbot](https://github.com/clawdbot/clawdbot).
+Utility scripts and tools by **NOVA** — an AI assistant ecosystem running on [OpenClaw](https://github.com/nova-ai/openclaw).
 
-These are small utilities I've written to solve everyday problems. Open source in case they're useful to others!
+This repository contains the operational scripts that power NOVA's memory pipeline, inter-agent communication, Google Drive sync, and pre-commit security hooks. These are small utilities written to solve everyday problems — open source in case they're useful to others.
 
-## Scripts
+---
+
+## Table of Contents
+
+- [Memory Pipeline](#memory-pipeline)
+  - [extract-memories.sh](#extract-memoriessh)
+  - [embed-memories.py](#embed-memoriespy)
+  - [embed-memories-cron.sh](#embed-memories-cronsh)
+  - [proactive-recall.py](#proactive-recallpy)
+  - [semantic-search.py](#semantic-searchpy)
+  - [recall-benchmark.py](#recall-benchmarkpy)
+  - [decay-confidence.sh](#decay-confidencesh)
+- [Utilities](#utilities)
+  - [gdrive-sync.sh](#gdrive-syncsh)
+  - [agent-install.sh](#agent-installsh)
+- [Security](#security)
+  - [git-security (install-hooks.sh + pre-commit-template)](#git-security)
+- [Plugin](#plugin)
+  - [agent-chat-channel](#agent-chat-channel)
+- [Architecture](#architecture)
+- [License](#license)
+
+---
+
+## Memory Pipeline
+
+The memory pipeline is the core of NOVA's persistent memory system. Data flows through four stages:
+
+1. **Extract** → Parse chat messages and extract structured memory (facts, entities, lessons)
+2. **Embed** → Convert extracted content into vector embeddings using OpenAI + pgvector
+3. **Recall** → On new messages, retrieve semantically relevant memories for context injection
+4. **Maintain** → Decay stale memories and benchmark retrieval accuracy
+
+### extract-memories.sh
+
+Extracts structured memory data (entities, facts, opinions, preferences, vocabulary, events) from chat messages using the Anthropic Claude API. Designed to be called from a message processing hook.
+
+```bash
+# Pipe a message directly
+echo "I love working on the Nova project" | ./scripts/extract-memories.sh
+
+# Or pass as argument
+./scripts/extract-memories.sh "My birthday is May 27th, 1978"
+
+# Environment variables for sender attribution
+SENDER_NAME="I)ruid" SENDER_ID="+15551234567" ./scripts/extract-memories.sh "Just between us, I'm thinking of quitting"
+```
+
+**Requirements:** Anthropic API key (`ANTHROPIC_API_KEY`), `jq`, `curl`, `psql` (for privacy preference lookup)
+
+**Output:** JSON with extracted entities, facts, opinions, preferences, vocabulary, and events.
+
+**Privacy-aware:** Respects per-user default visibility settings (public/private) stored in the database. Detects override cues like "feel free to share" or "don't tell anyone."
+
+### embed-memories.py
+
+Takes memory content from various sources (daily logs, MEMORY.md, database lessons, events, SOPs) and creates vector embeddings using OpenAI's `text-embedding-3-small` model. Stores embeddings in PostgreSQL using the `pgvector` extension.
+
+```bash
+# Embed all sources
+python3 ./scripts/embed-memories.py
+
+# Embed only daily logs
+python3 ./scripts/embed-memories.py --source daily_log
+
+# Drop and recreate all embeddings
+python3 ./scripts/embed-memories.py --reindex
+```
+
+**Requirements:** OpenAI API key (`OPENAI_API_KEY`), PostgreSQL (`nova_memory` database), `pgvector` extension
+
+**Sources:**
+- `daily_log` — Markdown files from `~/clawd/memory/`
+- `memory_md` — `MEMORY.md` file
+- `lesson` — Database `lessons` table
+- `event` — Database `events` table
+- `sop` — Database `sops` table (Standard Operating Procedures)
+
+**Chunking:** Splits text into overlapping chunks (1000 chars with 200 char overlap) for granular retrieval.
+
+### embed-memories-cron.sh
+
+Cron wrapper script that runs `embed-memories.py` daily. Sources a Python virtual environment and logs output to `~/clawd/logs/embed-memories.log`.
+
+```bash
+# Run manually
+./scripts/embed-memories-cron.sh
+
+# Typical crontab entry (runs daily at 3 AM)
+0 3 * * * /home/nova/clawd/scripts/embed-memories-cron.sh
+```
+
+**Requirements:** Python virtual environment at `~/clawd/scripts/tts-venv/`
+
+### proactive-recall.py
+
+Pre-message semantic recall system. Given a user's message, retrieves the most semantically relevant memories from the embedding store. Designed for context injection — it can produce formatted output ready to insert into an LLM prompt.
+
+```bash
+# Standalone search
+python3 ./scripts/proactive-recall.py "What projects does NOVA include?"
+
+# Formatted for prompt injection
+python3 ./scripts/proactive-recall.py "Tell me about the Silmarillion" --inject
+
+# Custom limit and threshold
+python3 ./scripts/proactive-recall.py "How does the recall system work?" --limit 5
+```
+
+**Requirements:** OpenAI API key, PostgreSQL (`nova_memory` database with `memory_embeddings` table), `pgvector`
+
+**Output:** JSON with ranked results including source, content excerpt, and similarity score. Use `--inject` for a preformatted markdown block.
+
+### semantic-search.py
+
+CLI tool for ad-hoc semantic search across the embedded memory store. Provides flexible querying with configurable similarity threshold and result limits.
+
+```bash
+# Basic search
+python3 ./scripts/semantic-search.py "what did we discuss about the app?"
+
+# More results with lower threshold
+python3 ./scripts/semantic-search.py "I)ruid's health" --limit 10 --threshold 0.3
+
+# JSON output for programmatic use
+python3 ./scripts/semantic-search.py "architecture" --json
+```
+
+**Requirements:** OpenAI API key, PostgreSQL, `pgvector`
+
+### recall-benchmark.py
+
+Self-diagnostic benchmarking tool that tests the semantic recall pipeline (`proactive-recall.py`) against known ground-truth facts. Measures retrieval accuracy across multiple query patterns including entity lookups, library retrieval, lesson recall, event queries, cross-references, and noise handling.
+
+```bash
+# Run with verbose output
+python3 ./scripts/recall-benchmark.py --verbose
+
+# JSON output for analysis
+python3 ./scripts/recall-benchmark.py --json
+```
+
+**Pass/fail:** Exit code 0 if hit rate ≥ 60%, exit code 1 otherwise. Reports per-category breakdown.
+
+**Test categories:**
+- `entity_lookup` — Direct fact retrieval (names, birthdays, relationships)
+- `library` — Library/knowbase retrieval (books, subjects)
+- `lesson` — Lesson recall from past corrections
+- `event` — Event date retrieval
+- `cross_reference` — Architecture and ecosystem knowledge
+- `noise` — Handles irrelevant queries without false positives
+
+### decay-confidence.sh
+
+Cron-compatible script that gradually decays confidence scores for lessons not referenced recently. Prevents stale or outdated information from persisting indefinitely.
+
+```bash
+# Run manually
+./scripts/decay-confidence.sh
+
+# Typical crontab entry (runs daily at 4 AM)
+0 4 * * * /home/nova/clawd/scripts/decay-confidence.sh
+```
+
+**Behavior:**
+- Lessons not referenced in 30+ days: confidence multiplied by 0.95
+- Minimum confidence floor: 0.1 (never fully forgets)
+- Logs lessons that drop below 0.3 confidence for review
+
+**Requirements:** PostgreSQL access to `nova_memory` database
+
+---
+
+## Utilities
 
 ### gdrive-sync.sh
 
-Simple Google Drive folder sync using [gogcli](https://gogcli.sh).
+Simple Google Drive folder sync using [gogcli](https://gogcli.sh). Supports pull, push, and status operations for a single Google Drive folder.
 
 ```bash
-./gdrive-sync.sh pull    # Download from GDrive to local
-./gdrive-sync.sh push    # Upload from local to GDrive  
-./gdrive-sync.sh status  # Show files in both locations
+# Set required config (or edit script defaults)
+export GDRIVE_FOLDER_ID="your-folder-id"
+export LOCAL_DIR="$HOME/my-sync-folder"
+export GOG_ACCOUNT="you@gmail.com"  # optional
+
+# Download from GDrive to local
+./scripts/gdrive-sync.sh pull
+
+# Upload from local to GDrive
+./scripts/gdrive-sync.sh push
+
+# Show files in both locations
+./scripts/gdrive-sync.sh status
 ```
 
 **Requirements:**
@@ -21,10 +204,111 @@ Simple Google Drive folder sync using [gogcli](https://gogcli.sh).
 - `jq` for JSON parsing
 - Authenticated gog account (`gog auth add you@gmail.com`)
 
-**Configuration:** Edit the variables at the top of the script:
-- `LOCAL_DIR` — local directory to sync
-- `GDRIVE_FOLDER_ID` — Google Drive folder ID
-- `ACCOUNT` — your Google account email
+**Configuration:** Set via environment variables (`GDRIVE_FOLDER_ID`, `LOCAL_DIR`, `GOG_ACCOUNT`) or edit the defaults at the top of the script.
+
+### agent-install.sh
+
+Stub installer for NOVA-INSTALL.sh compatibility. This repository has no installation requirements.
+
+```bash
+./agent-install.sh
+# Output: No installation steps for nova-scripts
+```
+
+---
+
+## Security
+
+### git-security
+
+Pre-commit hooks for scanning staged files for potential secrets before they reach the repository. Prevents accidental commits of API keys, credentials, and private keys.
+
+**Contents:**
+- `install-hooks.sh` — Installer script that copies the hook template to any git repository
+- `pre-commit-template` — The actual pre-commit hook template
+
+```bash
+# Install hooks in a repository
+./scripts/git-security/install-hooks.sh /path/to/your/repo
+```
+
+**What it detects (via the pre-commit template):**
+
+| Pattern | Example |
+|---|---|
+| Anthropic API keys | `sk-ant-api...` |
+| Anthropic Admin keys | `sk-ant-admin...` |
+| OpenAI API keys | `sk-...` |
+| AWS Access Keys | `AKIA...` |
+| AWS Secret Keys | Base64-encoded 40-char strings in quotes |
+| Private Keys | `-----BEGIN * PRIVATE KEY-----` |
+| GitHub Tokens | `ghp_...`, `ghs_...`, etc. |
+| Generic secrets/passwords | `"secret": "..."`, `"password": "..."` |
+| Generic API keys | `"api_key": "..."` |
+| Forbidden files | `.env`, `.pem`, `.key`, `credentials.json`, `id_rsa`, etc. |
+
+**Installation also updates `.gitignore`** with common secret patterns if they're missing.
+
+**Bypass:** `git commit --no-verify` (document why in the commit message).
+
+---
+
+## Plugin
+
+### agent-chat-channel
+
+A PostgreSQL-based messaging channel plugin for OpenClaw that allows agents to communicate via the `agent_chat` database table. Uses PostgreSQL `LISTEN`/`NOTIFY` for real-time message delivery.
+
+**Location:** `agent-chat-channel/` (has its own README.md and SETUP.md)
+
+**Key features:**
+- Real-time notifications via PostgreSQL `NOTIFY`
+- Mention-based routing — only processes messages where the agent is mentioned
+- Deduplication via `agent_chat_processed` table
+- Two-way messaging — routes incoming messages to agent sessions and sends replies back to the database
+- Multiple account support — one gateway can serve multiple agents
+- 1Password integration for database credentials
+
+**How it works:**
+1. Plugin connects to PostgreSQL and executes `LISTEN agent_chat`
+2. On startup, checks for any unprocessed messages where agent name is in the `mentions` array
+3. When a `NOTIFY` is received, queries for new messages targeting this agent
+4. Routes each message to the agent's session via `runtime.handleInbound`
+5. Marks message as processed in `agent_chat_processed`
+6. Agent replies are inserted back into `agent_chat` with the agent as sender
+
+**Database schema:**
+
+```sql
+-- Main chat messages table
+CREATE TABLE agent_chat (
+    id SERIAL PRIMARY KEY,
+    channel TEXT NOT NULL DEFAULT 'default',
+    sender TEXT NOT NULL,
+    message TEXT NOT NULL,
+    mentions TEXT[] DEFAULT '{}',
+    reply_to INTEGER REFERENCES agent_chat(id),
+    created_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Track processed messages
+CREATE TABLE agent_chat_processed (
+    chat_id INTEGER REFERENCES agent_chat(id) ON DELETE CASCADE,
+    agent TEXT NOT NULL,
+    processed_at TIMESTAMP DEFAULT NOW(),
+    PRIMARY KEY (chat_id, agent)
+);
+```
+
+**Configuration:** See `agent-chat-channel/README.md` and `agent-chat-channel/SETUP.md` for full details.
+
+---
+
+## Architecture
+
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for the system overview showing how these components relate to each other and to the broader NOVA ecosystem.
+
+---
 
 ## License
 
diff --git a/agent-chat-channel/README.md b/agent-chat-channel/README.md
index de9576c..f4a1166 100644
--- a/agent-chat-channel/README.md
+++ b/agent-chat-channel/README.md
@@ -1,4 +1,4 @@
-# Agent Chat Channel Plugin for Clawdbot
+# Agent Chat Channel Plugin for OpenClaw
 
 PostgreSQL-based messaging channel that allows agents to communicate via the `agent_chat` database table.
 
@@ -60,7 +60,7 @@ cd /home/nova/clawd/clawdbot-plugins/agent-chat-channel
 npm install
 ```
 
-2. Register the plugin in Clawdbot's config (usually `~/.config/clawdbot/config.yaml`):
+2. Register the plugin in OpenClaw's config (usually `~/.config/openclaw/config.yaml`):
 ```yaml
 plugins:
   paths:
@@ -69,7 +69,7 @@ plugins:
 
 ## Configuration
 
-Add to your Clawdbot config:
+Add to your OpenClaw config:
 
 ```yaml
 channels:
@@ -162,7 +162,7 @@ Check that:
 
 - Verify NOTIFY trigger is firing: `SELECT * FROM pg_stat_activity WHERE wait_event = 'ClientRead'`
 - Check that agent name matches exactly in config and `mentions` array
-- Look for errors in Clawdbot logs: `clawdbot gateway logs`
+- Look for errors in OpenClaw logs: `openclaw gateway logs`
 
 ### Messages processed multiple times
 
@@ -172,7 +172,7 @@ This shouldn't happen due to the `agent_chat_processed` table, but if it does:
 
 ## Development
 
-The plugin follows Clawdbot's channel plugin architecture:
+The plugin follows OpenClaw's channel plugin architecture:
 
 - `config`: Account resolution and configuration management
 - `gateway.startAccount`: Core listening logic
@@ -181,4 +181,4 @@ The plugin follows Clawdbot's channel plugin architecture:
 
 ## License
 
-Same as Clawdbot
+Same as OpenClaw
diff --git a/agent-chat-channel/SETUP.md b/agent-chat-channel/SETUP.md
index 84043b3..f12c5de 100644
--- a/agent-chat-channel/SETUP.md
+++ b/agent-chat-channel/SETUP.md
@@ -25,9 +25,9 @@ CREATE FUNCTION notify_agent_chat() ...;
 CREATE TRIGGER agent_chat_notify ...;
 ```
 
-## 3. Configure Clawdbot
+## 3. Configure OpenClaw
 
-Edit your `~/.config/clawdbot/config.yaml`:
+Edit your `~/.config/openclaw/config.yaml`:
 
 ```yaml
 # Register the plugin
@@ -48,16 +48,16 @@ channels:
 
 See `example-config.yaml` for more options.
 
-## 4. Restart Clawdbot Gateway
+## 4. Restart OpenClaw Gateway
 
 ```bash
-clawdbot gateway restart
+openclaw gateway restart
 ```
 
 ## 5. Verify Plugin Loaded
 
 ```bash
-clawdbot gateway status
+openclaw gateway status
 ```
 
 Look for `agent_chat` in the channels list.
@@ -77,7 +77,7 @@ The agent should receive and respond to the message.
 
 - Check plugin path in config
 - Verify index.js exports `agentChatPlugin` or default export
-- Check gateway logs: `clawdbot gateway logs`
+- Check gateway logs: `openclaw gateway logs`
 
 ### Database connection errors
 
diff --git a/agent-chat-channel/example-config.yaml b/agent-chat-channel/example-config.yaml
index ead3db4..9601f0a 100644
--- a/agent-chat-channel/example-config.yaml
+++ b/agent-chat-channel/example-config.yaml
@@ -1,6 +1,6 @@
-# Example Clawdbot configuration for agent_chat channel
+# Example OpenClaw configuration for agent_chat channel
 #
-# Add this to your ~/.config/clawdbot/config.yaml
+# Add this to your ~/.config/openclaw/config.yaml
 
 # 1. Register the plugin
 plugins:
@@ -30,10 +30,3 @@ channels:
 #         host: localhost
 #         user: newhart
 #         password: op://NOVA Shared Vault/Agent DB: newhart/password
-#       
-#       assistant2:
-#         agentName: assistant2
-#         database: nova_memory
-#         host: localhost
-#         user: assistant2
-#         password: op://NOVA Shared Vault/Agent DB: assistant2/password
diff --git a/agent-chat-channel/index.js b/agent-chat-channel/index.js
index 752fd92..cb19a1f 100644
--- a/agent-chat-channel/index.js
+++ b/agent-chat-channel/index.js
@@ -2,7 +2,7 @@ import pg from 'pg';
 const { Client } = pg;
 
 /**
- * Agent Chat Channel Plugin for Clawdbot
+ * Agent Chat Channel Plugin for OpenClaw
  * 
  * Listens to PostgreSQL NOTIFY on 'agent_chat' channel and routes messages
  * to the agent when mentioned. Marks processed messages in agent_chat_processed.
@@ -11,7 +11,7 @@ const { Client } = pg;
 const PLUGIN_ID = 'agent_chat';
 
 /**
- * Resolve agent_chat account config from Clawdbot config
+ * Resolve agent_chat account config from OpenClaw config
  */
 function resolveAgentChatAccount({ cfg, accountId = 'default' }) {
   const channelConfig = cfg.channels?.agent_chat;
diff --git a/scripts/proactive-recall.py b/scripts/proactive-recall.py
index e77129b..78fe28c 100755
--- a/scripts/proactive-recall.py
+++ b/scripts/proactive-recall.py
@@ -7,7 +7,7 @@
     
 Output: JSON with relevant memories to inject into context.
 
-For Clawdbot integration, call this from a hook or message preprocessor.
+For OpenClaw integration, call this from a hook or message preprocessor.
 """
 
 import os