{"id":"8c5b9ee3-b5fc-4fc7-9153-bea99ab4d4d1","entityType":"agent","slug":"clawhub-hualang-c-redis-memory-system","name":"redis-memory-system","canonicalUrl":"https://www.xpersona.co/agent/clawhub-hualang-c-redis-memory-system","canonicalPath":"/agent/clawhub-hualang-c-redis-memory-system","generatedAt":"2026-10-10T17:35:50.700Z","source":"CLAWHUB","claimStatus":"UNCLAIMED","verificationTier":"NONE","summary":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-10T15:18:07.513Z","emptyReason":null},"description":"跨会话自动记忆系统 v3.3.0 — 单脚本+配置驱动+语义标签索引。支持标签检索、倒排索引、语义搜索。","descriptionLabel":"Source description","evidenceSummary":"Capability contract not published. No trust telemetry is available yet. 1.4K downloads reported by the source. Last updated 10/10/2026.","installCommand":"clawhub skill install s1737qdqxgbbd8gwrat1cmt0n9841b46:redis-memory-system","sourceUrl":"https://clawhub.ai/hualang-c/redis-memory-system","homepage":"https://clawhub.ai/hualang-c/skills/redis-memory-system","primaryLinks":[{"label":"View on ClawHub","url":"https://clawhub.ai/hualang-c/redis-memory-system","kind":"source"},{"label":"Homepage","url":"https://clawhub.ai/hualang-c/skills/redis-memory-system","kind":"homepage"}],"safetyScore":84,"overallRank":62,"popularityScore":63,"trustScore":null,"claimedByName":null,"isOwner":false,"seoDescription":"redis-memory-system technical dossier on Xpersona with agent coverage, OPENCLEW support, and live trust metadata."},"coverage":{"evidence":{"source":"public-profile","verified":false,"confidence":"medium","updatedAt":"2026-10-10T15:18:07.513Z","emptyReason":null},"protocols":[{"protocol":"OPENCLEW","label":"OpenClaw","status":"self-declared","notes":"Declared in the public agent profile."}],"capabilities":[],"verifiedCount":0,"selfDeclaredCount":1,"capabilityMatrix":{"rows":[{"key":"OPENCLEW","type":"protocol","support":"unknown","confidenceSource":"profile","notes":"Listed on profile"}],"flattenedTokens":"protocol:OPENCLEW|unknown|profile"}},"adoption":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-10T15:18:07.513Z","emptyReason":null},"stars":null,"forks":null,"downloads":1364,"packageName":null,"latestVersion":"3.3.0","tractionLabel":"1.4K downloads"},"release":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-10T15:18:07.499Z","emptyReason":null},"lastUpdatedAt":"2026-10-10T15:18:07.513Z","lastCrawledAt":"2026-10-10T15:18:07.499Z","lastIndexedAt":null,"nextCrawlAt":"2026-10-11T15:18:07.499Z","lastVerifiedAt":null,"highlights":[{"version":"3.3.0","createdAt":"2026-05-27T01:09:06.544Z","changelog":"- **Version bump:** Unified version numbering to v3.3.0 across all files - **Fix:** sync now uses transcript file mtime for date key, preventing date misassignment on conversations spanning midnight - **Cleanup:** Removed deprecated `openclaw_cron_prompt.txt` (unused since v3.2); updated SKILL.md file table, rewrote setup.sh to remove references to non-existent scripts - **Security:** Zero hardcoded info, no personal data exposure - **版本统一：** 清理版本号混乱，统一跳至 v3.3.0 - **修复：** sync 改用 transcript 文件修改时间确定日期 key，避免跨夜对话写入错误日期 - **清理：** 删除废弃的 `openclaw_cron_prompt.txt`（v3.2 后弃用）；更新 SKILL.md 文件表、重写 setup.sh 移除非现存脚本引用 - **安全：** 零硬编码，无个人信息泄露","fileCount":7,"zipByteSize":12986},{"version":"3.2.4","createdAt":"2026-05-26T05:27:18.195Z","changelog":"Optimized Examples 优化示例","fileCount":8,"zipByteSize":12534},{"version":"3.2.3","createdAt":"2026-05-26T00:36:48.873Z","changelog":"edis-memory-system v3.2.3 What's New in v3.2.3 1. Semantic Tag System (LLM-Generated) Every hourly sync now generates 5 concept-level tags per session via LLM, stored as Redis Set inverted indices. This replaces vector DB dependency with a zero-dependency lightweight alternative. 2. New Commands: tag & search memory.sh tag — View tags for a specific date — memory.sh search [tag2 ...] — Intersection-based multi-tag lookup across dates Both commands pull from clean, automatically maintained tag indices. 3. Full Chain Verified Single-tag lookup, multi-tag intersection (AND), combined tag+summary queries — all tested and passing in production. 4. Product Philosophy Locked Lightweight. Zero burden. Config-driven. Serving individual developers — not enterprise complexity. No vector DB, no external dependencies beyond Redis. v3.2.3 completes the semantic layer without adding a single pound of weight. The system remains: 1 config file, 1 script, Redis. CN — v3.2.3 更新内容 1. 语义标签系统（LLM 自动生成） 每轮自动同步时，LLM 会为会话生成 5 个概念级标签，存入 Redis Set 倒排索引。完全替代向量数据库方案，零额外依赖。 2. 新增命令：tag & search — memory.sh tag <用户名> <日期>— 查看某天的标签 — memory.sh search <用户名> <标签1> [标签2 ...] — 多标签交集检索 数据由 cron 自动维护，无需手动干预。 3. 全链路验证通过 单标签查询、多标签交集（AND）、标签+摘要联合检索——生产环境实测全部通过。 4. 产品理念落地 轻量、零负担、配置驱动。只服务个体开发者，不做企业级复杂。无向量库，无额外依赖，Redis 就够了。 v3.2.3 给记忆系统加上了语义层，但没增加一斤重量。依然是一个脚本、一个配置、Redis。 版本路线 v3.1 — Cron 全自动同步 + 直读 transcript 绕过 dmScope 隔离 v3.2.1 — 6 脚本合并为 1 个 memory.sh，配置驱动替代硬编码 v3.2.3 — 语义标签系统上线（标签 + 倒排索引 + 多标签检索）","fileCount":8,"zipByteSize":13720},{"version":"3.2.2","createdAt":"2026-05-25T11:56:54.350Z","changelog":"- Single `memory.sh` replaces all legacy scripts — unified entry for sync/get/set/heartbeat/stats - Configuration-driven: usernames managed via `/etc/memory-users.conf`, no code changes needed - `sync` outputs structured JSON; the cron LLM only handles summarization decisions - Language-agnostic self-reference filter (`*memory.sh*sync*`) - `{{SCRIPTS_DIR}}` placeholder replaces hardcoded paths, resolved by setup - Heartbeat cron auto-registered, monitors for missing summaries and writes alert flags - Per-user distributed locks enabling parallel sync for multiple users - 单脚本 memory.sh 替代全部旧脚本，sync/get/set/heartbeat/stats 统一入口 - 配置驱动，用户名通过 /etc/memory-users.conf 管理，加用户不改代码 - sync 输出结构化 JSON，cron 的 LLM 只做总结决策 - 自引用过滤语言无关（*memory.sh*sync*），中英文环境通用 - {{SCRIPTS_DIR}} 占位符替代硬编码路径，setup 自动替换 - 心跳 cron 自动注册，检测摘要丢失并写告警文件 - 锁细化到用户级，多用户可并行同步","fileCount":6,"zipByteSize":9234},{"version":"3.2.1","createdAt":"2026-05-25T11:38:33.742Z","changelog":"Major Release — Complete Architecture Refactoring v3.2 is not a minor patch. It's a ground-up redesign of the entire memory synchronization system. What changed: - 6 scripts consolidated into a single `memory.sh` — sync / get / set / heartbeat / stats all in one place - Configuration-driven: all usernames managed via `/etc/memory-users.conf`, no code changes needed to add users - `sync` command outputs structured JSON; the cron LLM only handles summarization decisions, no more shell output parsing - Self-reference filter: cron sessions no longer pollute their own memory data - Per-user distributed locks enabling parallel sync for multiple users Upgrading from v3.1? The old scripts (redis_memory.sh, cron_heartbeat_ping.sh, etc.) are deprecated. Everything is now managed by `memory.sh`. Clean up old files before installation. 重大更新 — 架构完全重构 v3.2 不是一次小修小补，而是从设计理念到代码实现的全盘重做。 核心变化： - 6 个脚本合并为 1 个 memory.sh，sync/get/set/heartbeat/stats 全部内置 - 配置文件驱动，所有用户名通过 /etc/memory-users.conf 管理，加用户不改代码 - sync 命令输出结构化 JSON，cron 的 LLM 只需做总结决策，不再解析原始 shell 输出 - 自引用过滤：cron session 不再污染自己的记忆数据 - 锁细化到用户级，多用户可并行同步 从 v3.1 升级的用户注意：旧版脚本（redis_memory.sh / cron_heartbeat_ping.sh 等）已废弃，全部由 memory.sh 统一接管。安装前建议清理旧文件。","fileCount":6,"zipByteSize":9229},{"version":"3.1.1","createdAt":"2026-05-25T10:10:48.129Z","changelog":"redis-memory-system v3.1.1 Changelog 2026-05-25 Core Architecture Changes Merged exec calls File search + conversation extraction + Redis deduplication combined into a single script. Eliminates variable loss across processes caused by the three independent exec steps in v3.1. Atomic Redis writes Replaces three separate redis-cli calls with a Lua EVAL script. HSET + EXPIRE + SET last_seen completed in one transaction. Prevents data inconsistency if a crash occurs midway. Distributed lock SET NX EX 600 prevents two cron jobs from writing simultaneously. trap cleanup EXIT ensures the lock is automatically released when the script exits. Retry mechanism When file reading fails, retry up to 2 times with a 1‑second interval. Fixed Bugs File selection: most matches → latest by modification time Old bug: an old file from May 8th with 29 matches would override a new session from today with 28 matches, causing missed memories. Fix: use ls -t to pick the most recently modified file. Shell syntax errors do not abort the script Old bug: when grep -c returned empty, shell would error with [: 0: integer expression expected. Fix: proper handling of empty return values. Threshold of 5 was too high Old bug: short dialogs like “Are you there?” (only 2 user messages) were filtered out and never stored. Fix: lowered threshold to 2. Cron self‑reference filtering Old bug: the cron prompt contained a user ID, so cron’s own session was also matched by grep. Fix: head -10 checks if the file contains the [cron: prefix and skips self‑referencing files. Script Improvements All scripts now validate argument count and content to prevent ghost records from insufficient parameters. redis_memory_user.sh username validation At startup, checks whether USERNAME is still the placeholder \"your_username\" to prevent accidentally writing to memory:your_username. cron_heartbeat_ping.sh externalised user list Supports three configuration methods: environment variable REDIS_MEMORY_USERS, configuration file /etc/redis-memory-users.conf, or a hardcoded array. New commands in redis_memory.sh ping: check Redis connectivity. stats: count memory days and characters per user. New standalone script scripts/extract_dialog.py Replaces the Python code previously embedded in the cron prompt for transcript conversation extraction. Avoids shell quoting issues and makes it easier to cite in papers. recent command upper limit of 30 days Prevents accidentally traversing the entire history when a large number is passed. Documentation Updates SKILL.md and README.md completely rewritten: Architecture diagram updated to reflect the actual v3.1.1 flow. Deployment notes synchronised (timeout raised from 120 s to 180 s, tool restrictions set to exec,read). Added a complete problem‑solution mapping table. Known Limitations Redis has no persistence configured (RDB/AOF). Restarting Redis loses the last 7 days of memories. Tied to OpenClaw’s transcript file path; adapting to other platforms requires changes. No quantitative evaluation metric for LLM summary deduplication. redis-memory-system v3.1.1 更新日志 2026-05-25 核心架构改动 合并 exec 调用 文件查找 + 对话提取 + Redis 查重合并为一个脚本 消除原 v3.1 三步独立 exec 导致的变量跨进程丢失 Redis 原子写入 用 Lua EVAL 脚本替代三次独立 redis-cli 调用 HSET + EXPIRE + SET last_seen 在同一个事务中完成 半路崩溃不会产生数据不一致 分布式锁 SET NX EX 600 防止两个 cron 同时写入 trap cleanup EXIT 保证锁在脚本退出时自动释放 重试机制 文件读取失败时最多重试 2 次，间隔 1 秒 修复的 bug 找文件按匹配数取最多 -> 改为 ls -t 按修改时间取最新 旧 bug: 5月8号旧文件有29条匹配，碾压了今天新session的28条，导致记忆漏写 shell 语法报错不中断 旧 bug: grep -c 返回空时，shell 报 [: 0: integer expression expected 阈值 5 太高 旧 bug: \"在吗\"这种短对话只有2条用户消息，被过滤永不入库 -> 降到 2 cron 自引用过滤 旧 bug: cron prompt 中嵌有用户 ID，导致 cron 自己的 session 也被 grep 命中 修复: head -10 检查文件是否包含 [cron: 前缀，跳过自引用 脚本改进 所有脚本增加参数个数和内容校验 防止因参数不足产生幽灵记录 redis_memory_user.sh 用户名校验 启动时检测 USERNAME 是否仍为 \"your_username\" 占位符 防止误写入 memory:your_username cron_heartbeat_ping.sh 用户列表外部化 支持三种配置方式：环境变量 REDIS_MEMORY_USERS、配置文件 /etc/redis-memory-users.conf、硬编码数组 redis_memory.sh 新增命令 ping: 检查 Redis 连通性 stats: 统计各用户记忆天数/字符数 新增 scripts/extract_dialog.py 独立的 transcript 对话提取脚本，替代内嵌在 cron prompt 中的 python 代码 避免 shell 引号转义问题，同时便于论文引用 recent 命令上限 30 天 防止误传大数字导致遍历全部历史 文档更新 SKILL.md 和 README.md 全面重写： 架构图更新为 v3.1.1 实际流程 部署说明同步（timeout 从 120s 提到 180s，tools 限制为 exec,read） 新增完整的问题-方案对照表 已知限制 Redis 无持久化配置（RDB/AOF），重启后 7 天记忆丢失 耦合 OpenClaw transcript 文件路径，跨平台需适配 LLM 摘要去重缺少定量评估指标","fileCount":9,"zipByteSize":15496},{"version":"3.0.0","createdAt":"2026-05-24T11:00:16.653Z","changelog":"1. Fully Automatic Sync - v2.1: Agent Heartbeat-triggered writes, dependent on Session activity - v3.1: OpenClaw Cron takes over, runs every hour automatically. Agent does nothing. 2. Bypassed dmScope Isolation - v2.1: Heartbeat could only access the current Session's conversation. Writes skipped when Session was idle. - v3.1: Cron reads Transcript JSONL directly via filesystem (tail -200), no longer blocked by API-level isolation. 3. Semantic Deduplication - v2.1: No dedup — repeated triggers could write the same summary multiple times - v3.1: Compares new summary with existing one before writing; skips if the same information is already captured. 4. Meta-Instruction Filtering - v2.1: Summaries often contained debug text like \"sleep\", \"retrigger\", \"poll\" - v3.1: Prompt explicitly filters out technical and meta-instruction content 5. Memory Space Isolation - v2.1: Cron logs and heartbeats were written into the user's memory hash (141-entry pollution incident) - v3.1: Introduced `cron:health` as an isolated key. System data never mixes with user memory.6. Tool Restriction - v3.1 added `--tools exec,read,write,edit` to prevent recursive Cron execution or unintended API calls **7. Cron Prompt as Standalone File** - v2.1: Prompt was embedded in scripts, hard to maintain - v3.1: Extracted into `openclaw_cron_prompt.txt` for independent editing 1. 全自动同步 - v2.1：Agent Heartbeat 触发写入，依赖 Session 活跃状态 - v3.1：OpenClaw Cron 接管，每小时自动执行，Agent 完全零负担 2. 绕过 dmScope 隔离 - v2.1：通过 Heartbeat 直接访问当前 Session 对话，Session 不活跃时写不了 - v3.1：Cron 子 Session 通过文件系统直读 Transcript JSONL，用 tail -200 拿对话内容，不再受 API 隔离限制 3. 语义去重 - v2.1：无去重机制，多次触发可能重复写入相同摘要 - v3.1：写入前与现有摘要语义对比，相同信息跳过 4. 过滤元指令 - v2.1：摘要中常混入 \"sleep\"、\"再触发\"、\"poll\" 等技术调试内容 - v3.1：Prompt 明确要求过滤这类内容 5. 防污染 - v2.1：Cron 日志和系统心跳混入 user memory hash（141 条污染事件） - v3.1：引入 `cron:health` 隔离 Key，系统数据与用户记忆彻底分离 6. 工具限制 - v3.1 新增 `--tools exec,read,write,edit`，防止 Cron 递归触发或调用 API 7. Cron 模板化 - v2.1：Prompt 写在脚本里，改起来麻烦 - v3.1：抽成独立 `openclaw_cron_prompt.txt`，可独立编辑 I'm very sorry that the skills I created weren't debugged perfectly before release, and many of them are failing after going live. I'm going through this as well. But I hope everyone can be understanding and tolerant. I will continue developing under the MIT-0 license, and I also invite everyone to participate in tuning and improving them. -- hualang-c 我很抱歉我制作的技能因为之前没有调试完美，上线之后有很多失效的情况，我也正在经历这些，但希望大家可以包容，我将恪守mit-0协议继续制作，也请大家参与调优 --hualang-c","fileCount":9,"zipByteSize":12472},{"version":"2.1.0","createdAt":"2026-05-21T14:07:22.274Z","changelog":"🎉 v2.1 is here! Core improvement: Never lose memory again. 1️⃣ Activity Marker — Records session activity even without summaries. Checks on startup for unsynced data. 2️⃣ Startup Recovery — Auto-restores unsynced memory on session start. 3️⃣ Topic-Switch Auto-Write — Writes draft on topic change, not just at conversation end. Auto-writes every 30 min. 4️⃣ User-Specific Script — New redis_memory_user.sh with hardcoded username. One copy per user, never mix them up. 5️⃣ Enhanced Cron Script — New cron_heartbeat_ping.sh: writes activity marker + promotes draft + fallback report. 📦 New files: cron_heartbeat_ping.sh, redis_memory_user.sh 🔄 Updated: setup.sh, SKILL.md, README.md 🎉 v2.1 来了！核心改进：再也不丢记忆了。 更新内容： 1️⃣ Session 活跃标记 — 即使没写摘要，系统也会记录\"这个时间段 session 是活跃的\"，启动时主动检查。 2️⃣ 启动恢复检查 — 每次启动自动检查 activity 标记 + draft 内容，有未同步的记忆自动恢复。 3️⃣ 话题切换自动写 — 换话题就写 draft，不等到对话结束。对话超过30分钟自动写一次。 4️⃣ 用户专用脚本 — 新增 redis_memory_user.sh，硬编码用户名，一人一份永远不搞混。 5️⃣ 保底Cron脚本 — 新增 cron_heartbeat_ping.sh，每小时执行：写活跃标记 + 升级 draft + 兜底报告。 📦 新增文件：cron_heartbeat_ping.sh、redis_memory_user.sh 🔄 更新文件：setup.sh、SKILL.md、README.md","fileCount":7,"zipByteSize":11888}]},"execution":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No published capability contract is available yet."},"installCommand":"clawhub skill install s1737qdqxgbbd8gwrat1cmt0n9841b46:redis-memory-system","setupComplexity":"low","setupSteps":["Install using `clawhub skill install s1737qdqxgbbd8gwrat1cmt0n9841b46:redis-memory-system` in an isolated environment before connecting it to live workloads.","No published capability contract is available yet, so validate auth and request/response behavior manually.","Review the upstream CLAWHUB listing at https://clawhub.ai/hualang-c/redis-memory-system before using production credentials."],"contract":{"contractStatus":"missing","authModes":[],"requires":[],"forbidden":[],"supportsMcp":false,"supportsA2a":false,"supportsStreaming":false,"inputSchemaRef":null,"outputSchemaRef":null,"dataRegion":null,"contractUpdatedAt":null,"sourceUpdatedAt":null,"freshnessSeconds":null},"invocationGuide":{"preferredApi":{"snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-hualang-c-redis-memory-system/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-hualang-c-redis-memory-system/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-hualang-c-redis-memory-system/trust"},"curlExamples":["curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-hualang-c-redis-memory-system/snapshot\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-hualang-c-redis-memory-system/contract\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-hualang-c-redis-memory-system/trust\""],"jsonRequestTemplate":{"query":"summarize this repo","constraints":{"maxLatencyMs":2000,"protocolPreference":["OPENCLEW"]}},"jsonResponseTemplate":{"ok":true,"result":{"summary":"...","confidence":0.9},"meta":{"source":"CLAWHUB","generatedAt":"2026-10-10T17:35:50.698Z"}},"retryPolicy":{"maxAttempts":3,"backoffMs":[500,1500,3500],"retryableConditions":["HTTP_429","HTTP_503","NETWORK_TIMEOUT"]}},"endpoints":{"dossierUrl":"https://www.xpersona.co/api/v1/agents/clawhub-hualang-c-redis-memory-system/dossier","snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-hualang-c-redis-memory-system/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-hualang-c-redis-memory-system/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-hualang-c-redis-memory-system/trust"}},"reliability":{"evidence":{"source":"runtime-metrics","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No trust, reliability, or runtime telemetry is available."},"trust":{"status":"unavailable","handshakeStatus":"UNKNOWN","verificationFreshnessHours":null,"reputationScore":null,"p95LatencyMs":null,"successRate30d":null,"fallbackRate":null,"attempts30d":null,"trustUpdatedAt":null,"trustConfidence":"unknown","sourceUpdatedAt":null,"freshnessSeconds":null},"decisionGuardrails":{"doNotUseIf":["Contract metadata is missing or unavailable for deterministic execution."],"safeUseWhen":[],"riskFlags":["missing_or_unavailable_contract","trust_data_unavailable","schema_references_missing"],"operationalConfidence":"low"},"executionMetrics":{"observedLatencyMsP50":null,"observedLatencyMsP95":null,"estimatedCostUsd":null,"uptime30d":null,"rateLimitRpm":null,"rateLimitBurst":null,"lastVerifiedAt":null,"verificationSource":null},"runtimeMetrics":{"successRate":null,"avgLatencyMs":null,"avgCostUsd":null,"hallucinationRate":null,"retryRate":null,"disputeRate":null,"p50Latency":null,"p95Latency":null,"lastUpdated":null}},"benchmarks":{"evidence":{"source":"no-benchmark-data","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No benchmark suites or observed failure patterns are available."},"suites":[],"failurePatterns":[]},"artifacts":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-10T15:18:07.513Z","emptyReason":null},"readme":"Skill: redis-memory-system\n\nOwner: hualang-c\n\nSummary: 跨会话自动记忆系统 v3.3.0 — 单脚本+配置驱动+语义标签索引。支持标签检索、倒排索引、语义搜索。\n\nTags: latest:3.3.0\n\nVersion history:\n\nv3.3.0 | 2026-05-27T01:09:06.544Z | user\n\n- **Version bump:** Unified version numbering to v3.3.0 across all files\n- **Fix:** sync now uses transcript file mtime for date key, preventing date misassignment on conversations spanning midnight\n- **Cleanup:** Removed deprecated `openclaw_cron_prompt.txt` (unused since v3.2); updated SKILL.md file table, rewrote setup.sh to remove references to non-existent scripts\n- **Security:** Zero hardcoded info, no personal data exposure\n\n- **版本统一：** 清理版本号混乱，统一跳至 v3.3.0\n- **修复：** sync 改用 transcript 文件修改时间确定日期 key，避免跨夜对话写入错误日期\n- **清理：** 删除废弃的 `openclaw_cron_prompt.txt`（v3.2 后弃用）；更新 SKILL.md 文件表、重写 setup.sh 移除非现存脚本引用\n- **安全：** 零硬编码，无个人信息泄露\n\nv3.2.4 | 2026-05-26T05:27:18.195Z | user\n\nOptimized Examples\n优化示例\n\nv3.2.3 | 2026-05-26T00:36:48.873Z | user\n\nedis-memory-system v3.2.3 \n What's New in v3.2.3\n1. Semantic Tag System (LLM-Generated)\nEvery hourly sync now generates 5 concept-level tags per session via LLM, stored as Redis Set inverted indices. This replaces vector DB dependency with a zero-dependency lightweight alternative.\n2. New Commands: tag & search\nmemory.sh tag — View tags for a specific date — memory.sh search [tag2 ...] — Intersection-based multi-tag lookup across dates Both commands pull from clean, automatically maintained tag indices.\n3. Full Chain Verified\nSingle-tag lookup, multi-tag intersection (AND), combined tag+summary queries — all tested and passing in production.\n4. Product Philosophy Locked\nLightweight. Zero burden. Config-driven. Serving individual developers — not enterprise complexity. No vector DB, no external dependencies beyond Redis.\nv3.2.3 completes the semantic layer without adding a single pound of weight. The system remains: 1 config file, 1 script, Redis.\nCN — v3.2.3 更新内容\n1. 语义标签系统（LLM 自动生成）\n每轮自动同步时，LLM 会为会话生成 5 个概念级标签，存入 Redis Set 倒排索引。完全替代向量数据库方案，零额外依赖。\n2. 新增命令：tag & search\n— memory.sh tag <用户名> <日期>— 查看某天的标签 — memory.sh search <用户名> <标签1> [标签2 ...] — 多标签交集检索 数据由 cron 自动维护，无需手动干预。\n3. 全链路验证通过\n单标签查询、多标签交集（AND）、标签+摘要联合检索——生产环境实测全部通过。\n4. 产品理念落地\n轻量、零负担、配置驱动。只服务个体开发者，不做企业级复杂。无向量库，无额外依赖，Redis 就够了。\nv3.2.3 给记忆系统加上了语义层，但没增加一斤重量。依然是一个脚本、一个配置、Redis。\n版本路线 v3.1 — Cron 全自动同步 + 直读 transcript 绕过 dmScope 隔离 v3.2.1 — 6 脚本合并为 1 个 memory.sh，配置驱动替代硬编码 v3.2.3 — 语义标签系统上线（标签 + 倒排索引 + 多标签检索）\n\nv3.2.2 | 2026-05-25T11:56:54.350Z | user\n\n- Single `memory.sh` replaces all legacy scripts — unified entry for sync/get/set/heartbeat/stats\n- Configuration-driven: usernames managed via `/etc/memory-users.conf`, no code changes needed\n- `sync` outputs structured JSON; the cron LLM only handles summarization decisions\n- Language-agnostic self-reference filter (`*memory.sh*sync*`)\n- `{{SCRIPTS_DIR}}` placeholder replaces hardcoded paths, resolved by setup\n- Heartbeat cron auto-registered, monitors for missing summaries and writes alert flags\n- Per-user distributed locks enabling parallel sync for multiple users\n\n- 单脚本 memory.sh 替代全部旧脚本，sync/get/set/heartbeat/stats 统一入口\n- 配置驱动，用户名通过 /etc/memory-users.conf 管理，加用户不改代码\n- sync 输出结构化 JSON，cron 的 LLM 只做总结决策\n- 自引用过滤语言无关（*memory.sh*sync*），中英文环境通用\n- {{SCRIPTS_DIR}} 占位符替代硬编码路径，setup 自动替换\n- 心跳 cron 自动注册，检测摘要丢失并写告警文件\n- 锁细化到用户级，多用户可并行同步\n\nv3.2.1 | 2026-05-25T11:38:33.742Z | user\n\nMajor Release — Complete Architecture Refactoring\nv3.2 is not a minor patch. It's a ground-up redesign of the entire memory synchronization system.\nWhat changed:\n- 6 scripts consolidated into a single `memory.sh` — sync / get / set / heartbeat / stats all in one place\n- Configuration-driven: all usernames managed via `/etc/memory-users.conf`, no code changes needed to add users\n- `sync` command outputs structured JSON; the cron LLM only handles summarization decisions, no more shell output parsing\n- Self-reference filter: cron sessions no longer pollute their own memory data\n- Per-user distributed locks enabling parallel sync for multiple users\nUpgrading from v3.1? The old scripts (redis_memory.sh, cron_heartbeat_ping.sh, etc.) are deprecated. Everything is now managed by `memory.sh`. Clean up old files before installation.\n\n重大更新 — 架构完全重构\nv3.2 不是一次小修小补，而是从设计理念到代码实现的全盘重做。\n核心变化：\n- 6 个脚本合并为 1 个 memory.sh，sync/get/set/heartbeat/stats 全部内置\n- 配置文件驱动，所有用户名通过 /etc/memory-users.conf 管理，加用户不改代码\n- sync 命令输出结构化 JSON，cron 的 LLM 只需做总结决策，不再解析原始 shell 输出\n- 自引用过滤：cron session 不再污染自己的记忆数据\n- 锁细化到用户级，多用户可并行同步\n从 v3.1 升级的用户注意：旧版脚本（redis_memory.sh / cron_heartbeat_ping.sh 等）已废弃，全部由 memory.sh 统一接管。安装前建议清理旧文件。\n\nv3.1.1 | 2026-05-25T10:10:48.129Z | user\n\nredis-memory-system v3.1.1 Changelog\n2026-05-25\n\nCore Architecture Changes\nMerged exec calls\n\nFile search + conversation extraction + Redis deduplication combined into a single script.\n\nEliminates variable loss across processes caused by the three independent exec steps in v3.1.\n\nAtomic Redis writes\n\nReplaces three separate redis-cli calls with a Lua EVAL script.\n\nHSET + EXPIRE + SET last_seen completed in one transaction.\n\nPrevents data inconsistency if a crash occurs midway.\n\nDistributed lock\n\nSET NX EX 600 prevents two cron jobs from writing simultaneously.\n\ntrap cleanup EXIT ensures the lock is automatically released when the script exits.\n\nRetry mechanism\n\nWhen file reading fails, retry up to 2 times with a 1‑second interval.\n\nFixed Bugs\nFile selection: most matches → latest by modification time\n\nOld bug: an old file from May 8th with 29 matches would override a new session from today with 28 matches, causing missed memories.\n\nFix: use ls -t to pick the most recently modified file.\n\nShell syntax errors do not abort the script\n\nOld bug: when grep -c returned empty, shell would error with [: 0: integer expression expected.\n\nFix: proper handling of empty return values.\n\nThreshold of 5 was too high\n\nOld bug: short dialogs like “Are you there?” (only 2 user messages) were filtered out and never stored.\n\nFix: lowered threshold to 2.\n\nCron self‑reference filtering\n\nOld bug: the cron prompt contained a user ID, so cron’s own session was also matched by grep.\n\nFix: head -10 checks if the file contains the [cron: prefix and skips self‑referencing files.\n\nScript Improvements\nAll scripts now validate argument count and content to prevent ghost records from insufficient parameters.\n\nredis_memory_user.sh username validation\n\nAt startup, checks whether USERNAME is still the placeholder \"your_username\" to prevent accidentally writing to memory:your_username.\n\ncron_heartbeat_ping.sh externalised user list\n\nSupports three configuration methods: environment variable REDIS_MEMORY_USERS, configuration file /etc/redis-memory-users.conf, or a hardcoded array.\n\nNew commands in redis_memory.sh\n\nping: check Redis connectivity.\n\nstats: count memory days and characters per user.\n\nNew standalone script scripts/extract_dialog.py\n\nReplaces the Python code previously embedded in the cron prompt for transcript conversation extraction.\n\nAvoids shell quoting issues and makes it easier to cite in papers.\n\nrecent command upper limit of 30 days\n\nPrevents accidentally traversing the entire history when a large number is passed.\n\nDocumentation Updates\nSKILL.md and README.md completely rewritten:\n\nArchitecture diagram updated to reflect the actual v3.1.1 flow.\n\nDeployment notes synchronised (timeout raised from 120 s to 180 s, tool restrictions set to exec,read).\n\nAdded a complete problem‑solution mapping table.\n\nKnown Limitations\nRedis has no persistence configured (RDB/AOF). Restarting Redis loses the last 7 days of memories.\n\nTied to OpenClaw’s transcript file path; adapting to other platforms requires changes.\n\nNo quantitative evaluation metric for LLM summary deduplication.\n\nredis-memory-system v3.1.1 更新日志 2026-05-25\n\n核心架构改动\n\n合并 exec 调用\n文件查找 + 对话提取 + Redis 查重合并为一个脚本\n消除原 v3.1 三步独立 exec 导致的变量跨进程丢失\n\nRedis 原子写入\n用 Lua EVAL 脚本替代三次独立 redis-cli 调用\nHSET + EXPIRE + SET last_seen 在同一个事务中完成\n半路崩溃不会产生数据不一致\n\n分布式锁\nSET NX EX 600 防止两个 cron 同时写入\ntrap cleanup EXIT 保证锁在脚本退出时自动释放\n\n重试机制\n文件读取失败时最多重试 2 次，间隔 1 秒\n\n修复的 bug\n\n找文件按匹配数取最多 -> 改为 ls -t 按修改时间取最新\n旧 bug: 5月8号旧文件有29条匹配，碾压了今天新session的28条，导致记忆漏写\n\nshell 语法报错不中断\n旧 bug: grep -c 返回空时，shell 报 [: 0: integer expression expected\n\n阈值 5 太高\n旧 bug: \"在吗\"这种短对话只有2条用户消息，被过滤永不入库 -> 降到 2\n\ncron 自引用过滤\n旧 bug: cron prompt 中嵌有用户 ID，导致 cron 自己的 session 也被 grep 命中\n修复: head -10 检查文件是否包含 [cron: 前缀，跳过自引用\n\n脚本改进\n\n所有脚本增加参数个数和内容校验\n防止因参数不足产生幽灵记录\n\nredis_memory_user.sh 用户名校验\n启动时检测 USERNAME 是否仍为 \"your_username\" 占位符\n防止误写入 memory:your_username\n\ncron_heartbeat_ping.sh 用户列表外部化\n支持三种配置方式：环境变量 REDIS_MEMORY_USERS、配置文件 /etc/redis-memory-users.conf、硬编码数组\n\nredis_memory.sh 新增命令\nping: 检查 Redis 连通性\nstats: 统计各用户记忆天数/字符数\n\n新增 scripts/extract_dialog.py\n独立的 transcript 对话提取脚本，替代内嵌在 cron prompt 中的 python 代码\n避免 shell 引号转义问题，同时便于论文引用\n\nrecent 命令上限 30 天\n防止误传大数字导致遍历全部历史\n\n文档更新\n\nSKILL.md 和 README.md 全面重写：\n\n架构图更新为 v3.1.1 实际流程\n\n部署说明同步（timeout 从 120s 提到 180s，tools 限制为 exec,read）\n\n新增完整的问题-方案对照表\n\n已知限制\n\nRedis 无持久化配置（RDB/AOF），重启后 7 天记忆丢失\n\n耦合 OpenClaw transcript 文件路径，跨平台需适配\n\nLLM 摘要去重缺少定量评估指标\n\nv3.0.0 | 2026-05-24T11:00:16.653Z | user\n\n1. Fully Automatic Sync\n- v2.1: Agent Heartbeat-triggered writes, dependent on Session activity\n- v3.1: OpenClaw Cron takes over, runs every hour automatically. Agent does nothing.\n2. Bypassed dmScope Isolation\n- v2.1: Heartbeat could only access the current Session's conversation. Writes skipped when Session was idle.\n- v3.1: Cron reads Transcript JSONL directly via filesystem (tail -200), no longer blocked by API-level isolation.\n3. Semantic Deduplication\n- v2.1: No dedup — repeated triggers could write the same summary multiple times\n- v3.1: Compares new summary with existing one before writing; skips if the same information is already captured.\n4. Meta-Instruction Filtering\n- v2.1: Summaries often contained debug text like \"sleep\", \"retrigger\", \"poll\"\n- v3.1: Prompt explicitly filters out technical and meta-instruction content\n5. Memory Space Isolation\n- v2.1: Cron logs and heartbeats were written into the user's memory hash (141-entry pollution incident)\n- v3.1: Introduced `cron:health` as an isolated key. System data never mixes with user memory.6. Tool Restriction\n- v3.1 added `--tools exec,read,write,edit` to prevent recursive Cron execution or unintended API calls\n**7. Cron Prompt as Standalone File**\n- v2.1: Prompt was embedded in scripts, hard to maintain\n- v3.1: Extracted into `openclaw_cron_prompt.txt` for independent editing\n1. 全自动同步\n- v2.1：Agent Heartbeat 触发写入，依赖 Session 活跃状态\n- v3.1：OpenClaw Cron 接管，每小时自动执行，Agent 完全零负担\n2. 绕过 dmScope 隔离\n- v2.1：通过 Heartbeat 直接访问当前 Session 对话，Session 不活跃时写不了\n- v3.1：Cron 子 Session 通过文件系统直读 Transcript JSONL，用 tail -200 拿对话内容，不再受 API 隔离限制\n3. 语义去重\n- v2.1：无去重机制，多次触发可能重复写入相同摘要\n- v3.1：写入前与现有摘要语义对比，相同信息跳过\n4. 过滤元指令\n- v2.1：摘要中常混入 \"sleep\"、\"再触发\"、\"poll\" 等技术调试内容\n- v3.1：Prompt 明确要求过滤这类内容\n5. 防污染\n- v2.1：Cron 日志和系统心跳混入 user memory hash（141 条污染事件）\n- v3.1：引入 `cron:health` 隔离 Key，系统数据与用户记忆彻底分离\n6. 工具限制\n- v3.1 新增 `--tools exec,read,write,edit`，防止 Cron 递归触发或调用 API\n7. Cron 模板化\n- v2.1：Prompt 写在脚本里，改起来麻烦\n- v3.1：抽成独立 `openclaw_cron_prompt.txt`，可独立编辑\n\nI'm very sorry that the skills I created weren't debugged perfectly before release, and many of them are failing after going \nlive. I'm going through this as well. But I hope everyone can be understanding and tolerant. I will continue developing under the MIT-0 license, and I also invite everyone to participate in tuning and improving them.\n-- hualang-c\n\n我很抱歉我制作的技能因为之前没有调试完美，上线之后有很多失效的情况，我也正在经历这些，但希望大家可以包容，我将恪守mit-0协议继续制作，也请大家参与调优 \n--hualang-c\n\nv2.1.0 | 2026-05-21T14:07:22.274Z | user\n\n🎉 v2.1 is here! Core improvement: Never lose memory again.\n1️⃣ Activity Marker — Records session activity even without summaries. Checks on startup for unsynced data.\n2️⃣ Startup Recovery — Auto-restores unsynced memory on session start.\n3️⃣ Topic-Switch Auto-Write — Writes draft on topic change, not just at conversation end. Auto-writes every 30 min.\n4️⃣ User-Specific Script — New redis_memory_user.sh with hardcoded username. One copy per user, never mix them up.\n5️⃣ Enhanced Cron Script — New cron_heartbeat_ping.sh: writes activity marker + promotes draft + fallback report.\n📦 New files: cron_heartbeat_ping.sh, redis_memory_user.sh 🔄 Updated: setup.sh, SKILL.md, README.md\n\n🎉 v2.1 来了！核心改进：再也不丢记忆了。\n更新内容：\n1️⃣ Session 活跃标记 — 即使没写摘要，系统也会记录\"这个时间段 session 是活跃的\"，启动时主动检查。\n2️⃣ 启动恢复检查 — 每次启动自动检查 activity 标记 + draft 内容，有未同步的记忆自动恢复。\n3️⃣ 话题切换自动写 — 换话题就写 draft，不等到对话结束。对话超过30分钟自动写一次。\n4️⃣ 用户专用脚本 — 新增 redis_memory_user.sh，硬编码用户名，一人一份永远不搞混。\n5️⃣ 保底Cron脚本 — 新增 cron_heartbeat_ping.sh，每小时执行：写活跃标记 + 升级 draft + 兜底报告。\n📦 新增文件：cron_heartbeat_ping.sh、redis_memory_user.sh 🔄 更新文件：setup.sh、SKILL.md、README.md\n\nv2.0.0 | 2026-05-19T01:43:05.524Z | user\n\n🔧 Bug Fixes\nFix memory loss on session reset — Heartbeat was silently idling due to target:none config, never writing conversation summaries to Redis. Changed to target:last with a triple-layer write architecture; any single layer succeeding guarantees persistence.\nFix cron writing timestamps only — The system cron was only writing heartbeat pings every hour without promoting draft summaries to permanent storage. Rewritten to auto-detect draft::summary keys and upgrade them to memory::YYYY-MM-DD with 7-day TTL.\nFix complete memory loss after session recycling — OpenClaw's 4:00 AM reset, 120-minute idle reset, and 24-hour no-interaction recycle wiped all conversation history. Solved with a triple-layer architecture where each layer operates independently.\nFix cross-user data leakage risk — Shared scripts between different users could accidentally read each other's memory. Added redis_memory_isolated.sh for strict isolation with hard rules prohibiting cross-user access without explicit authorization.\n⚡ Improvements\nTriple-layer write architecture: Agent → draft key (12h TTL) → System Cron(hourly) + OpenClaw Cron(every 2h) + Heartbeat(every 2h) → Permanent storage(7 days)\nDraft key bridge: draft::summary acts as an intermediate layer with 12-hour auto-expiry; zero garbage even if all cron jobs fail\nZero token cost: Entire pipeline runs on Redis + Shell scripts — no API tokens consumed\nMulti-user isolation: Dual scripts + separate key namespaces; physical data separation between users; cross-user access requires explicit authorization\n7-day auto-expiry: No manual cleanup needed; Redis TTL 604800s automatically evicts stale data\n\n🔧 问题修复\n修复记忆写入丢失 — Heartbeat 因 target:none 配置静默空跑，对话摘要从未写入 Redis。改为 target:last + 三层写入保障，任意一层成功即保底。\n修复 Cron 只打卡不存内容 — 系统 cron 每小时仅写入时间戳打卡，未将对话草稿升级为永久记录。重写为自动检测 draft:<用户>:summary key，有内容则升级为 memory:<用户>:YYYY-MM-DD 永久存储。\n修复 Session 重置失忆 — OpenClaw 凌晨 4:00 重置 / 120 分钟空闲重置 / 24 小时无交互后，对话历史完全丢失。新增三层铁壁架构解决，每一层独立工作，互不依赖。\n修复跨用户数据泄露风险 — 不同用户使用同一脚本可能导致记忆串读。新增 redis_memory_isolated.sh 隔离版 + 铁律规则，严格禁止跨用户访问。\n⚡ 优化\n三层铁壁写入架构：对话中 → draft key (12h TTL) → 系统 Cron(每小时) + OpenClaw Cron(每2h) + Heartbeat(每2h) → 永久存储(7天)\nDraft key 桥接：draft:<用户>:summary 作为中间层，12 小时自动过期，即使所有定时任务都失败也不会留垃圾数据\n零 Token 成本：全链路基于 Redis + Shell 脚本实现，不消耗任何 API Token\n多用户隔离：双脚本 + 双 key 空间，各用户数据物理隔离，需主动授权才能跨查\n7 天自动过期：无需手动清理，Redis TTL 604800 秒自动淘汰旧数据\n\nv1.0.3 | 2026-05-17T05:47:40.262Z | user\n\n中文介绍更新：\n🧠 Redis Memory System — 跨 Session 短期记忆，开箱即用\n一行命令安装，自动读写 Redis，无需手动配置。让 OpenClaw Agent 跨 session 记得你是谁。\n安装：\nchmod +x scripts/setup.sh && bash scripts/setup.sh\n安装后自动：\n📖 Session 启动时自动读取 — 通过 .bootstrap 机制加载近期记忆\n✍️ 每小时 cron 保底写入 — 即使会话意外中断也不丢数据\n🧹 对话结束时自动摘要写入 — 三层保障，零维护\n特性：\n🔹 7 天 TTL，自动过期不撑磁盘\n🔹 多账号隔离，双脚本设计\n🔹 参数强校验，健壮可靠\n🔹 独立于 Session 生命周期\nEnglish Description Update:\n🧠 Redis Memory System — Zero-config cross-session memory for OpenClaw agents.\nOne command to install, zero manual config. Your agent automatically remembers conversations across session resets.\nInstall:\nchmod +x scripts/setup.sh && bash scripts/setup.sh\nAfter install, everything runs automatically:\n📖 Auto-read at session start — Bootstrap loads Redis context before the first reply\n✍️ Hourly cron backup — Independent timestamp writes, survives crashes\n🧹 Auto-summary on conversation end — Three-layer protection, zero maintenance\nFeatures:\n🔹 7-day auto-expiring TTL, no disk bloat\n🔹 Multi-user isolation with dual scripts\n🔹 Strict parameter validation\n🔹 Independent of OpenClaw session lifecycle\n\nv1.0.1 | 2026-05-17T04:16:03.058Z | user\n\n中文介绍：\n🧠 Redis Memory System — 跨 Session 短期记忆，给 Agent 装上\"短期记忆海马体\"\nOpenClaw Agent 每次会话被回收后（04:00框架重置 / 120分钟空闲 / 24小时平台超时），都会像失忆一样醒来。这套系统在会话之外增加了一层 Redis 存储，让 Agent 醒来第一时间知道你昨天聊了什么。\n工作原理 每次对话结束时，Agent 自动将当日对话摘要写入 Redis Hash，KEY 级 TTL 设为 7 天。下次 Session 启动时，SOUL.md 铁律强制先查 Redis 再回话——从\"我是谁\"到\"我们聊到哪了\"，全程衔接。\n核心特性\n🔹 跨 session 记忆保持 — 不依赖框架层的上下文持久化，独立于 Session 生命周期\n🔹 多账号数据隔离 — 同一进程服务多位用户时，memory:账号A 和 memory:账号B 是独立的 Hash key，双脚本+SOUL 铁律双重保障\n🔹 Heartbeat 自动续写保底 — 即使对话意外中断（断网/崩溃/超时），下一次 Heartbeat Poll 会自动检查并写入摘要，零数据丢失\n🔹 7 天 TTL 自动过期 — 短期记忆就该自动遗忘。不撑磁盘、不需维护、不留隐私隐患\n🔹 双脚本设计 — 通用版 redismemory.sh 适合单用户/互信多用户场景；隔离版 redismemoryisolated.sh 通过 REDISMEMORY_USER 环境变量硬编码用户身份，防止跨账号误操作\n🔹 参数强校验 — set -euo pipefail 保障脚本健壮性，日期格式与有效性双重校验（YYYY-MM-DD + date -d 验证），缺参友好提示\n🔹 操作审计 — 独立的 actions:system Hash 记录下载文件、安装软件等后台操作，解决\"谁干的\"溯源问题\n🔹 轻量极致 — 每条记忆仅 0.5~2KB，代理端无需额外依赖，只需 Redis-server 运行在 localhost:6379\n与官方 MEMORY.md 的区别 官方 OpenClaw 提供文件式 MEMORY.md（长期）和 memory_search（语义检索），但依赖会话上下文写入。这套系统在文件层之外增加了一层 Redis——7天窗口内的记忆自动存活，不需要手动提炼。两套互补：Redis 管\"短期不忘\"，MEMORY.md 管\"长期不朽\"。\nEnglish Description:\n🧠 Redis Memory System — Cross-session short-term memory for OpenClaw agents. Think of it as a hippocampus for your AI.\nOpenClaw agents lose session context at predictable boundaries: daily framework reset (04:00), idle timeout (120 min), and platform-level disconnection (24h). Without external memory, every new session starts from scratch — the agent has no idea what you talked about yesterday. This system bridges that gap with a lightweight Redis layer that preserves daily conversation summaries across session boundaries.\nHow it works When a conversation ends, the agent automatically writes a daily summary to a Redis Hash keyed by user and date (memory: → YYYY-MM-DD). Each key has a 7-day TTL. On every new session start, SOUL.md iron rules force the agent to query Redis before responding to the user — transforming \"Who am I talking to?\" into \"We were discussing X yesterday, let's pick up from there.\"\nKey Features\n🔹 Cross-session persistence — Survives framework resets, idle timeouts, and platform disconnections. Independent of OpenClaw's session lifecycle\n🔹 Multi-user isolation — memory:userA and memory:userB are separate Redis Hash keys within the same instance. Dual-script architecture + SOUL.md behavioral rules create defense in depth against data leakage\n🔹 Heartbeat auto-save fallback — If a conversation cuts off unexpectedly (network drop, crash, timeout), the next Heartbeat poll automatically checks for unsaved context and writes it. Zero data loss by design\n🔹 7-day TTL auto-expire — Short-term memory should forget by default. No disk bloat, no manual cleanup, no privacy residue\n🔹 Dual scripts — redis_memory.sh (general purpose) for single-user or trusted multi-user scenarios; redis_memory_isolated.sh (sandboxed) enforces a fixed username via REDIS_MEMORY_USER environment variable, preventing accidental cross-user writes\n🔹 Strict validation — set -euo pipefail for script-level robustness; dual-layer date validation (regex format check + date -d existence check); friendly error messages for missing arguments\n🔹 Action audit trail — A separate actions:system Hash records system operations (file downloads, software installs), answering \"Who did what and when?\"\n🔹 Extremely lightweight — ~0.5–2KB per memory entry. No agent-side dependencies beyond a running Redis-server on localhost:6379\nvs. OpenClaw's built-in MEMORY.md OpenClaw's official memory system uses file-based MEMORY.md (long-term) and semantic search (memory_search/memory_get), but relies on in-session context for writes. This skill adds a Redis layer beneath it — day-level summaries survive automatically within the 7-day window without manual curation. The two complement each other: Redis handles \"don't forget what we just talked about,\" MEMORY.md handles \"remember this forever.\"\n\nv1.0.0 | 2026-05-17T03:37:25.407Z | user\n\n## 1.0.0 - 2026-05-17\n\n### Added\n- Redis-backed cross-session memory for OpenClaw agents\n- 7-day TTL auto-expiry for all memory keys\n- Multi-user memory isolation on single Redis instance\n- Heartbeat-based auto-saving (prevents memory loss on interruptions)\n- System operation audit log (actions:system)\n- Two scripts: `redis_memory.sh` (multi‑user) and `redis_memory_isolated.sh` (fully isolated)\n## 1.0.0 - 2026-05-17\n\n### 新增\n- 为 OpenClaw 智能体提供基于 Redis 的跨会话记忆\n- 所有记忆键支持 7 天 TTL 自动过期\n- 单 Redis 实例实现多用户记忆隔离\n- 基于心跳的自动保存（防止因中断丢失近期记忆）\n- 系统操作审计日志（actions:system）\n- 提供两个脚本：`redis_memory.sh`（多用户版）和 `redis_memory_isolated.sh`（完全隔离版）\n\nArchive index:\n\nArchive v3.3.0: 7 files, 12986 bytes\n\nFiles: _meta.json (138b), README.md (1726b), scripts/extract_dialog.py (1935b), scripts/memory.sh (10865b), scripts/setup.sh (2827b), skill-card.md (2178b), SKILL.md (8712b)\n\nFile v3.3.0:SKILL.md\n\n---\nname: redis-memory-system\ndescription: \"跨会话自动记忆系统 v3.3.0 — 单脚本+配置驱动+语义标签索引。支持标签检索、倒排索引、语义搜索。\"\n---\n\n# Redis 记忆系统 v3.3.0\n\n**核心思路：Agent 零负担，系统自动完成。cron 子 session 绕过 dmScope 限制，通过文件系统直读 transcript。**\n\n## 架构\n\n```\n┌──────────────────────────────────────────────────────┐\n│ OpenClaw Cron (每1h, isolated session) │\n│ │\n│ ① 分布式锁 (SET NX EX 600) 防并发 │\n│ ② ls -t 找最新 transcript 文件（排除cron自引用） │\n│ ③ extract_dialog.py 提取末尾200行对话 │\n│ ④ LLM 语义去重 + 摘要生成 │\n│ ⑤ Lua EVAL 原子写入（HSET+EXPIRE+last_seen） │\n│ ⑥ 锁释放 │\n└───────────────────────┬──────────────────────────────┘\n │\n┌───────────────────────┴──────────────────────────────┐\n│ 系统 Cron (每1h) — 监控哨兵 │\n│ │\n│ ① 心跳写入隔离 key: cron:health │\n│ ② 逐用户检查 memory:<用户> 今天有无摘要 │\n│ ③ 异常时写告警 flag 到 /tmp/ │\n└───────────────────────┬──────────────────────────────┘\n │\n┌───────────────────────┴──────────────────────────────┐\n│ Agent Session 启动时 │\n│ │\n│ redis_memory.sh get <用户> → 查最近3天 │\n│ cat /tmp/*.flag → 检查告警 │\n└──────────────────────────────────────────────────────┘\n```\n\n## 关键解决的问题\n\n| 问题 | 方案 |\n|------|------|\n| dmScope 隔离导致 cron 子 session 看不到主会话 | 文件系统直读 transcript JSONL |\n| exec 间变量丢失（各自独立 shell） | 合并为单个 exec 脚本，变量只在进程内传递 |\n| 重复追加相同摘要 | LLM 语义去重—新旧摘要表达相同信息时跳过 |\n| cron 污染 memory hash | cron 心跳写到隔离 key `cron:health` |\n| 并发执行风险 | Redis SET NX EX 分布式锁，防止两个 cron 同时写 |\n| 非原子写入（HSET+EXPIRE 分开执行） | Lua 脚本（EVAL）保证一个事务内完成全部操作 |\n| 文件查找顺序错误 | `ls -t` 按修改时间取最新，而非按匹配数 |\n\n## 文件说明\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/memory.sh` | 核心脚本：sync / get / set / tag / search / heartbeat / ping / stats |\n| `scripts/extract_dialog.py` | transcript 对话提取工具 |\n| `scripts/setup.sh` | 一键安装（Redis + 脚本 + 系统cron） |\n\n\n## 🔑 Redis Key 设计\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:<用户名>` | Hash | 7天 | 每日对话摘要，field=日期，value=文本 |\n| `cron:health` | Hash | 7天 | 系统心跳（隔离，不污染记忆数据） |\n| `activity:<用户名>:last_seen` | String | 12h | 最后活跃时间标记 |\n| `cron_lock:memory_sync` | String | 10min | 分布式锁，防并发 |\n\n## 部署 / Deployment\n\n### 1. 基础安装 / Setup\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n### 2. 创建 OpenClaw cron（核心 / Core）\n\n```bash\n# Create auto-sync cron job (runs every 1h)\n# 创建每 1 小时自动同步的 cron 任务\n\nPROMPT=$(cat scripts/openclaw_cron_prompt.txt)\nopenclaw cron add \\\n --name \"memory-auto-sync\" \\\n --every 1h \\\n --session isolated \\\n --timeout-seconds 180 \\\n --thinking minimal \\\n --tools \"exec,read\" \\\n --no-deliver \\\n --message \"$PROMPT\"\n```\n\n**重要 / Important：**\n- `--tools \"exec,read\"` — restricts cron to script execution & file reading only, prevents recursive tool triggers\n- 限制 cron 只能执行脚本和读文件，防止递归触发其他工具\n- `--session isolated` — runs cron in an isolated container, won't affect main session context\n- 确保 cron 在独立容器跑，不影响主会话\n\n## Session 启动检查 / Session Startup Check\n\n每次新 session 启动时加载近期记忆。\nLoad recent memory on each new session start:\n\n```bash\n# Read last 3 days of memory\n# 读取最近 3 天的记忆\nbash scripts/memory.sh get \n\n# Check for memory loss warnings\n# 检查是否有记忆丢失告警\ncat /tmp/memory_warning_.flag 2>/dev/null\n```\n\n### 日常运维命令 / Daily Operations\n\n```bash\n# Check Redis connection · 检查 Redis 连通性\nbash scripts/memory.sh ping\n\n# View system overview · 查看系统概览\nbash scripts/memory.sh stats\n\n# Read user memory (last 3 days) · 查用户记忆（最近 3 天）\nbash scripts/memory.sh get \n\n# Read memory for a specific date · 查指定日期记忆\nbash scripts/memory.sh get 2026-05-26\n\n# Search by semantic tags · 按语义标签搜索\nbash scripts/memory.sh search \n\n# Manually write a summary · 手动写入摘要\nbash scripts/memory.sh set 2026-05-26 \"Summary text here\"\n\n## v3.2.3 相比 v3.2 的改动（2026-05-26）\n\n#### 语义标签索引（v3.2.3 新增）\n- **LLM 语义标签：** cron 同步时自动提取 5 个概念级标签，替代向量检索\n- **倒排索引：** `tagidx:<标签>` → 日期集合，Redis SINTER O(1) 查询\n- **标签搜索：** `memory.sh search <关键词>` 配合 Agent 语义匹配\n- **零额外内存：** 不用 embedding 模型和向量数据库，每日标签仅占 ~200 字节\n\n### 核心架构改动\n- **合并exec调用：** 文件查找+对话提取+Redis查重合并为一个脚本，变量不会跨exec丢失（原v3.1三步分离，变量会在独立shell中丢失）\n- **Redis原子写入：** 用 Lua 脚本（`EVAL`）替代三次独立 `redis-cli` 调用，保证 HSET + EXPIRE + SET last_seen 在同一事务中完成\n- **分布式锁：** `SET NX EX 600` 防并发，cron 卡住时最长600秒自动释放（`trap cleanup EXIT` 保底）\n- **重试机制：** 文件读取失败时最多重试 2 次，间隔 1 秒\n\n### 修复的 bug\n- **找文件：** 从按匹配数取最多改为按 `ls -t` 修改时间取最新，避免旧文件碾压新 session\n- **shell语法：** `grep -c` 后加 `|| echo 0` 兜底，消除 `[: 0: integer expression expected`\n- **阈值：** 从 5 降到 2，短对话也能被收录\n\n### 脚本改进\n- **参数校验完善：** 所有脚本增加参数个数和内容校验，防止因参数不足产生幽灵记录\n- **用户名校验：** `redis_memory_user.sh` 启动时检测 USERNAME 是否仍为占位符，防止写入 `memory:your_username`\n- **用户列表外部化：** `cron_heartbeat_ping.sh` 支持环境变量 `REDIS_MEMORY_USERS`、配置文件 `/etc/redis-memory-users.conf` 或硬编码数组三种方式\n- **redis_memory.sh 新增：** `ping` 命令（检查Redis连通性）、`stats` 命令（统计各用户记忆天数/字符数）\n- **天数限制：** `recent` 命令上限 30 天，防止误传大数字导致遍历全部历史\n\n## 版本历史\n\n- v1.0 (2026-05-16) — 基础 Redis 记忆存储\n- v1.1 (2026-05-17) — 多用户隔离 + SOUL 铁律\n- v2.0 (2026-05-20) — draft 机制 + 三层保底 + 启动恢复\n- v2.1 (2026-05-21) — cron 脚本增强 + 用户专用脚本\n- v3.0 (2026-05-23) — 系统自动读会话写摘要，Agent 零负担\n- **v3.1 (2026-05-23) — 修复 dmScope 隔离问题，改用文件路径；增加去重/过滤逻辑**\n- **v3.1.1 (2026-05-25) — 架构大修：合并exec、Lua原子写入、分布式锁、重试机制**\n- **v3.2 (2026-05-25) — 单脚本+配置驱动+JSON输出**\n- **v3.2.3 (2026-05-26) — 语义标签索引 + 倒排检索 + 标签搜索**\n- **v3.3.0 (2026-05-27) — 统一版本号；修复跨夜日期写入错误：sync改用transcript文件修改时间确定日期key，避免凌晨写入时日期错位**\n\nFile v3.3.0:README.md\n\n# Redis Memory System v3.3.0\n\nFully automatic cross-session short-term memory system. Single script, config-driven, semantic tag index.\n\n全自动跨会话短期记忆系统。单脚本 + 配置驱动 + 语义标签索引。\n\n## 适配环境 / Requirements\n\n| 项目 / Item | 规格 / Spec |\n|-------------|-------------|\n| 实例 / Instance | 任意（Redis 占用 < 50MB） |\n| Redis | 单机模式 / Standalone |\n| Agent | OpenClaw |\n\n## 一键安装 / Quick Install\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n## 用法 / Usage\n\n```bash\n# Sync dialogue to Redis (for cron) · 同步对话到 Redis（给 cron 用）\nbash scripts/memory.sh sync\n\n# Read recent memory (last 3 days) · 查最近 3 天记忆\nbash scripts/memory.sh get \n\n# Read memory for N days · 查最近 N 天记忆\nbash scripts/memory.sh get 7\n\n# Read memory for a specific date · 查指定日期记忆\nbash scripts/memory.sh get 2026-05-26\n\n# Search by semantic tags · 按语义标签搜索\nbash scripts/memory.sh search \n\n# Manually write summary · 手动写入摘要\nbash scripts/memory.sh set 2026-05-26 \"Summary text\"\n\n# System overview · 系统状态\nbash scripts/memory.sh stats\n\n# Redis connection check · 检查 Redis 连通性\nbash scripts/memory.sh ping\n```\n\n## 语义标签索引 / Semantic Tags (v3.3.0)\n\n- LLM 自动为每日摘要提取 5 个概念级标签 / LLM auto-extracts 5 concept-level tags per day\n- 倒排索引 `tagidx:` → 日期集合 / Inverted index for cross-date lookup\n- Redis SINTER 支持 O(1) 多标签交集查询 / O(1) multi-tag intersection queries\n- 零额外内存，不用 embedding 模型 / Zero extra memory, no embedding model needed\n\nFile v3.3.0:_meta.json\n\n{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"3.3.0\",\n \"publishedAt\": 1779844146544\n}\n\nFile v3.3.0:skill-card.md\n\n## Description:\n\nFully automatic cross-session short-term memory system with a single script, configuration-driven operation, and a semantic tag index.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[hualang-c](https://clawhub.ai/user/hualang-c)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nDevelopers and OpenClaw users use this skill to install and operate a Redis-backed memory helper that syncs recent session dialogue summaries, retrieves recent memory, searches semantic tags, and checks memory-system status.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: The skill ingests cross-session transcript content into Redis, which can include sensitive user or session information.\n\nMitigation: Use an opt-in installation path, treat stored summaries and transcript excerpts as sensitive data, and avoid shared Redis databases.\n\nRisk: The setup script registers persistent cron-based background execution.\n\nMitigation: Manually review or remove cron registration before deployment, and approve scheduled execution only for intended users and environments.\n\nRisk: Redis-backed memory can be exposed if Redis access is broad or unauthenticated.\n\nMitigation: Restrict Redis access, validate configured usernames, and isolate memory data per user or deployment.\n\n## Reference(s):\n\n- [Redis Memory System README](artifact/README.md)\n- [ClawHub Skill Page](https://clawhub.ai/hualang-c/skills/redis-memory-system)\n\n## Skill Output:\n\n**Output Type(s):** [text, markdown, shell commands, configuration, guidance]\n\n**Output Format:** [Markdown with inline shell commands and JSON status output]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Produces Redis memory operations for sync, get, set, tag search, heartbeat, ping, and stats workflows.]\n\n## Skill Version(s):\n\n3.3.0 (source: server release evidence, artifact _meta.json)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.\n\nArchive v3.2.4: 8 files, 12534 bytes\n\nFiles: _meta.json (138b), openclaw_cron_prompt.txt (454b), README.md (843b), scripts/extract_dialog.py (1935b), scripts/memory.sh (10586b), scripts/setup.sh (3809b), skill-card.md (2261b), SKILL.md (7701b)\n\nFile v3.2.4:SKILL.md\n\n---\nname: redis-memory-system\ndescription: \"跨会话自动记忆系统 v3.2.3 — 单脚本+配置驱动+语义标签索引。支持标签检索、倒排索引、语义搜索。\"\n---\n\n# Redis 记忆系统 v3.2.3\n\n**核心思路：Agent 零负担，系统自动完成。cron 子 session 绕过 dmScope 限制，通过文件系统直读 transcript。**\n\n## 架构\n\n```\n┌──────────────────────────────────────────────────────┐\n│ OpenClaw Cron (每1h, isolated session) │\n│ │\n│ ① 分布式锁 (SET NX EX 600) 防并发 │\n│ ② ls -t 找最新 transcript 文件（排除cron自引用） │\n│ ③ extract_dialog.py 提取末尾200行对话 │\n│ ④ LLM 语义去重 + 摘要生成 │\n│ ⑤ Lua EVAL 原子写入（HSET+EXPIRE+last_seen） │\n│ ⑥ 锁释放 │\n└───────────────────────┬──────────────────────────────┘\n │\n┌───────────────────────┴──────────────────────────────┐\n│ 系统 Cron (每1h) — 监控哨兵 │\n│ │\n│ ① 心跳写入隔离 key: cron:health │\n│ ② 逐用户检查 memory:<用户> 今天有无摘要 │\n│ ③ 异常时写告警 flag 到 /tmp/ │\n└───────────────────────┬──────────────────────────────┘\n │\n┌───────────────────────┴──────────────────────────────┐\n│ Agent Session 启动时 │\n│ │\n│ redis_memory.sh get <用户> → 查最近3天 │\n│ cat /tmp/*.flag → 检查告警 │\n└──────────────────────────────────────────────────────┘\n```\n\n## 关键解决的问题\n\n| 问题 | 方案 |\n|------|------|\n| dmScope 隔离导致 cron 子 session 看不到主会话 | 文件系统直读 transcript JSONL |\n| exec 间变量丢失（各自独立 shell） | 合并为单个 exec 脚本，变量只在进程内传递 |\n| 重复追加相同摘要 | LLM 语义去重—新旧摘要表达相同信息时跳过 |\n| cron 污染 memory hash | cron 心跳写到隔离 key `cron:health` |\n| 并发执行风险 | Redis SET NX EX 分布式锁，防止两个 cron 同时写 |\n| 非原子写入（HSET+EXPIRE 分开执行） | Lua 脚本（EVAL）保证一个事务内完成全部操作 |\n| 文件查找顺序错误 | `ls -t` 按修改时间取最新，而非按匹配数 |\n\n## 文件说明\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/setup.sh` | 一键安装（Redis + 脚本 + 系统cron） |\n| `scripts/redis_memory.sh` | 通用记忆操作（查/写/统计/检查） |\n| `scripts/redis_memory_isolated.sh` | 环境变量指定用户 |\n| `scripts/redis_memory_user.sh` | 硬编码用户名专用 |\n| `scripts/cron_heartbeat_ping.sh` | 系统监控哨兵（用户列表外部可配） |\n| `scripts/extract_dialog.py` | transcript 对话提取工具 |\n| `openclaw_cron_prompt.txt` | OpenClaw cron 的 system prompt（v3.1.1） |\n\n## 🔑 Redis Key 设计\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:<用户名>` | Hash | 7天 | 每日对话摘要，field=日期，value=文本 |\n| `cron:health` | Hash | 7天 | 系统心跳（隔离，不污染记忆数据） |\n| `activity:<用户名>:last_seen` | String | 12h | 最后活跃时间标记 |\n| `cron_lock:memory_sync` | String | 10min | 分布式锁，防并发 |\n\n## 部署\n\n### 1. 基础安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n### 2. 创建 OpenClaw cron（核心）\n\n```bash\nPROMPT=$(cat scripts/openclaw_cron_prompt.txt)\nopenclaw cron add \\\n --name \"记忆自动同步\" \\\n --every 1h \\\n --session isolated \\\n --timeout-seconds 180 \\\n --thinking minimal \\\n --tools \"exec,read\" \\\n --no-deliver \\\n --message \"$PROMPT\"\n```\n\n**重要：** `--tools \"exec,read\"` 限制了 cron 只能执行脚本和读文件，防止递归触发其他工具。`--session isolated` 确保 cron 在独立容器跑，不影响主会话。\n\n## Session 启动检查\n\n每次新 session 启动时加载近期记忆：\n\n```bash\nbash scripts/redis_memory.sh get <用户名>\ncat /tmp/memory_warning_<用户名>.flag 2>/dev/null\n```\n\n## v3.2.3 相比 v3.2 的改动（2026-05-26）\n\n#### 语义标签索引（v3.2.3 新增）\n- **LLM 语义标签：** cron 同步时自动提取 5 个概念级标签，替代向量检索\n- **倒排索引：** `tagidx:<标签>` → 日期集合，Redis SINTER O(1) 查询\n- **标签搜索：** `memory.sh search <关键词>` 配合 Agent 语义匹配\n- **零额外内存：** 不用 embedding 模型和向量数据库，每日标签仅占 ~200 字节\n\n### 核心架构改动\n- **合并exec调用：** 文件查找+对话提取+Redis查重合并为一个脚本，变量不会跨exec丢失（原v3.1三步分离，变量会在独立shell中丢失）\n- **Redis原子写入：** 用 Lua 脚本（`EVAL`）替代三次独立 `redis-cli` 调用，保证 HSET + EXPIRE + SET last_seen 在同一事务中完成\n- **分布式锁：** `SET NX EX 600` 防并发，cron 卡住时最长600秒自动释放（`trap cleanup EXIT` 保底）\n- **重试机制：** 文件读取失败时最多重试 2 次，间隔 1 秒\n\n### 修复的 bug\n- **找文件：** 从按匹配数取最多改为按 `ls -t` 修改时间取最新，避免旧文件碾压新 session\n- **shell语法：** `grep -c` 后加 `|| echo 0` 兜底，消除 `[: 0: integer expression expected`\n- **阈值：** 从 5 降到 2，短对话也能被收录\n\n### 脚本改进\n- **参数校验完善：** 所有脚本增加参数个数和内容校验，防止因参数不足产生幽灵记录\n- **用户名校验：** `redis_memory_user.sh` 启动时检测 USERNAME 是否仍为占位符，防止写入 `memory:your_username`\n- **用户列表外部化：** `cron_heartbeat_ping.sh` 支持环境变量 `REDIS_MEMORY_USERS`、配置文件 `/etc/redis-memory-users.conf` 或硬编码数组三种方式\n- **redis_memory.sh 新增：** `ping` 命令（检查Redis连通性）、`stats` 命令（统计各用户记忆天数/字符数）\n- **天数限制：** `recent` 命令上限 30 天，防止误传大数字导致遍历全部历史\n\n## 版本历史\n\n- v1.0 (2026-05-16) — 基础 Redis 记忆存储\n- v1.1 (2026-05-17) — 多用户隔离 + SOUL 铁律\n- v2.0 (2026-05-20) — draft 机制 + 三层保底 + 启动恢复\n- v2.1 (2026-05-21) — cron 脚本增强 + 用户专用脚本\n- v3.0 (2026-05-23) — 系统自动读会话写摘要，Agent 零负担\n- **v3.1 (2026-05-23) — 修复 dmScope 隔离问题，改用文件路径；增加去重/过滤逻辑**\n- **v3.1.1 (2026-05-25) — 架构大修：合并exec、Lua原子写入、分布式锁、重试机制**\n- **v3.2 (2026-05-25) — 单脚本+配置驱动+JSON输出**\n- **v3.2.3 (2026-05-26) — 语义标签索引 + 倒排检索 + 标签搜索**\n\nFile v3.2.4:README.md\n\n# Redis Memory System v3.2.3\n\n全自动跨会话短期记忆系统。单脚本 + 配置驱动 + 语义标签索引。\n\n## 适配环境\n\n| 项目 | 规格 |\n|------|------|\n| 实例 | 任意（Redis 占用 < 50MB 内存） |\n| Redis | 单机模式 |\n| Agent | OpenClaw |\n\n## 一键安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n## 用法\n\n```bash\n# 同步（给 cron 用）\nbash scripts/memory.sh sync\n\n# 查记忆\nbash scripts/memory.sh get <用户名> [天数]\n\n# 搜索（语义标签，Agent 配合查询）\nbash scripts/memory.sh search <关键词>\n\n# 系统状态\nbash scripts/memory.sh stats\n```\n\n## 语义标签索引（v3.2.3）\n\n- LLM 自动为每日摘要提取 5 个概念级标签\n- 倒排索引 `tagidx:<标签>` → 日期集合，Redis SINTER 支持 O(1) 查询\n- 零额外内存，不用 embedding 模型\n\nFile v3.2.4:_meta.json\n\n{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"3.2.4\",\n \"publishedAt\": 1779773238195\n}\n\nFile v3.2.4:skill-card.md\n\n## Description:
\nAutomatic cross-session memory system for OpenClaw that reads local transcripts, summarizes recent conversation context, stores derived memory in Redis, and supports tag-based retrieval.
\n\nThis skill is ready for commercial/non-commercial use.
\n\n## Publisher:
\n[hualang-c](https://clawhub.ai/user/hualang-c)
\n\n### License/Terms of Use:
\nMIT-0
\n\n\n## Use Case:
\nDevelopers and OpenClaw users use this skill to maintain short-term cross-session memory by synchronizing conversation summaries into Redis and retrieving recent or tag-matched memory during later sessions.
\n\n### Deployment Geography for Use:
\nGlobal
\n\n## Known Risks and Mitigations:
\nRisk: The skill intentionally reads local OpenClaw transcript files and stores derived conversation memory in Redis, which can expose sensitive conversation data if retention and access controls are not managed.
\nMitigation: Restrict the transcript directory and configured user list, secure Redis, and define retention and deletion procedures before enabling automatic synchronization.
\nRisk: The setup flow can install recurring jobs that automatically process conversations without repeated user interaction.
\nMitigation: Review and modify setup.sh before running it, and avoid silent cron registration unless the schedule and scope are deliberate.
\n\n\n## Reference(s):
\n- [ClawHub skill page](https://clawhub.ai/hualang-c/redis-memory-system)
\n\n\n## Skill Output:
\n**Output Type(s):** [text, markdown, shell commands, configuration, guidance]
\n**Output Format:** [Markdown guidance with inline shell commands and JSON status output from scripts]
\n**Output Parameters:** [1D]
\n**Other Properties Related to Output:** [May install scripts, configure cron jobs, read local transcript files, and write derived memory data to Redis when executed by the user.]
\n\n## Skill Version(s):
\n3.2.4 (source: server release evidence)
\n\n## Ethical Considerations:
\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.
\n\nFile v3.2.4:openclaw_cron_prompt.txt\n\n# 此文件为 v3.1.1 旧版示例 prompt（含占位符）\n# \n# v3.2+ 已改用 memory.sh sync 配置驱动方案，不硬编码任何用户信息。\n# 新方案通过以下方式传入用户：\n# memory.sh sync --user <用户名>\n# 或设置环境变量 MEMORY_USERS=\"用户1,用户2\"\n# 或编辑配置文件 /etc/memory-users.conf\n#\n# 本文件保留为历史参考，不用于实际生产配置。\n# 请参考 SKILL.md 中的新方案说明。\n\nArchive v3.2.3: 8 files, 13720 bytes\n\nFiles: _meta.json (138b), openclaw_cron_prompt.txt (2567b), README.md (843b), scripts/extract_dialog.py (1935b), scripts/memory.sh (10586b), scripts/setup.sh (3809b), skill-card.md (2461b), SKILL.md (7703b)\n\nFile v3.2.3:SKILL.md\n\n---\nname: redis-memory-system\ndescription: \"跨会话自动记忆系统 v3.2.3 — 单脚本+配置驱动+语义标签索引。支持标签检索、倒排索引、语义搜索。\"\n---\n\n# Redis 记忆系统 v3.2.3\n\n**核心思路：Agent 零负担，系统自动完成。cron 子 session 绕过 dmScope 限制，通过文件系统直读 transcript。**\n\n## 架构\n\n```\n┌──────────────────────────────────────────────────────┐\n│ OpenClaw Cron (每1h, isolated session) │\n│ │\n│ ① 分布式锁 (SET NX EX 600) 防并发 │\n│ ② ls -t 找最新 transcript 文件（排除cron自引用） │\n│ ③ extract_dialog.py 提取末尾200行对话 │\n│ ④ LLM 语义去重 + 摘要生成 │\n│ ⑤ Lua EVAL 原子写入（HSET+EXPIRE+last_seen） │\n│ ⑥ 锁释放 │\n└───────────────────────┬──────────────────────────────┘\n │\n┌───────────────────────┴──────────────────────────────┐\n│ 系统 Cron (每1h) — 监控哨兵 │\n│ │\n│ ① 心跳写入隔离 key: cron:health │\n│ ② 逐用户检查 memory:<用户> 今天有无摘要 │\n│ ③ 异常时写告警 flag 到 /tmp/ │\n└───────────────────────┬──────────────────────────────┘\n │\n┌───────────────────────┴──────────────────────────────┐\n│ Agent Session 启动时 │\n│ │\n│ redis_memory.sh get <用户> → 查最近3天 │\n│ cat /tmp/*.flag → 检查告警 │\n└──────────────────────────────────────────────────────┘\n```\n\n## 关键解决的问题\n\n| 问题 | 方案 |\n|------|------|\n| dmScope 隔离导致 cron 子 session 看不到主会话 | 文件系统直读 transcript JSONL |\n| exec 间变量丢失（各自独立 shell） | 合并为单个 exec 脚本，变量只在进程内传递 |\n| 重复追加相同摘要 | LLM 语义去重—新旧摘要表达相同信息时跳过 |\n| cron 污染 memory hash | cron 心跳写到隔离 key `cron:health` |\n| 并发执行风险 | Redis SET NX EX 分布式锁，防止两个 cron 同时写 |\n| 非原子写入（HSET+EXPIRE 分开执行） | Lua 脚本（EVAL）保证一个事务内完成全部操作 |\n| 文件查找顺序错误 | `ls -t` 按修改时间取最新，而非按匹配数 |\n\n## 文件说明\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/setup.sh` | 一键安装（Redis + 脚本 + 系统cron） |\n| `scripts/redis_memory.sh` | 通用记忆操作（查/写/统计/检查） |\n| `scripts/redis_memory_isolated.sh` | 环境变量指定用户 |\n| `scripts/redis_memory_user.sh` | 硬编码用户名专用 |\n| `scripts/cron_heartbeat_ping.sh` | 系统监控哨兵（用户列表外部可配） |\n| `scripts/extract_dialog.py` | transcript 对话提取工具 |\n| `openclaw_cron_prompt.txt` | OpenClaw cron 的 system prompt（v3.1.1） |\n\n## 🔑 Redis Key 设计\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:<用户名>` | Hash | 7天 | 每日对话摘要，field=日期，value=文本 |\n| `cron:health` | Hash | 7天 | 系统心跳（隔离，不污染记忆数据） |\n| `activity:<用户名>:last_seen` | String | 12h | 最后活跃时间标记 |\n| `cron_lock:memory_sync` | String | 10min | 分布式锁，防并发 |\n\n## 部署\n\n### 1. 基础安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n### 2. 创建 OpenClaw cron（核心）\n\n```bash\nPROMPT=$(cat scripts/openclaw_cron_prompt.txt)\nopenclaw cron add \\\n --name \"记忆自动同步\" \\\n --every 1h \\\n --session isolated \\\n --timeout-seconds 180 \\\n --thinking minimal \\\n --tools \"exec,read\" \\\n --no-deliver \\\n --message \"$PROMPT\"\n```\n\n**重要：** `--tools \"exec,read\"` 限制了 cron 只能执行脚本和读文件，防止递归触发其他工具。`--session isolated` 确保 cron 在独立容器跑，不影响主会话。\n\n## Session 启动检查\n\n每次新 session 启动时加载近期记忆：\n\n```bash\nbash scripts/redis_memory.sh get 花开时\ncat /tmp/redis_memory_warning_花开时.flag 2>/dev/null\n```\n\n## v3.2.3 相比 v3.2 的改动（2026-05-26）\n\n#### 语义标签索引（v3.2.3 新增）\n- **LLM 语义标签：** cron 同步时自动提取 5 个概念级标签，替代向量检索\n- **倒排索引：** `tagidx:<标签>` → 日期集合，Redis SINTER O(1) 查询\n- **标签搜索：** `memory.sh search <关键词>` 配合 Agent 语义匹配\n- **零额外内存：** 不用 embedding 模型和向量数据库，每日标签仅占 ~200 字节\n\n### 核心架构改动\n- **合并exec调用：** 文件查找+对话提取+Redis查重合并为一个脚本，变量不会跨exec丢失（原v3.1三步分离，变量会在独立shell中丢失）\n- **Redis原子写入：** 用 Lua 脚本（`EVAL`）替代三次独立 `redis-cli` 调用，保证 HSET + EXPIRE + SET last_seen 在同一事务中完成\n- **分布式锁：** `SET NX EX 600` 防并发，cron 卡住时最长600秒自动释放（`trap cleanup EXIT` 保底）\n- **重试机制：** 文件读取失败时最多重试 2 次，间隔 1 秒\n\n### 修复的 bug\n- **找文件：** 从按匹配数取最多改为按 `ls -t` 修改时间取最新，避免旧文件碾压新 session\n- **shell语法：** `grep -c` 后加 `|| echo 0` 兜底，消除 `[: 0: integer expression expected`\n- **阈值：** 从 5 降到 2，短对话也能被收录\n\n### 脚本改进\n- **参数校验完善：** 所有脚本增加参数个数和内容校验，防止因参数不足产生幽灵记录\n- **用户名校验：** `redis_memory_user.sh` 启动时检测 USERNAME 是否仍为占位符，防止写入 `memory:your_username`\n- **用户列表外部化：** `cron_heartbeat_ping.sh` 支持环境变量 `REDIS_MEMORY_USERS`、配置文件 `/etc/redis-memory-users.conf` 或硬编码数组三种方式\n- **redis_memory.sh 新增：** `ping` 命令（检查Redis连通性）、`stats` 命令（统计各用户记忆天数/字符数）\n- **天数限制：** `recent` 命令上限 30 天，防止误传大数字导致遍历全部历史\n\n## 版本历史\n\n- v1.0 (2026-05-16) — 基础 Redis 记忆存储\n- v1.1 (2026-05-17) — 多用户隔离 + SOUL 铁律\n- v2.0 (2026-05-20) — draft 机制 + 三层保底 + 启动恢复\n- v2.1 (2026-05-21) — cron 脚本增强 + 用户专用脚本\n- v3.0 (2026-05-23) — 系统自动读会话写摘要，Agent 零负担\n- **v3.1 (2026-05-23) — 修复 dmScope 隔离问题，改用文件路径；增加去重/过滤逻辑**\n- **v3.1.1 (2026-05-25) — 架构大修：合并exec、Lua原子写入、分布式锁、重试机制**\n- **v3.2 (2026-05-25) — 单脚本+配置驱动+JSON输出**\n- **v3.2.3 (2026-05-26) — 语义标签索引 + 倒排检索 + 标签搜索**\n\nFile v3.2.3:README.md\n\n# Redis Memory System v3.2.3\n\n全自动跨会话短期记忆系统。单脚本 + 配置驱动 + 语义标签索引。\n\n## 适配环境\n\n| 项目 | 规格 |\n|------|------|\n| 实例 | 任意（Redis 占用 < 50MB 内存） |\n| Redis | 单机模式 |\n| Agent | OpenClaw |\n\n## 一键安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n## 用法\n\n```bash\n# 同步（给 cron 用）\nbash scripts/memory.sh sync\n\n# 查记忆\nbash scripts/memory.sh get <用户名> [天数]\n\n# 搜索（语义标签，Agent 配合查询）\nbash scripts/memory.sh search <关键词>\n\n# 系统状态\nbash scripts/memory.sh stats\n```\n\n## 语义标签索引（v3.2.3）\n\n- LLM 自动为每日摘要提取 5 个概念级标签\n- 倒排索引 `tagidx:<标签>` → 日期集合，Redis SINTER 支持 O(1) 查询\n- 零额外内存，不用 embedding 模型\n\nFile v3.2.3:_meta.json\n\n{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"3.2.3\",\n \"publishedAt\": 1779755808873\n}\n\nFile v3.2.3:skill-card.md\n\n## Description:
\nCross-session automatic memory system for OpenClaw that summarizes conversation transcripts into Redis and adds semantic tag indexes for lookup.
\n\nThis skill is ready for commercial/non-commercial use.
\n\n## Publisher:
\n[hualang-c](https://clawhub.ai/user/hualang-c)
\n\n### License/Terms of Use:
\nMIT-0
\n\n\n## Use Case:
\nDevelopers using OpenClaw can install this skill to keep short-term cross-session memory in a local Redis instance, retrieve recent summaries, and search by generated semantic tags.
\n\n### Deployment Geography for Use:
\nGlobal
\n\n## Known Risks and Mitigations:
\nRisk: The skill reads previous OpenClaw conversation transcripts across sessions, which can expose sensitive user or project information.
\nMitigation: Use only with explicit consent from all affected users, restrict transcript access, and avoid installing it in shared or untrusted environments.
\nRisk: The skill stores conversation summaries and semantic tags in Redis, creating persistent memory that may outlive the user's expectations.
\nMitigation: Run Redis locally with access controls, review configured TTLs, and provide a clear process to purge memory keys when the skill is disabled.
\nRisk: The setup path can install scheduled background jobs that continue reading transcripts and writing memory data.
\nMitigation: Review cron entries before and after installation, document removal steps, and monitor scheduled jobs for expected scope and frequency.
\n\n\n## Reference(s):
\n- [ClawHub skill page](https://clawhub.ai/hualang-c/redis-memory-system)
\n- [ClawHub publisher profile](https://clawhub.ai/user/hualang-c)
\n\n\n## Skill Output:
\n**Output Type(s):** [Text, Markdown, Shell commands, Configuration, Guidance]
\n**Output Format:** [Markdown with shell commands and configuration guidance]
\n**Output Parameters:** [1D]
\n**Other Properties Related to Output:** [Produces Redis-backed memory summaries, status text, tag listings, and setup commands for OpenClaw cron integration.]
\n\n## Skill Version(s):
\n3.2.3 (source: server release metadata and artifact _meta.json)
\n\n## Ethical Considerations:
\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.
\n\nFile v3.2.3:openclaw_cron_prompt.txt\n\n你是记忆同步助手，每1小时自动为花开时生成每日摘要并存入Redis。\n注意：dmScope隔离下不能通过sessions_list读对话，必须直读transcript文件。\n\n执行下面这个完整的脚本：\n\nexec:\nSESSIONS_DIR=\"/root/.openclaw/agents/main/sessions\"\nTODAY=$(date +%Y-%m-%d)\nLOCK_KEY=\"cron_lock:memory_sync\"\nLOCK_TTL=600\n\nif ! redis-cli SET \"$LOCK_KEY\" \"$$\" NX EX \"$LOCK_TTL\" 2>/dev/null; then\n echo \"LOCK_FAIL\"; exit 0\nfi\ncleanup() { redis-cli DEL \"$LOCK_KEY\" >/dev/null 2>&1; }\ntrap cleanup EXIT\n\nBEST_FILE=\"\"\nfor f in $(ls -t \"$SESSIONS_DIR\"/*.jsonl 2>/dev/null | grep -v \".trajectory\"); do\n if head -10 \"$f\" 2>/dev/null | grep -qF \"[cron:\" 2>/dev/null; then continue; fi\n CNT=$(grep -c \"o9cq80wIv9Q0CjVvF9JHP4oNmg48\" \"$f\" 2>/dev/null || echo 0)\n if [ \"$CNT\" -ge 2 ]; then BEST_FILE=\"$f\"; break; fi\ndone\necho \"FILE=$BEST_FILE\"\n\nif [ -z \"$BEST_FILE\" ]; then\n echo \"SKIP: no conversation file found\"; echo \"---END---\"\n EXISTING=$(redis-cli HGET \"memory:花开时\" \"$TODAY\" 2>/dev/null || echo \"\")\n echo \"ELEN=${#EXISTING}\"; echo \"---META---\"; exit 0\nfi\n\n# 把提取脚本写文件，避免引号转义问题\ncat > /tmp/extract_dialog.py << 'PYEOF'\nimport json, sys\nlines = open(sys.argv[1]).readlines()\nfor line in lines[-200:]:\n try:\n m = json.loads(line.strip())\n if m.get('type') != 'message': continue\n msg = m.get('message', {})\n role = msg.get('role', '')\n content = msg.get('content', '')\n if isinstance(content, list):\n for c in content:\n if c.get('type') == 'text' and c.get('text', '').strip():\n print(role + ': ' + c['text'][:300])\n elif isinstance(content, str) and len(content) < 500 and content.strip():\n print(role + ': ' + content[:300])\n except:\n pass\nPYEOF\n\npython3 /tmp/extract_dialog.py \"$BEST_FILE\" 2>/dev/null || echo \"PARSE_ERROR\"\necho \"---END---\"\n\nEXISTING=$(redis-cli HGET \"memory:花开时\" \"$TODAY\" 2>/dev/null || echo \"\")\necho \"ELEN=${#EXISTING}\"\necho \"---META---\"\n\n根据输出决策：FILE为空或无user消息则NOTHING_NEW；有user消息则生成2-3句摘要；与EXISTING对比去重后决定是否写入。\n\n确认后执行原子写入：\nexec:\nTODAY=$(date +%Y-%m-%d)\nread -r SUMMARY\nredis-cli EVAL \"redis.call('HSET','memory:花开时',ARGV[1],ARGV[2]) redis.call('EXPIRE','memory:花开时',604800) redis.call('SET','activity:花开时:last_seen',ARGV[3],'EX',43200) return 'OK'\" 0 \"$TODAY\" \"$SUMMARY\" \"$(date '+%Y-%m-%d %H:%M')\"\necho \"DONE\"\n\n只允许 exec、read 工具\n\nArchive v3.2.2: 6 files, 9234 bytes\n\nFiles: _meta.json (138b), openclaw_cron_prompt_v3.2.txt (1230b), README.md (2105b), scripts/memory.sh (8923b), scripts/setup.sh (3105b), SKILL.md (3155b)\n\nFile v3.2.2:SKILL.md\n\n---\nname: redis-memory-system\ndescription: \"跨会话自动记忆系统 v3.2 — OpenClaw cron 每小时自动从 transcript 文件读取对话并写 Redis。单脚本 + 配置驱动，无硬编码用户名。\"\n---\n\n# Redis 记忆系统 v3.2\n\n**核心思路：Agent 零负担，系统自动完成。单脚本 memory.sh + 配置文件 /etc/memory-users.conf。**\n\n## 架构\n\n```\nOpenClaw Cron (每1h)\n → memory.sh sync（单脚本，配置驱动，输出 JSON）\n → [分布式锁] 防并发\n → 找最新 transcript（find 安全遍历）\n → Python 提取最近 200 条对话\n → 查 Redis 现有摘要\n → 输出 JSON\n → LLM 分析 JSON → 总结决策 → 原子写入 Redis\n （Lua EVAL 保证 HSET + EXPIRE + last_seen 同一事务）\n\n系统 Cron (每1h)\n → memory.sh heartbeat（心跳监控，隔离 key）\n\n用户（你）\n → 什么都不用做\n```\n\n## 核心改进（v3.2）\n\n| 改进 | 详情 |\n|------|------|\n| **单脚本合并** | 6 个脚本 → 1 个 `memory.sh` |\n| **无硬编码名字** | 所有用户名通过 `/etc/memory-users.conf` 配置 |\n| **配置驱动** | 加用户只需编辑配置文件，不改代码 |\n| **JSON 输出** | sync 输出结构化 JSON，LLM 只做总结决策 |\n| **安全遍历** | `find -printf` + `while read -d ''` 替代 `for f in $(ls -t)` |\n| **cron prompt 精简** | 从 200 行降到 ~50 行 |\n\n## 文件说明\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/memory.sh` | **唯一脚本** — sync / get / set / heartbeat / ping / stats |\n| `scripts/setup.sh` | 一键安装 |\n| `openclaw_cron_prompt_v3.2.txt` | cron prompt |\n| `/etc/memory-users.conf` | 用户列表（每行一个用户名）|\n\n### 已废弃\n- `redis_memory.sh`、`redis_memory_sync.sh` → `memory.sh` 统一接管\n- `redis_memory_isolated.sh`、`redis_memory_user.sh` → 配置驱动\n- `cron_heartbeat_ping.sh` → `memory.sh heartbeat`\n\n## 用法\n\n```bash\n# 同步（给 cron 用）\nbash scripts/memory.sh sync\n\n# 手动查记忆\nbash scripts/memory.sh get <用户名>\nbash scripts/memory.sh get <用户名> 7\n\n# 心跳监控\nbash scripts/memory.sh heartbeat\n\n# 系统状态\nbash scripts/memory.sh stats\n```\n\n## 配置多用户\n\n编辑 `/etc/memory-users.conf`，每行一个用户名：\n\n```\nuser1\nuser2\nuser3\n```\n\n然后 memory.sh sync 会自动遍历所有用户。\n\n## Redis Key 设计\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:<用户名>` | Hash | 7天 | 每日对话摘要 |\n| `cron:health` | Hash | 7天 | 系统心跳（隔离 key） |\n| `activity:<用户名>:last_seen` | String | 12h | 最后活跃时间 |\n| `cron_lock:sync:<用户名>` | String | 10min | 分布式锁 |\n\n## 版本历史\n\n- v1.0 — 基础 Redis 记忆存储\n- v1.1 — 多用户隔离 + SOUL 铁律\n- v2.0 — draft 机制 + 三层保底 + 启动恢复\n- v2.1 — cron 脚本增强 + 用户专用脚本\n- v3.0 — 系统自动读会话写摘要，Agent 零负担\n- v3.1 — 修复 dmScope 隔离问题，改用文件路径\n- v3.1.1 — 架构大修：合并exec、Lua原子写入、分布式锁\n- **v3.2 — 单脚本 + 配置驱动 + 无硬编码用户名 + JSON 输出**\n\nFile v3.2.2:README.md\n\n# Redis Memory System v3.2 — 全自动跨 Session 记忆\n\n单脚本 + 配置文件驱动。cron 每小时自动读 transcript → 输出 JSON → LLM 总结 → 写 Redis。\n\n## 适配环境\n\n- **规格**：任意（Redis 占用 < 50MB 内存）\n- **Redis**：单机模式，默认配置\n- **Agent**：OpenClaw（任意版本）\n\n## 一键安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n安装后编辑 `/etc/memory-users.conf`，每行一个用户名。\n\n## 架构\n\n```\ncron (每1h)\n → memory.sh sync（单脚本，配置驱动，输出 JSON）\n → [分布式锁] 用户级防并发\n → 找最新 transcript（find 安全遍历）\n → Python 提取最近 200 条对话\n → 查 Redis 现有摘要\n → 输出结构化 JSON\n → LLM 分析 JSON → 总结/去重/追加决策\n → [Lua EVAL] 原子写入 Redis\n\n用户\n → memory.sh get <用户名> 查记忆\n → memory.sh stats 看状态\n```\n\n## 用法\n\n```bash\n# 同步（给 cron 用）\nbash scripts/memory.sh sync\n\n# 查记忆\nbash scripts/memory.sh get <用户名>\nbash scripts/memory.sh get <用户名> 7\n\n# 手动记\nbash scripts/memory.sh set <用户名> 2026-05-25 \"今天...\"\n\n# 系统工具\nbash scripts/memory.sh ping\nbash scripts/memory.sh stats\n```\n\n## 文件\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/memory.sh` | 唯一核心脚本（sync/get/set/heartbeat/ping/stats） |\n| `scripts/setup.sh` | 一键安装 |\n| `openclaw_cron_prompt_v3.2.txt` | cron prompt |\n| `/etc/memory-users.conf` | 用户列表（每行一个用户名）|\n\n## Redis Key\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:<用户名>` | Hash | 7天 | 每日摘要，field=日期, value=文本 |\n| `cron:health` | Hash | 7天 | 心跳（隔离 key） |\n| `activity:<用户名>:last_seen` | String | 12h | 最后活跃 |\n| `cron_lock:sync:<用户名>` | String | 10min | 用户级分布式锁 |\n\n## 版本\n\n- v1.0 — 基础记忆存储\n- v2.x — 多用户 + draft + cron\n- v3.0/v3.1 — 系统自动读写，Agent 零负担\n- **v3.2 — 单脚本 + 配置驱动 + JSON 输出**\n\nFile v3.2.2:_meta.json\n\n{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"3.2.2\",\n \"publishedAt\": 1779710214350\n}\n\nFile v3.2.2:openclaw_cron_prompt_v3.2.txt\n\n# 记忆同步 cron prompt v3.2 — 由 setup.sh 自动替换 {{SCRIPTS_DIR}}\n# 用户列表来自 /etc/memory-users.conf（每行一个）\n\n## 步骤 1：跑同步脚本\n\nexec:\nbash {{SCRIPTS_DIR}}/memory.sh sync\n\n输出 JSON 数组，每个元素包含一个用户的对话数据和现有摘要\n\n## 步骤 2：逐条处理\n\n遍历 JSON 数组，对每个用户：\na) `status` 为 \"error\" / \"skip\" → 跳过\nb) `file` 或 `dialog_lines` 为空 → 跳过（NOTHING_NEW）\nc) 有对话 → 生成 2-3 句中文摘要\nd) 去重对比 `existing_summary`：\n - 空 → 新写入\n - 内容重复 → 跳过（ALREADY_SYNCED）\n - 有新信息 → `原摘要\\n后续: 新内容`\n - 超过 `summary_max_len` → 压缩精简\n\n## 步骤 3：写入 Redis\n\n对每个需要写入的用户：\n\nexec:\nread USER SUMMARY\nredis-cli EVAL \"\n redis.call('HSET', 'memory:'..ARGV[1], ARGV[2], ARGV[3])\n redis.call('EXPIRE', 'memory:'..ARGV[1], 604800)\n redis.call('SET', 'activity:'..ARGV[1]..':last_seen', ARGV[4], 'EX', 43200)\n return 'OK'\n\" 0 \"$USER\" \"$(date +%Y-%m-%d)\" \"$SUMMARY\" \"$(date '+%Y-%m-%d %H:%M')\"\necho \"DONE: $USER ${#SUMMARY} chars\"\n\n## 约束\n\n- 只使用 exec 工具\n- 空摘要不写入\n- 用中文回复执行结果\n\nArchive v3.2.1: 6 files, 9229 bytes\n\nFiles: _meta.json (138b), openclaw_cron_prompt_v3.2.txt (1278b), README.md (2105b), scripts/memory.sh (8883b), scripts/setup.sh (3256b), SKILL.md (3155b)\n\nFile v3.2.1:SKILL.md\n\n---\nname: redis-memory-system\ndescription: \"跨会话自动记忆系统 v3.2 — OpenClaw cron 每小时自动从 transcript 文件读取对话并写 Redis。单脚本 + 配置驱动，无硬编码用户名。\"\n---\n\n# Redis 记忆系统 v3.2\n\n**核心思路：Agent 零负担，系统自动完成。单脚本 memory.sh + 配置文件 /etc/memory-users.conf。**\n\n## 架构\n\n```\nOpenClaw Cron (每1h)\n → memory.sh sync（单脚本，配置驱动，输出 JSON）\n → [分布式锁] 防并发\n → 找最新 transcript（find 安全遍历）\n → Python 提取最近 200 条对话\n → 查 Redis 现有摘要\n → 输出 JSON\n → LLM 分析 JSON → 总结决策 → 原子写入 Redis\n （Lua EVAL 保证 HSET + EXPIRE + last_seen 同一事务）\n\n系统 Cron (每1h)\n → memory.sh heartbeat（心跳监控，隔离 key）\n\n用户（你）\n → 什么都不用做\n```\n\n## 核心改进（v3.2）\n\n| 改进 | 详情 |\n|------|------|\n| **单脚本合并** | 6 个脚本 → 1 个 `memory.sh` |\n| **无硬编码名字** | 所有用户名通过 `/etc/memory-users.conf` 配置 |\n| **配置驱动** | 加用户只需编辑配置文件，不改代码 |\n| **JSON 输出** | sync 输出结构化 JSON，LLM 只做总结决策 |\n| **安全遍历** | `find -printf` + `while read -d ''` 替代 `for f in $(ls -t)` |\n| **cron prompt 精简** | 从 200 行降到 ~50 行 |\n\n## 文件说明\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/memory.sh` | **唯一脚本** — sync / get / set / heartbeat / ping / stats |\n| `scripts/setup.sh` | 一键安装 |\n| `openclaw_cron_prompt_v3.2.txt` | cron prompt |\n| `/etc/memory-users.conf` | 用户列表（每行一个用户名）|\n\n### 已废弃\n- `redis_memory.sh`、`redis_memory_sync.sh` → `memory.sh` 统一接管\n- `redis_memory_isolated.sh`、`redis_memory_user.sh` → 配置驱动\n- `cron_heartbeat_ping.sh` → `memory.sh heartbeat`\n\n## 用法\n\n```bash\n# 同步（给 cron 用）\nbash scripts/memory.sh sync\n\n# 手动查记忆\nbash scripts/memory.sh get <用户名>\nbash scripts/memory.sh get <用户名> 7\n\n# 心跳监控\nbash scripts/memory.sh heartbeat\n\n# 系统状态\nbash scripts/memory.sh stats\n```\n\n## 配置多用户\n\n编辑 `/etc/memory-users.conf`，每行一个用户名：\n\n```\nuser1\nuser2\nuser3\n```\n\n然后 memory.sh sync 会自动遍历所有用户。\n\n## Redis Key 设计\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:<用户名>` | Hash | 7天 | 每日对话摘要 |\n| `cron:health` | Hash | 7天 | 系统心跳（隔离 key） |\n| `activity:<用户名>:last_seen` | String | 12h | 最后活跃时间 |\n| `cron_lock:sync:<用户名>` | String | 10min | 分布式锁 |\n\n## 版本历史\n\n- v1.0 — 基础 Redis 记忆存储\n- v1.1 — 多用户隔离 + SOUL 铁律\n- v2.0 — draft 机制 + 三层保底 + 启动恢复\n- v2.1 — cron 脚本增强 + 用户专用脚本\n- v3.0 — 系统自动读会话写摘要，Agent 零负担\n- v3.1 — 修复 dmScope 隔离问题，改用文件路径\n- v3.1.1 — 架构大修：合并exec、Lua原子写入、分布式锁\n- **v3.2 — 单脚本 + 配置驱动 + 无硬编码用户名 + JSON 输出**\n\nFile v3.2.1:README.md\n\n# Redis Memory System v3.2 — 全自动跨 Session 记忆\n\n单脚本 + 配置文件驱动。cron 每小时自动读 transcript → 输出 JSON → LLM 总结 → 写 Redis。\n\n## 适配环境\n\n- **规格**：任意（Redis 占用 < 50MB 内存）\n- **Redis**：单机模式，默认配置\n- **Agent**：OpenClaw（任意版本）\n\n## 一键安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n安装后编辑 `/etc/memory-users.conf`，每行一个用户名。\n\n## 架构\n\n```\ncron (每1h)\n → memory.sh sync（单脚本，配置驱动，输出 JSON）\n → [分布式锁] 用户级防并发\n → 找最新 transcript（find 安全遍历）\n → Python 提取最近 200 条对话\n → 查 Redis 现有摘要\n → 输出结构化 JSON\n → LLM 分析 JSON → 总结/去重/追加决策\n → [Lua EVAL] 原子写入 Redis\n\n用户\n → memory.sh get <用户名> 查记忆\n → memory.sh stats 看状态\n```\n\n## 用法\n\n```bash\n# 同步（给 cron 用）\nbash scripts/memory.sh sync\n\n# 查记忆\nbash scripts/memory.sh get <用户名>\nbash scripts/memory.sh get <用户名> 7\n\n# 手动记\nbash scripts/memory.sh set <用户名> 2026-05-25 \"今天...\"\n\n# 系统工具\nbash scripts/memory.sh ping\nbash scripts/memory.sh stats\n```\n\n## 文件\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/memory.sh` | 唯一核心脚本（sync/get/set/heartbeat/ping/stats） |\n| `scripts/setup.sh` | 一键安装 |\n| `openclaw_cron_prompt_v3.2.txt` | cron prompt |\n| `/etc/memory-users.conf` | 用户列表（每行一个用户名）|\n\n## Redis Key\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:<用户名>` | Hash | 7天 | 每日摘要，field=日期, value=文本 |\n| `cron:health` | Hash | 7天 | 心跳（隔离 key） |\n| `activity:<用户名>:last_seen` | String | 12h | 最后活跃 |\n| `cron_lock:sync:<用户名>` | String | 10min | 用户级分布式锁 |\n\n## 版本\n\n- v1.0 — 基础记忆存储\n- v2.x — 多用户 + draft + cron\n- v3.0/v3.1 — 系统自动读写，Agent 零负担\n- **v3.2 — 单脚本 + 配置驱动 + JSON 输出**\n\nFile v3.2.1:_meta.json\n\n{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"3.2.1\",\n \"publishedAt\": 1779709113742\n}\n\nFile v3.2.1:openclaw_cron_prompt_v3.2.txt\n\n# 记忆同步 cron prompt v3.2（配置驱动版）\n# 用户列表来自 /etc/memory-users.conf（每行一个）\n# 脏活由 memory.sh 独立脚本完成，输出 JSON\n\n## 步骤 1：跑同步脚本\n\nexec:\nbash /root/.openclaw/workspace/scripts/memory.sh sync\n\n输出 JSON 数组，每个元素包含一个用户的对话数据和现有摘要\n\n## 步骤 2：逐条处理\n\n遍历 JSON 数组，对每个用户：\na) `status` 为 \"error\" / \"skip\" → 跳过\nb) `file` 或 `dialog_lines` 为空 → 跳过（NOTHING_NEW）\nc) 有对话 → 生成 2-3 句中文摘要\nd) 去重对比 `existing_summary`：\n - 空 → 新写入\n - 内容重复 → 跳过（ALREADY_SYNCED）\n - 有新信息 → `原摘要\\n后续: 新内容`\n - 超过 `summary_max_len` → 压缩精简\n\n## 步骤 3：写入 Redis\n\n对每个需要写入的用户：\n\nexec:\nread USER SUMMARY\nredis-cli EVAL \"\n redis.call('HSET', 'memory:'..ARGV[1], ARGV[2], ARGV[3])\n redis.call('EXPIRE', 'memory:'..ARGV[1], 604800)\n redis.call('SET', 'activity:'..ARGV[1]..':last_seen', ARGV[4], 'EX', 43200)\n return 'OK'\n\" 0 \"$USER\" \"$(date +%Y-%m-%d)\" \"$SUMMARY\" \"$(date '+%Y-%m-%d %H:%M')\"\necho \"DONE: $USER ${#SUMMARY} chars\"\n\n## 约束\n\n- 只使用 exec 工具\n- 空摘要不写入\n- 用中文回复执行结果\n\nArchive v3.1.1: 9 files, 15496 bytes\n\nFiles: openclaw_cron_prompt.txt (3544b), README.md (2308b), scripts/cron_heartbeat_ping.sh (3136b), scripts/redis_memory_isolated.sh (3202b), scripts/redis_memory_user.sh (4914b), scripts/redis_memory.sh (5785b), scripts/setup.sh (3809b), SKILL.md (5117b), _meta.json (138b)\n\nFile v3.1.1:SKILL.md\n\n---\nname: redis-memory-system\ndescription: \"跨会话自动记忆系统 v3.1.1 — OpenClaw cron 每小时自动从 transcript 文件读取对话并写 Redis。修复cron找文件bug：改为按修改时间取最新文件，修复shell语法错误，降低阈值支持短对话。\"\n---\n\n# Redis 记忆系统 v3.1.1\n\n**核心思路：Agent 零负担，系统自动完成。cron 子 session 绕过 dmScope 限制，通过文件系统直读 transcript。**\n\n## 架构\n\n```\nOpenClaw Cron (每1h)\n → exec: 找 transcript 文件\n → exec: tail -200 提取对话\n → LLM 总结（去重 + 过滤元指令）\n → redis-cli HSET memory:花开时 YYYY-MM-DD \"摘要\"\n\n系统 Cron (每1h)\n → cron:health 写心跳（隔离，不污染记忆）\n → 检查今天有无摘要 → 丢就写告警 flag\n\nAgent（你）\n → 什么都不用做\n```\n\n## 关键解决的问题\n\n| 问题 | 方案 |\n|------|------|\n| dmScope 隔离导致 cron 子 session 看不到主会话 | 文件系统直读 transcript JSONL |\n| exec 间变量丢失（各自独立 shell） | 合并为单个 exec 脚本，变量只在进程内传递 |\n| 重复追加相同摘要 | LLM 语义去重—新旧摘要表达相同信息时跳过 |\n| cron 污染 memory hash | cron 心跳写到隔离 key `cron:health` |\n| 并发执行风险 | Redis SET NX EX 分布式锁，防止两个 cron 同时写 |\n| 非原子写入（HSET+EXPIRE 分开执行） | Lua 脚本（EVAL）保证一个事务内完成全部操作 |\n| 文件查找顺序错误 | `ls -t` 按修改时间取最新，而非按匹配数 |\n\n## 文件说明\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/setup.sh` | 一键安装 |\n| `scripts/redis_memory.sh` | 通用记忆操作（查/写） |\n| `scripts/redis_memory_isolated.sh` | 环境变量指定用户 |\n| `scripts/redis_memory_user.sh` | 硬编码用户名专用 |\n| `scripts/cron_heartbeat_ping.sh` | 系统监控哨兵（只告警，不写记忆） |\n| `openclaw_cron_prompt.txt` | OpenClaw cron 的 system prompt（v3.1 核心） |\n\n## 🔑 Redis Key 设计\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:花开时` | Hash | 7天 | 每日对话摘要 |\n| `cron:health` | Hash | 7天 | 系统心跳（隔离） |\n| `activity:花开时:last_seen` | String | 12h | 最后活跃时间标记 |\n\n**已删除（v3.0+）：** `draft:花开时:summary`，cron 条目不再写入 memory hash。\n\n## 部署\n\n### 1. 基础安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n### 2. 创建 OpenClaw cron（核心）\n\n```bash\nPROMPT=$(cat scripts/openclaw_cron_prompt.txt)\nopenclaw cron add \\\n --name \"记忆自动同步\" \\\n --every 1h \\\n --session isolated \\\n --timeout-seconds 120 \\\n --thinking minimal \\\n --tools \"exec,read,write,edit\" \\\n --no-deliver \\\n --message \"$PROMPT\"\n```\n\n## Session 启动检查\n\n每次新 session 启动时加载近期记忆：\n\n```bash\nbash scripts/redis_memory.sh get 花开时\ncat /tmp/redis_memory_warning_花开时.flag 2>/dev/null\n```\n\n## v3.1.1 相比 v3.1 的改动（2026-05-25）\n\n### 核心架构改动\n- **合并exec调用：** 文件查找+对话提取+Redis查重合并为一个脚本，变量不会跨exec丢失（原v3.1三步分离，变量会在独立shell中丢失）\n- **Redis原子写入：** 用 Lua 脚本（`EVAL`）替代三次独立 `redis-cli` 调用，保证 HSET + EXPIRE + SET last_seen 在同一事务中完成\n- **分布式锁：** `SET NX EX 600` 防并发，cron 卡住时最长600秒自动释放（`trap cleanup EXIT` 保底）\n- **重试机制：** 文件读取失败时最多重试 2 次，间隔 1 秒\n\n### 修复的 bug\n- **找文件：** 从按匹配数取最多改为按 `ls -t` 修改时间取最新，避免旧文件碾压新 session\n- **shell语法：** `grep -c` 后加 `|| echo 0` 兜底，消除 `[: 0: integer expression expected`\n- **阈值：** 从 5 降到 2，短对话也能被收录\n\n### 脚本改进\n- **参数校验完善：** 所有脚本增加参数个数和内容校验，防止因参数不足产生幽灵记录\n- **用户名校验：** `redis_memory_user.sh` 启动时检测 USERNAME 是否仍为占位符，防止写入 `memory:your_username`\n- **用户列表外部化：** `cron_heartbeat_ping.sh` 支持环境变量 `REDIS_MEMORY_USERS`、配置文件 `/etc/redis-memory-users.conf` 或硬编码数组三种方式\n- **redis_memory.sh 新增：** `ping` 命令（检查Redis连通性）、`stats` 命令（统计各用户记忆天数/字符数）\n- **天数限制：** `recent` 命令上限 30 天，防止误传大数字导致遍历全部历史\n\n## 版本历史\n\n- v1.0 (2026-05-16) — 基础 Redis 记忆存储\n- v1.1 (2026-05-17) — 多用户隔离 + SOUL 铁律\n- v2.0 (2026-05-20) — draft 机制 + 三层保底 + 启动恢复\n- v2.1 (2026-05-21) — cron 脚本增强 + 用户专用脚本\n- v3.0 (2026-05-23) — 系统自动读会话写摘要，Agent 零负担\n- **v3.1 (2026-05-23) — 修复 dmScope 隔离问题，改用文件路径；增加去重/过滤逻辑**\n- **v3.1.1 (2026-05-25) — 架构大修：合并exec、Lua原子写入、分布式锁、重试机制、redis_memory.sh全面升级**\n\nFile v3.1.1:README.md\n\n# Redis Memory System v3.1.1 — 全自动跨 Session 短期记忆\n\n专为个人开发者设计的轻量级 Redis 记忆方案。**无需 Agent 手动操作**，OpenClaw cron 每小时自动从 transcript 文件读取对话并写入 Redis。\n\n## 适配环境\n\n- **规格**：4核 4G 内存 / 40G 磁盘\n- **系统**：Ubuntu 22.04 LTS\n- **Redis**：单机模式，默认配置\n- **Agent**：OpenClaw（任意版本）\n\n占用 < 50MB 内存，磁盘消耗可忽略。\n\n## 一键安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n## 架构\n\n```\nOpenClaw cron (每1h)\n → [分布式锁] 防并发\n → 读 transcript 文件（ls -t 按时间取最新）\n → LLM 总结 + 语义去重\n → [Lua脚本] 原子写入 Redis（HSET+EXPIRE+last_seen）\n\n系统 cron (每1h)\n → 写心跳到隔离 key cron:health\n → 逐用户检查摘要是否丢失\n → 异常时写告警 flag 文件\n\nAgent (你)\n → 什么都不用做\n```\n\n## v3.1.1 核心改进\n\n- **合并 exec 调用**：文件查找+摘要提取+Redis查询合并为一个脚本，消除变量跨进程丢失\n- **Lua 原子写入**：`EVAL` 脚本保证 HSET + EXPIRE + last_seen 在同一事务完成\n- **分布式锁**：`SET NX EX 600` 防止两个 cron 同时运行\n- **重试机制**：文件读取失败最多重试 2 次\n- **参数校验**：所有操作防空参、防类型错误\n- **用户列表外部化**：环境变量 / 配置文件 / 硬编码三种配置方式\n\n## Redis Key 设计\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:<用户名>` | Hash | 7天 | 每日对话摘要，field=日期, value=文本 |\n| `cron:health` | Hash | 7天 | 系统心跳（隔离，不污染记忆） |\n| `activity:<用户名>:last_seen` | String | 12h | 最后活跃时间标记 |\n| `cron_lock:memory_sync` | String | 10min | 分布式锁，防并发 |\n\n## 文件说明\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/setup.sh` | 一键安装 |\n| `scripts/redis_memory.sh` | 通用记忆操作（查/写/统计/检查） |\n| `scripts/redis_memory_isolated.sh` | 环境变量指定用户 |\n| `scripts/redis_memory_user.sh` | 硬编码用户名专用 |\n| `scripts/cron_heartbeat_ping.sh` | 系统监控哨兵（用户列表可选配置） |\n| `openclaw_cron_prompt.txt` | OpenClaw cron 的 system prompt |\n\nFile v3.1.1:_meta.json\n\n{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"3.1.1\",\n \"publishedAt\": 1779703848129\n}\n\nFile v3.1.1:openclaw_cron_prompt.txt\n\n你是记忆同步助手，每1小时自动为花开时生成每日摘要并存入Redis。\n注意：dmScope隔离下不能通过sessions_list读对话，必须直读transcript文件。\n\n执行下面这个完整的脚本（一个exec完成所有操作）：\n\nexec:\nSESSIONS_DIR=\"/root/.openclaw/agents/main/sessions\"\nTODAY=$(date +%Y-%m-%d)\nLOCK_KEY=\"cron_lock:memory_sync\"\nLOCK_TTL=600\nMAX_RETRIES=2\nSUMMARY_MAX_LEN=2000\n\n# 防并发锁\nif ! redis-cli SET \"$LOCK_KEY\" \"$$\" NX EX \"$LOCK_TTL\" 2>/dev/null; then\n echo \"LOCK_FAIL: 另一个cron正在运行\"; exit 0\nfi\ncleanup() { redis-cli DEL \"$LOCK_KEY\" >/dev/null 2>&1; }\ntrap cleanup EXIT\n\n# 1. 找最新且包含用户对话的transcript文件（排除.trajectory和cron自引用）\nBEST_FILE=\"\"\nfor f in $(ls -t \"$SESSIONS_DIR\"/*.jsonl 2>/dev/null | grep -v \".trajectory\"); do\n # 跳过cron自引用：检查文件名是否以cron ID开头（不严谨但有效）\n COUNT=$(grep -c \"o9cq80wIv9Q0CjVvF9JHP4oNmg48\" \"$f\" 2>/dev/null || echo 0)\n if [ \"$COUNT\" -ge 2 ]; then\n BEST_FILE=\"$f\"\n break\n fi\ndone\necho \"FILE=$BEST_FILE\"\n\n# 2. 提取对话（带重试）\nDIALOG_OUT=\"\"\nif [ -n \"$BEST_FILE\" ]; then\n for attempt in $(seq 1 $MAX_RETRIES); do\n DIALOG_OUT=$(python3 -c \"\nimport json, sys\ntry:\n lines = open(sys.argv[1]).readlines()\n for line in lines[-200:]:\n try:\n m = json.loads(line.strip())\n if m.get('type') != 'message': continue\n msg = m.get('message', {})\n role = msg.get('role', '')\n content = msg.get('content', '')\n if isinstance(content, list):\n for c in content:\n if c.get('type') == 'text' and c.get('text', '').strip():\n txt = c['text'][:300]\n print(f'{role}: {txt}')\n elif isinstance(content, str) and len(content) < 500 and content.strip():\n print(f'{role}: {content[:300]}')\n except:\n pass\nexcept Exception as e:\n print(f'PARSE_ERROR: {e}')\n sys.exit(1)\n\" \"$BEST_FILE\" 2>/dev/null || echo \"PARSE_ERROR\")\n [ -n \"$DIALOG_OUT\" ] && [ \"$DIALOG_OUT\" != \"PARSE_ERROR\" ] && break\n sleep 1\n done\nfi\necho \"$DIALOG_OUT\"\necho \"---END_DIALOG---\"\n\n# 3. 检查Redis现有摘要\nEXISTING=$(redis-cli HGET \"memory:花开时\" \"$TODAY\" 2>/dev/null || echo \"\")\necho \"EXISTING_LEN=${#EXISTING}\"\necho \"EXISTING=[${EXISTING:0:200}]\"\n\n# 4. 如果已有摘要太长，做截断标记\nif [ \"${#EXISTING}\" -gt \"$SUMMARY_MAX_LEN\" ]; then\n echo \"WARN: 今日摘要已超过${SUMMARY_MAX_LEN}字符，考虑压缩\"\nfi\necho \"---END_META---\"\n\n根据输出做决策（用中文回复）：\na) FILE为空或无user角色消息 → NOTHING_NEW（退出，不写入）\nb) 有user消息 → 生成2-3句中文摘要\nc) 去重：\n - EXISTING为空 → 直接写入新摘要\n - 新摘要与EXISTING核心信息重复 → ALREADY_SYNCED\n - 有新信息 → 追加：\"原摘要\\n后续: 新摘要\"\n - 若追加后长度超过SUMMARY_MAX_LEN → 压缩为精简版\n\n确认后执行原子写入：\nexec:\nTODAY=$(date +%Y-%m-%d)\nread -r SUMMARY\n# 使用Lua脚本保证原子性（HSET + EXPIRE + SET last_seen 在同一事务中）\nredis-cli EVAL \"\n redis.call('HSET', 'memory:花开时', ARGV[1], ARGV[2])\n redis.call('EXPIRE', 'memory:花开时', 604800)\n redis.call('SET', 'activity:花开时:last_seen', ARGV[3], 'EX', 43200)\n return 'OK'\n\" 0 \"$TODAY\" \"$SUMMARY\" \"$(date '+%Y-%m-%d %H:%M')\"\necho \"DONE_SIZE=${#SUMMARY}\"\n\n只允许 exec、read 工具\n禁止 sleep、open\n\nArchive v3.0.0: 9 files, 12472 bytes\n\nFiles: openclaw_cron_prompt.txt (2383b), README.md (2042b), scripts/cron_heartbeat_ping.sh (2459b), scripts/redis_memory_isolated.sh (2617b), scripts/redis_memory_user.sh (4341b), scripts/redis_memory.sh (3221b), scripts/setup.sh (3376b), SKILL.md (4175b), _meta.json (138b)\n\nFile v3.0.0:SKILL.md\n\n---\nname: redis-memory-system\ndescription: \"跨会话自动记忆系统 v3.1 — OpenClaw cron 每小时自动从 transcript 文件读取对话并写 Redis。解决 dmScope 隔离下 cron 子 session 无法通过 sessions_list 读取主会话的问题。\"\n---\n\n# Redis 记忆系统 v3.1\n\n**核心思路：Agent 零负担，系统自动完成。cron 子 session 绕过 dmScope 限制，通过文件系统直读 transcript。**\n\n## 适用人群 / Target Audience\n\n**中文**\n- OpenClaw 个人或团队用户，希望 Agent 拥有跨会话记忆能力\n- 运维过多位家庭成员/团队成员的 Agent 账号，需要数据隔离\n- 对 OpenClaw 的 dmScope / Cron / Skill 有一定了解\n- 能使用基本的 Shell 命令和 Redis\n\n**English**\n- OpenClaw users (individual or team) who want their Agent to remember across sessions\n- Those running multiple Agent accounts (family members / team) and need data isolation\n- Familiar with OpenClaw's dmScope, Cron, and Skill system\n- Comfortable with basic Shell commands and Redis\n\n## 架构\n\n```\nOpenClaw Cron (每1h)\n → exec: 找 transcript 文件\n → exec: tail -200 提取对话\n → LLM 总结（去重 + 过滤元指令）\n → redis-cli HSET memory:花开时 YYYY-MM-DD \"摘要\"\n\n系统 Cron (每1h)\n → cron:health 写心跳（隔离，不污染记忆）\n → 检查今天有无摘要 → 丢就写告警 flag\n\nAgent（你）\n → 什么都不用做\n```\n\n## 关键解决的问题\n\n| 问题 | 方案 |\n|------|------|\n| dmScope 隔离导致 cron 子 session 看不到主会话 | 文件系统直读 transcript JSONL |\n| tail -200 读到元指令/调试内容 | 提示词要求过滤 \"sleep/再触发/poll\" 等技术内容 |\n| 重复追加相同摘要 | 语义去重—新旧摘要表达相同信息时跳过 |\n| cron 污染 memory hash | cron 心跳写到隔离 key `cron:health` |\n| 覆盖用户少 | 多用户各自独立 cron（目前花开时已配，安安待配） |\n\n## 文件说明\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/setup.sh` | 一键安装 |\n| `scripts/redis_memory.sh` | 通用记忆操作（查/写） |\n| `scripts/redis_memory_isolated.sh` | 环境变量指定用户 |\n| `scripts/redis_memory_user.sh` | 硬编码用户名专用 |\n| `scripts/cron_heartbeat_ping.sh` | 系统监控哨兵（只告警，不写记忆） |\n| `openclaw_cron_prompt.txt` | OpenClaw cron 的 system prompt（v3.1 核心） |\n\n## 🔑 Redis Key 设计\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:花开时` | Hash | 7天 | 每日对话摘要 |\n| `cron:health` | Hash | 7天 | 系统心跳（隔离） |\n| `activity:花开时:last_seen` | String | 12h | 最后活跃时间标记 |\n\n**已删除（v3.0+）：** `draft:花开时:summary`，cron 条目不再写入 memory hash。\n\n## 部署\n\n### 1. 基础安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n### 2. 创建 OpenClaw cron（核心）\n\n```bash\nPROMPT=$(cat scripts/openclaw_cron_prompt.txt)\nopenclaw cron add \\\n --name \"记忆自动同步\" \\\n --every 1h \\\n --session isolated \\\n --timeout-seconds 120 \\\n --thinking minimal \\\n --tools \"exec,read,write,edit\" \\\n --no-deliver \\\n --message \"$PROMPT\"\n```\n\n## Session 启动检查\n\n每次新 session 启动时加载近期记忆：\n\n```bash\nbash scripts/redis_memory.sh get 花开时\ncat /tmp/redis_memory_warning_花开时.flag 2>/dev/null\n```\n\n## v3.1 相比 v3.0 的改动\n\n- **绕过 dmScope：** 从 `sessions_list/sessions_history` 改为文件系统直读 transcript\n- **去重：** 语义比较新旧摘要，不重复写\n- **过滤：** 过滤技术调试/元指令内容\n- **cron payload 模板化：** 独立为 `openclaw_cron_prompt.txt`\n- **工具限制：** `--tools exec,read,write,edit` 防止 cron 递归触发\n\n## 版本历史\n\n- v1.0 (2026-05-16) — 基础 Redis 记忆存储\n- v1.1 (2026-05-17) — 多用户隔离 + SOUL 铁律\n- v2.0 (2026-05-20) — draft 机制 + 三层保底 + 启动恢复\n- v2.1 (2026-05-21) — cron 脚本增强 + 用户专用脚本\n- v3.0 (2026-05-23) — 系统自动读会话写摘要，Agent 零负担\n- **v3.1 (2026-05-23) — 修复 dmScope 隔离问题，改用文件路径；增加去重/过滤逻辑**\n\nFile v3.0.0:README.md\n\n# Redis Memory System v3.1 — 全自动跨 Session 短期记忆\n\n专为个人开发者设计的轻量级 Redis 记忆方案。**无需 Agent 手动操作**，OpenClaw cron 每小时自动从 transcript 文件读取对话并写入 Redis。\n\n## 适用人群 / Target Audience\n\n**中文**\n- OpenClaw 个人或团队用户，希望 Agent 拥有跨会话记忆能力\n- 运维过多位家庭成员/团队成员的 Agent 账号，需要数据隔离\n- 对 OpenClaw 的 dmScope / Cron / Skill 有一定了解\n- 能使用基本的 Shell 命令和 Redis\n\n**English**\n- OpenClaw users (individual or team) who want their Agent to remember across sessions\n- Those running multiple Agent accounts (family members / team) and need data isolation\n- Familiar with OpenClaw's dmScope, Cron, and Skill system\n- Comfortable with basic Shell commands and Redis\n\n## 适配环境\n\n- **规格**：4核 4G 内存 / 40G 磁盘\n- **系统**：Ubuntu 22.04 LTS\n- **Redis**：单机模式，默认配置\n- **Agent**：OpenClaw（任意版本）\n\n占用 < 50MB 内存，磁盘消耗可忽略。\n\n## 一键安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n## 架构\n\n```\nOpenClaw cron (每1h) → 读 transcript 文件 → LLM 总结 → 写 Redis\n系统 cron (每1h) → 写心跳 → 检查丢失 → 告警\nAgent (你) → 什么都不用做\n```\n\n## v3.1 核心改进\n\n- **绕过 dmScope：** 从 sessions_list 改为文件系统直读 transcript JSONL\n- **去重：** 语义比较新旧摘要，不重复写\n- **过滤：** 过滤技术调试/元指令内容\n- **cron payload 模板化：** 独立为 `openclaw_cron_prompt.txt`\n\n## 文件说明\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/setup.sh` | 一键安装 |\n| `scripts/redis_memory.sh` | 通用记忆操作（查/写） |\n| `scripts/redis_memory_isolated.sh` | 环境变量指定用户 |\n| `scripts/redis_memory_user.sh` | 硬编码用户名专用 |\n| `scripts/cron_heartbeat_ping.sh` | 系统监控哨兵 |\n| `openclaw_cron_prompt.txt` | OpenClaw cron 的 system prompt |\n\nFile v3.0.0:_meta.json\n\n{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"3.0.0\",\n \"publishedAt\": 1779620416653\n}\n\nFile v3.0.0:openclaw_cron_prompt.txt\n\n你是记忆同步助手，每1小时自动为花开时生成每日摘要并存入Redis。\n\n注意：由于 dmScope 隔离，sessions_list/sessions_history 不可用。必须通过读 transcript 文件获取对话。\n\n步骤：\n\n1. 找到花开时（user ID: o9cq80wIv9Q0CjVvF9JHP4oNmg48）的最新 transcript 文件：\n exec:\n BEST=\"\"; BESTC=0\n for f in /root/.openclaw/agents/main/sessions/*.jsonl; do\n case \"$f\" in *.trajectory*) continue;; esac\n c=$(grep -c \"o9cq80wIv9Q0CjVvF9JHP4oNmg48\" \"$f\" 2>/dev/null || echo 0)\n if [ \"$c\" -gt \"$BESTC\" ]; then BESTC=$c; BEST=\"$f\"; fi\n done\n echo \"FILE=$BEST COUNT=$BESTC\"\n 要求 COUNT > 5 才确认真实对话\n\n2. 提取文件末尾 200 行中的真实对话内容：\n exec:\n python3 -c \"\nimport json\nlines = open('').readlines()\nfor line in lines[-200:]:\n try:\n m = json.loads(line.strip())\n if m.get('type') == 'message':\n msg = m.get('message', {})\n role = msg.get('role', '')\n content = msg.get('content', '')\n if isinstance(content, list):\n for c in content:\n if c.get('type') == 'text':\n txt = c.get('text', '')[:300]\n if txt.strip():\n print(f'{role}: {txt}')\n elif isinstance(content, str) and len(content) < 500:\n print(f'{role}: {content[:300]}')\n except: pass\n\"\n\n3. 查询今天已有摘要：\n exec:\n TODAY=$(date +%Y-%m-%d)\n EXISTING=$(redis-cli HGET \"memory:花开时\" \"$TODAY\" 2>/dev/null || echo \"\")\n echo \"EXISTING=[${EXISTING}]\"\n\n4. 分析并决策：\n a) 如果 tail 中没有最近 1 小时内的真实对话（全是技术元指令如 sleep/再触发/poll 等）→ NOTHING_NEW\n b) 如果有真实对话，生成 2-3 句中文摘要，过滤掉技术调试/元指令/系统操作\n c) 去重判断：\n - EXISTING 为空 → 直接写入新摘要\n - EXISTING 不为空，比较新摘要是否表达了相同核心信息：\n * 高度重复 → ALREADY_SYNCED（不写入）\n * 有新信息 → 追加: \"原摘要\\n后续: 新摘要\"\n\n5. 执行写入：\n exec:\n redis-cli HSET \"memory:花开时\" \"$TODAY\" \"摘要内容\"\n redis-cli EXPIRE \"memory:花开时\" 604800\n redis-cli SET \"activity:花开时:last_seen\" \"$(date)\" EX 43200\n echo \"DONE\"\n\nArchive v2.1.0: 7 files, 11888 bytes\n\nFiles: README.md (2150b), redis-memory-system_CHANGELOG.md (2005b), scripts/cron_heartbeat_ping.sh (3136b), scripts/redis_memory_user.sh (4341b), scripts/setup.sh (3376b), SKILL.md (10404b), _meta.json (138b)\n\nFile v2.1.0:SKILL.md\n\n---\nname: redis-memory-system\ndescription: Redis-based cross-session memory system for OpenClaw agents. One-command setup, zero config. Automatically reads recent memory at session start (via bootstrap) and writes hourly summaries (via system cron). 7-day TTL, multi-user isolation via dual scripts. Use when agents need short-term memory that survives session resets without manual configuration, or when implementing multi-account memory isolation.\n---\n\n# Redis 记忆系统 v2.1\n\n跨 session 短期记忆。所有数据 7 天自动过期，不撑磁盘。\n\n## 适用场景 ✅\n\n- **跨 session 记忆保持** — Agent 会话被回收后（04:00重置/空闲120分钟/24h无交互），醒来能记得之前聊了什么\n- **多账号隔离** — 同一 Redis 实例服务多个用户，每人数据互不可见\n- **短期记忆保底** — 对话意外中断时，Heartbeat/Cron 自动写入防止丢记忆\n- **系统操作审计** — 记录下载文件、安装软件等后台操作，避免\"谁干的\"问题\n- **话题切换自动保存** — 不再只在对话结束时才存，换话题就写，减少丢失风险\n\n## 不适用场景 ❌\n\n- **单轮/单条对话查询** — 本技能只存**每日摘要**，不存逐条对话记录\n- **永久记忆** — 数据 7 天自动过期。要永久保留请配合 MEMORY.md\n- **实时消息同步** — 这不是消息队列，不是 WebSocket 替代品\n- **大规模数据存储** — 每条记忆建议 < 2KB\n- **没有 Redis 的环境** — 机器没装 Redis 的话这个技能没用\n\n## 一句话架构\n\n```\nSession → draft key (12h TTL) → 三层自动写入 → memory key (7天)\n ├── 系统 Cron（每小时）\n ├── OpenClaw Cron（每2h兜底）\n └── Heartbeat（每次心跳）\n```\n\n加上 v2.1 新增的：\n```\nSession 启动恢复检查 → 如果上次有活跃但无摘要 → 主动询问\n话题切换自动写 draft → 不等到对话结束，换话题就写\nHeartbeat 不再跳过 → 活跃 session 也写 activity 标记\n```\n\n## 一键安装（推荐）\n\n```bash\n# 一条命令配好所有\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n安装完成后自动生效：\n- ✅ **每次 session 启动** → .bootstrap 自动加载近期记忆\n- ✅ **每小时整点** → 系统 cron 自动写入 + 检查 draft 升级\n- ✅ **话题切换时** → 自动按规则写入 draft 摘要\n- ✅ **启动恢复检查** → 检测上次是否有未同步的记忆\n\n## 脚本一览\n\n### `scripts/redis_memory.sh` — 通用版（推荐入门）\n\n多用户，用 `memory:<用户名>` 的 hash 结构隔离。\n\n```bash\nbash scripts/redis_memory.sh get aaa # 查最近3天\nbash scripts/redis_memory.sh get aaa 2026-05-17 # 查某天\nbash scripts/redis_memory.sh set aaa 2026-05-17 \"聊了xxx\"\nbash scripts/redis_memory.sh recent aaa 7 # 查最近7天\nbash scripts/redis_memory.sh action 2026-05-17 # 记录系统操作\n```\n\n### `scripts/redis_memory_isolated.sh` — 隔离版（环境变量）\n\n通过 `REDIS_MEMORY_USER` 环境变量指定用户，适合通用部署场景。\n\n```bash\nREDIS_MEMORY_USER=aaa bash scripts/redis_memory_isolated.sh get\nREDIS_MEMORY_USER=aaa bash scripts/redis_memory_isolated.sh set 2026-05-17 \"摘要\"\n```\n\n### `scripts/redis_memory_user.sh` — 用户专用版（v2.1 新增）\n\n直接把用户名硬编码在脚本里，适合**每个用户独立部署一份**。最\"笨\"但最安全的方式——完全杜绝输错用户名的可能。\n\n```bash\n# 1. 创建副本，修改 USERNAME\ncp scripts/redis_memory_user.sh scripts/redis_memory_an.sh\n# 2. 编辑 USERNAME=\"an\"\n# 3. 使用\nbash scripts/redis_memory_an.sh get\nbash scripts/redis_memory_an.sh set 2026-05-21 \"今天聊了什么\"\n```\n\n### `scripts/cron_heartbeat_ping.sh` — 保底cron（v2.1 新增）\n\n每小时执行一次的系统 cron 脚本。做三件事：\n1. 写入存活 ping + session 活跃标记\n2. 检查 draft key，有未同步内容就升级为永久记录\n3. 报告兜底状态（今天有活跃但没摘要 = 告警）\n\n```bash\n# 配置用户名后添加到 crontab\n0 * * * * /path/to/cron_heartbeat_ping.sh >> /tmp/redis_memory.log 2>&1\n```\n\n## 核心设计\n\n### 存储结构\n\n```\nmemory:<用户名> → Redis Hash（用户记忆，7天TTL）\n └─ 2026-05-21 → \"今天的摘要内容\"\n\ndraft:<用户名>:summary → Redis String（草稿，12h TTL）\n └─ 值 → \"正在写的摘要\"\n\nactivity:<用户名>:last_seen → Redis String（活跃标记，12h TTL，v2.1新增）\n └─ 值 → \"2026-05-21 14:16 (active)\"\n```\n\n### 写入时机（铁律）\n\nAgent 在以下时刻**必须**写入 draft key：\n\n1. ✅ **话题结束换话题** — 一定要写\n2. ✅ **用户说晚安/拜拜** — 一定要写\n3. ✅ **对话持续 > 30分钟** — 中间写一次防断连\n4. ✅ **后台操作完成** — 下载文件、安装软件等\n\n### 三层写入链路\n\n```\n我（对话中）→ draft:用户:summary (12h TTL，话题切换时写)\n ↓\n ┌──────────┼──────────┐\n ↓ ↓ ↓\n 系统Cron OpenClaw Heartbeat\n (每小时) Cron(2h) (每次心跳)\n ↓ ↓ ↓\n memory:用户:YYYY-MM-DD (7天永久)\n```\n\n三层互相独立，任意一层成功就算数。\n\n### v2.1 新增：Session 启动恢复检查\n\n每次 session 启动后，在回复用户之前执行检查：\n\n```bash\nLAST_SEEN=$(redis-cli GET \"activity:用户:last_seen\")\nDRAFT=$(redis-cli GET \"draft:用户:summary\")\nTODAY=$(date +%Y-%m-%d)\nMEMORY=$(redis-cli HGET \"memory:用户\" \"$TODAY\")\n\nif [ -n \"$DRAFT\" ] && [ -z \"$MEMORY\" ]; then\n # Draft 有内容但 memory 没同步 → 手动升级\n redis-cli HSET \"memory:用户\" \"$TODAY\" \"$DRAFT\"\n redis-cli DEL \"draft:用户:summary\"\n echo \"♻️ 恢复未同步的 draft → memory\"\nelif [ -z \"$MEMORY\" ] && [ -n \"$LAST_SEEN\" ]; then\n echo \"⚠️ 上次有活跃 session 但摘要丢失\"\nfi\n```\n\n### v2.1 新增：Heartbeat 不再跳过\n\n每次 heartbeat 都执行（不跳过活跃 session）：\n1. 写入 `activity:用户:last_seen` 为当前时间戳（12h过期）\n2. 检查 `draft:用户:summary` → 有内容直接升级\n3. 即使 draft 为空也记录活跃标记\n\n### 多用户隔离方案\n\n| 场景 | 推荐方案 |\n|------|---------|\n| 单用户 | 直接用 `redis_memory.sh` |\n| 多用户但互信 | 共用 `redis_memory.sh`，按用户名读写 |\n| **多用户需完全隔离** | 每人一个 `redis_memory_user.sh` 副本 + SOUL.md 铁律 |\n\n**技术 + 行为双重保障：**\n\n1. **技术层** — 每个用户独立脚本，key 空间物理隔离\n2. **行为层** — SOUL.md 铁律禁止跨账号读取\n\n### SOUL.md 隔离铁律范本\n\n```markdown\n## 🔴 Redis 隔离铁律（跨账号记忆保护）\n\n| 用户 | 脚本 | 数据key |\n|------|------|---------|\n| 用户A | `scripts/redis_memory_a.sh` | `memory:用户A` |\n| 用户B | `scripts/redis_memory_b.sh` | `memory:用户B` |\n\n### 对话中的选择规则\n- **用户A的 session** → 只能用 `redis_memory_a.sh get`\n- **用户B的 session** → 只能用 `redis_memory_b.sh get`\n\n### ❌ 绝对禁止\n- 在用户A的对话里读取用户B的Redis记忆\n- 用A的脚本查B的数据\n- 主动告诉任何一方对方在Redis里存了什么\n\n### ✅ 例外\n- 用户A主动要求查看用户B的记忆 → 需先确认\"确认要打破隔离吗？\"，得到肯定答复后才执行\n```\n\n## 配置参数\n\n| 参数 | 默认值 | 说明 |\n|------|--------|------|\n| Redis host | localhost | 可通过环境变量 `REDIS_HOST` 配置 |\n| Redis port | 6379 | 可通过环境变量 `REDIS_PORT` 配置 |\n| TTL | 604800 (7天) | 可通过脚本内 `EXPIRE` 命令调整 |\n| Draft TTL | 43200 (12h) | 草稿 key 自动过期时间 |\n| Activity TTL | 43200 (12h) | 活跃标记过期时间 |\n| 查询窗口 | 最近3天 | `get` 默认查3天；`recent N` 可调 |\n\n## 磁盘占用预估\n\n每条记忆约 500 字节 - 2 KB。4个用户每天对话，一年的数据量 < 5 MB。\n内存占用同理——7天窗口在 Redis 里不过几十 KB。\n\n## v2.1 更新说明（2026-05-21）\n\n### 新增文件\n\n| 文件 | 说明 |\n|------|------|\n| `scripts/cron_heartbeat_ping.sh` | 增强版系统 cron 脚本，含 session 活跃标记 + draft 自动升级 + 兜底报告 |\n| `scripts/redis_memory_user.sh` | 用户专用脚本，直接硬编码用户名，最安全的隔离方案 |\n\n### 新增功能\n\n1. **Session 活跃标记** — `activity:<用户>:last_seen`，即使 draft 为空也能追踪活动状态\n2. **启动恢复检查** — Session 启动时检测上次是否有活跃但摘要丢失，主动询问用户\n3. **Heartbeat 不再跳过活跃 Session** — 每次心跳都写入标记 + 检查 draft\n4. **话题切换自动写 draft** — 不等到对话结束，换话题就写，减少丢失风险\n5. **用户专用脚本模式** — `redis_memory_user.sh`，硬编码用户名，从源头杜绝跨账号误操作\n\n### 相比 v2.0 的改进\n\n- **更健壮的保底** — draft 为空时也能追踪到\"有过活跃 session\"\n- **更安全的隔离** — 用户专用脚本 vs 环境变量，100% 杜绝输错\n- **更少的丢失** — 话题切换写 + 启动恢复 + Heartbeat 不跳过，三层保底\n\n## v2.0 更新说明（2026-05-20）\n\n### 为什么之前的架构失效了？\n\n**原有架构（v1.1）：**\n```\n我(对话中) → draft:用户:summary (12h TTL) → 系统cron → memory永久\n```\n\n**问题：** 所有环节都是被动转发者，没有主动生成者。Cron/Heartbeat 只能**转发**已有的 draft，不能**创造**内容。\n\n### 2026-05-20 事故\n\n连续2小时对话中 Agent 没写 draft → cron 每小时空转 → 2小时对话全丢。\n\n**根因：**\n1. Agent 在连续对话中没有写 draft key（违反规则）\n2. Heartbeat 在活跃 session 时跳过\n3. 系统 cron 每小时跑但 draft 为空 → 空转\n\n### v2.0 改了什么\n\n1. **Cron脚本升级** — 即使 draft 为空，也记录 session 活跃标记\n2. **Heartbeat 不再跳过** — 每次心跳都写入时间戳+检查 draft\n3. **Session 启动恢复** — 启动时检查是否有活跃但摘要丢失\n4. **写入时机从\"对话结束时\"改为\"话题切换时\"**\n\nFile v2.1.0:README.md\n\n# Redis Memory System v2.1 — 跨 Session 短期记忆\n\n开箱即用。运行安装脚本后无需任何配置，自动读写 Redis。\n\n## 一键安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n安装后自动：\n- ✅ 每次 Session 启动 → 加载近期记忆\n- ✅ 每小时整点 → cron 保底写入 + draft 自动升级\n- ✅ 话题切换时 → 自动写入摘要\n- ✅ Session 启动 → 恢复检查（检测未同步内容）\n\n## 手动安装\n\n```bash\n# 1. 安装并启动 Redis\napt install redis-server -y # 或 yum install redis\nredis-server --daemonize yes\n\n# 2. 验证\nredis-cli PING # → PONG\n\n# 3. 使用脚本\nchmod +x scripts/redis_memory.sh\nbash scripts/redis_memory.sh set 用户名 2026-05-21 \"今天聊了什么\"\nbash scripts/redis_memory.sh get 用户名\n```\n\n## 文件结构（v2.1）\n\n```\nredis-memory-system/\n├── README.md\n├── SKILL.md # 完整使用文档\n├── redis-memory-system.skill # ClawHub 打包文件\n└── scripts/\n ├── setup.sh # 一键安装\n ├── redis_memory.sh # 通用版\n ├── redis_memory_isolated.sh # 隔离版（环境变量）\n ├── redis_memory_user.sh # 用户专用版（硬编码用户名，v2.1新增）\n └── cron_heartbeat_ping.sh # 保底cron脚本（v2.1新增）\n```\n\n## v2.1 新增\n\n- **Session 活跃标记** — 即使没有写对话摘要也能追踪到\"有过活跃 session\"\n- **启动恢复检查** — 检测上次 session 是否有未同步内容\n- **用户专用脚本** — `redis_memory_user.sh`，硬编码用户名，杜绝跨账号误操作\n- **保底 cron 脚本** — `cron_heartbeat_ping.sh`，升级 draft + 写活跃标记 + 兜底报告\n\n## ⚠️ Redis 持久化\n\n**默认不保证持久化。** 如需重启不丢数据，修改 `/etc/redis/redis.conf`：\n\n```conf\nsave 900 1\nappendonly yes\n```\n\n不改也行——7 天过期，丢了就当自然遗忘。\n\n## 安全\n\n- 默认监听 127.0.0.1，仅本机可访问\n- 数据存明文，**不要存密码或密钥**\n- 7 天 TTL 自动过期，无需手动清理\n\nFile v2.1.0:_meta.json\n\n{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"2.1.0\",\n \"publishedAt\": 1779372442274\n}\n\nFile v2.1.0:redis-memory-system_CHANGELOG.md\n\n# Redis Memory System — 更新日志\n\n---\n\n## v2.1 (2026-05-21)\n\n### 新增文件\n- `scripts/cron_heartbeat_ping.sh` — 增强版系统 cron 脚本\n- `scripts/redis_memory_user.sh` — 用户专用脚本（硬编码用户名）\n\n### 新增功能\n- **Session 活跃标记** — `activity:<用户>:last_seen`，即使 draft 为空也能追踪活动\n- **启动恢复检查** — Session 启动时检测上次活跃但摘要丢失 → 主动询问用户\n- **Heartbeat 不再跳过活跃 Session** — 每次心跳写入标记 + 检查 draft\n- **话题切换自动写 draft** — 不等到对话结束，换话题就写\n- **用户专用脚本模式** — 硬编码用户名，从源头杜绝跨账号误操作\n\n### 改进\n- setup.sh 集成 cron_heartbeat_ping.sh 安装\n- 三层写入更健壮：draft 为空时也有活跃标记兜底\n- 文档大幅更新，增加 v2.1 特性说明\n\n---\n\n## v2.0 (2026-05-20)\n\n### 问题修复\n- 修复 v1.1 架构依赖单一 draft key 的问题\n- 修复 Heartbeat 在活跃 session 时跳过不写的问题\n- 修复 Session 重置后完全失忆的问题\n- 新增 session 活跃标记（即使 draft 为空）\n\n### 改进\n- 写入时机从\"对话结束时\"改为\"话题切换时\"\n- 新增启动恢复检查机制\n- 完善 SOUL.md 隔离铁律\n\n---\n\n## v1.1 (2026-05-20)\n\n### 问题修复\n- 修复记忆写入丢失 — Heartbeat 因 target:none 配置静默空跑\n- 修复 Cron 只打卡不存内容 — 重写为自动检测 draft key\n- 修复 Session 重置失忆 — 三层铁壁架构\n- 修复跨账号数据泄露风险 — 新增隔离版脚本 + SOUL.md 铁律\n\n### 改进\n- 三层铁壁写入架构：Agent → draft key → 三层自动写入 → memory\n- Draft key 桥接机制，12小时自动过期\n- 零 Token 成本\n- 多账号隔离：双脚本 + 双 key 空间\n- 7 天自动过期\n\n---\n\n## v1.0 (2026-05-17)\n\n### 初始版本\n- 基础的 Redis 记忆读写脚本\n- 一键安装 setup.sh\n- .bootstrap 自动加载\n- 系统 cron 每小时打卡\n- 7天 TTL\n\nArchive v2.0.0: 6 files, 7443 bytes\n\nFiles: README.md (1346b), scripts/redis_memory_isolated.sh (2617b), scripts/redis_memory.sh (3705b), scripts/setup.sh (3335b), SKILL.md (3587b), _meta.json (138b)\n\nFile v2.0.0:SKILL.md\n\n---\nname: redis-memory-system\ndescription: Redis-based cross-session memory system for OpenClaw agents. One-command setup, zero config. Automatically reads recent memory at session start (via bootstrap) and writes hourly summaries (via system cron). 7-day TTL, multi-user isolation via dual scripts. Use when agents need short-term memory that survives session resets without manual configuration, or when implementing multi-account memory isolation.\nauthor: hualang-c\nversion: \"2.0.0\"\n---\n\n# Redis Memory System — 跨 Session 短期记忆\n\n开箱即用。运行安装脚本后只需两步配置，自动读写 Redis。\n\n## 一键安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n安装后自动：\n- 安装 Redis（如未安装）\n- 注册 **系统 cron（每小时）** → draft→永久升级 + 打卡\n- 拷贝脚本到 `$OPENCLAW_WORKSPACE/scripts/`\n\n## 三步手动配置\n\n### 第1步：安装 Redis\n\n```bash\napt install redis-server -y\nredis-server --daemonize yes\nredis-cli PING # → PONG\n```\n\n### 第2步：注册 OpenClaw Cron（兜底，每2小时）\n\n```bash\nopenclaw cron add \\\n --name '记忆同步(兜底)' \\\n --schedule 'every 2h' \\\n -- \\\n bash /path/to/scripts/cron_memory_ping.sh\n```\n\n这个 cron 的作用：检测 `draft:<用户>:summary` 是否有未同步内容，如果有则升级为永久 Redis 摘要。\n\n### 第3步：配置 Heartbeat（每2小时，兜兜底）\n\nHeartbeat 在 OpenClaw Gateway 配置中：\n\n```bash\ngateway config set heartbeat.every \"2h\"\ngateway config set heartbeat.target \"last\"\ngateway config set heartbeat.isolatedSession false\ngateway config set heartbeat.skipWhenBusy true\n```\n\n或者在 `openclaw.json` 中：\n\n```json\n\"heartbeat\": {\n \"every\": \"2h\",\n \"target\": \"last\",\n \"isolatedSession\": false,\n \"skipWhenBusy\": true\n}\n```\n\n## 三层铁壁写入架构\n\n```\n我（对话中）→ draft key (12h TTL, EX 43200)\n ↓\n 系统 Cron（每小时） → 升级为永久 + 打卡\n ↓\n OpenClaw Cron（每2h兜底）\n ↓\n Heartbeat（每2h兜兜底）\n ↓\n 永久存储 memory:<用户>:YYYY-MM-DD（7天过期）\n```\n\n任意一层成功即保底。\n\n## 对话中的写入规则\n\nAgent 在以下时机调用 `draft` 写入：\n\n```bash\nbash scripts/redis_memory.sh draft <用户> \"<今天的完整摘要>\"\n```\n\n触发时机：\n- **话题结束时** — 一个主题聊完，换话题前写一次\n- **用户说晚安/拜拜** — 对话自然终止\n- **长时间聊天(>30分钟)** — 防止中间断连\n- **空闲逼近** — 察觉很久没说话（>90分钟），主动写一次\n- **重要事件发生时** — 下载文件、安装软件、做决策等\n\n## 文件\n\n```\nredis-memory-system/\n├── README.md # 快速说明\n├── SKILL.md # 完整文档（本文件）\n└── scripts/\n ├── setup.sh # 一键安装（Redis + cron + bootstrap）\n ├── redis_memory.sh # 通用版：get/set/draft/recent/action\n └── redis_memory_isolated.sh # 隔离版（多账号防串读）\n```\n\n## 安全\n\n- 默认监听 127.0.0.1，仅本机可访问\n- 数据存明文，**不要存密码或密钥**\n- 7 天 TTL 自动过期（EXPIRE 604800）\n- **多账号隔离**：`redis_memory_isolated.sh` 通过 `REDIS_MEMORY_USER` 环境变量强制隔离\n- **铁律**：Agent 在对话中必须使用对应的隔离版脚本，不得跨用户访问\n\n## 依赖\n\n- redis-server / redis-cli\n- bash 4+\n- cronie (crontab)\n\nFile v2.0.0:README.md\n\n# Redis Memory System — 跨 Session 短期记忆\n\n开箱即用。运行安装脚本后无需任何配置，自动读写 Redis。\n\n## 一键安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n安装后自动：\n- 每次 Session 启动 → 加载近期记忆\n- 每小时整点 → 写入时间戳保底\n- 对话结束 → 自动写入摘要\n\n## 手动安装\n\n```bash\n# 1. 安装并启动 Redis\napt install redis-server -y # 或 yum install redis\nredis-server --daemonize yes\n\n# 2. 验证\nredis-cli PING # → PONG\n\n# 3. 使用脚本\nchmod +x scripts/redis_memory.sh\nbash scripts/redis_memory.sh set 用户名 2026-05-17 \"今天聊了什么\"\nbash scripts/redis_memory.sh get 用户名\n```\n\n## ⚠️ Redis 持久化\n\n**默认不保证持久化。** 如需重启不丢数据，修改 `/etc/redis/redis.conf`：\n\n```conf\nsave 900 1\nappendonly yes\n```\n\n不改也行——7 天过期，丢了就当自然遗忘。\n\n## 安全\n\n- 默认监听 127.0.0.1，仅本机可访问\n- 数据存明文，**不要存密码或密钥**\n- 7 天 TTL 自动过期，无需手动清理\n\n## 文件\n\n```\nredis-memory-system/\n├── README.md\n├── SKILL.md\n└── scripts/\n ├── setup.sh # 一键安装\n ├── redis_memory.sh # 通用版\n └── redis_memory_isolated.sh # 隔离版\n```\n\nFile v2.0.0:_meta.json\n\n{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"2.0.0\",\n \"publishedAt\": 1779154985524\n}\n\nArchive v1.0.3: 6 files, 8191 bytes\n\nFiles: README.md (1346b), scripts/redis_memory_isolated.sh (2617b), scripts/redis_memory.sh (3221b), scripts/setup.sh (2659b), SKILL.md (6215b), _meta.json (138b)\n\nFile v1.0.3:SKILL.md\n\n---\nname: redis-memory-system\ndescription: Redis-based cross-session memory system for OpenClaw agents. One-command setup, zero config. Automatically reads recent memory at session start (via bootstrap) and writes hourly summaries (via system cron). 7-day TTL, multi-user isolation via dual scripts. Use when agents need short-term memory that survives session resets without manual configuration, or when implementing multi-account memory isolation.\n---\n\n# Redis 记忆系统\n\n跨 session 短期记忆。所有数据 7 天自动过期，不撑磁盘。\n\n## 适用场景 ✅\n\n- **跨 session 记忆保持** — Agent 会话被回收后（04:00重置/空闲120分钟/24h无交互），醒来能记得之前聊了什么\n- **多账号隔离** — 同一 Redis 实例服务多个用户，每人数据互不可见\n- **短期记忆保底** — 对话意外中断时，Heartbeat 自动写入防止丢记忆\n- **系统操作审计** — 记录下载文件、安装软件等后台操作，避免\"谁干的\"这类问题\n\n## 不适用场景 ❌\n\n- **单轮/单条对话查询** — 本技能只存**每日摘要**，不存逐条对话记录。想查某句话说过没有？这不适合你\n- **永久记忆** — 数据 7 天自动过期。要永久保留请配合 MEMORY.md\n- **实时消息同步** — 这不是消息队列，不是 WebSocket 替代品\n- **大规模数据存储** — 每条记忆建议 < 2KB，存大文件请用正经数据库\n- **没有 Redis 的环境** — 如果机器没装 Redis，这个技能没用\n\n## 一句话架构\n\n```\nSession → Redis（7天短期） → Heartbeat（自动续写） → MEMORY.md（长期提炼）\n```\n\n## 一键安装（推荐）\n\n```bash\n# 一条命令配好所有\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n安装完成后自动生效：\n- ✅ **每次 session 启动** → .bootstrap 自动加载近期记忆\n- ✅ **每小时整点** → 系统 cron 自动写入时间戳\n- ✅ **对话结束时** → 自动按规则写入摘要\n\n## 手动配置\n\n```bash\n# 1️⃣ 确保 Redis 运行\nredis-server --daemonize yes\nredis-cli PING\n\n# 2️⃣ 设置脚本\nchmod +x scripts/*.sh\n\n# 3️⃣ 写入记忆\nbash scripts/redis_memory.sh set aaa 2026-05-17 \"今天聊了什么\"\n\n# 4️⃣ 查记忆\nbash scripts/redis_memory.sh get aaa\n```\n\n## 脚本\n\n### `scripts/redis_memory.sh` — 通用版\n\n多用户，用 `memory:<用户名>` 的 hash 结构隔离。\n\n```bash\nbash scripts/redis_memory.sh get aaa # 查最近3天\nbash scripts/redis_memory.sh get aaa 2026-05-17 # 查某天\nbash scripts/redis_memory.sh set aaa 2026-05-17 \"聊了xxx\"\nbash scripts/redis_memory.sh recent aaa 7 # 查最近7天\nbash scripts/redis_memory.sh action 2026-05-17 # 记录系统操作\n```\n\n### `scripts/redis_memory_isolated.sh` — 单用户隔离版\n\n硬编码 key 为固定用户名，通过环境变量指定用户，杜绝跨账号误操作。\n\n```bash\nREDIS_MEMORY_USER=aaa bash scripts/redis_memory_isolated.sh get # 查最近3天\nREDIS_MEMORY_USER=aaa bash scripts/redis_memory_isolated.sh set 2026-05-17 \"摘要\"\n```\n\n## 核心设计\n\n### 存储结构\n\n```\nmemory:<用户名> → Redis Hash（用户记忆）\n └─ 2026-05-16 → \"今天的摘要内容\"\n └─ 2026-05-17 → \"今天的摘要内容\"\n\nactions:system → Redis Hash（系统操作记录）\n └─ 2026-05-16 → \"下载了什么文件\"\n```\n\nKEY 级 TTL = 7 天（604800 秒）。写入即刷新。\n\n### 会话回收临界点\n\n- **04:00 每日重置**（框架层）\n- **120分钟空闲重置**（框架层）\n- **24小时无交互**（微信/消息平台层）\n\n这些时刻之后 session 会丢失上下文，Redis 是唯一的找回路径。\n\n### 自动读取（一键安装后自动生效）\n\n一键安装会在 workspace 创建 `.bootstrap/redis-memory.md`，每次 session 启动时自动加载 Redis 查询指令。无需配置 SOUL.md 铁律。\n\n### 手动写入规则（Agent 行为）\n\nAgent 在以下时刻应主动写入 Redis：\n1. **对话结束时** — 用户说「睡了/拜拜/晚安」\n2. **空闲时** — 检测到用户已离线（>30分钟无响应）\n3. **重要事件** — 下载文件、安装软件、做决策\n\n### Heartbeat 自动写入（HEARTBEAT.md）\n\nHeartbeat 中加一段自动检查逻辑，做保底写入：\n\n```markdown\n## 🧠 Redis 记忆写入（每轮心跳执行）\n\n1. 查今天是否已写过 Redis\n2. 判断是否有新对话\n3. 有更新就写入\n4. 超过4小时无互动则跳过\n```\n\n这样即使会话意外中断，下一次 Heartbeat 也会把记忆存好。\n\n## 多用户隔离方案\n\n| 场景 | 方案 |\n|------|------|\n| 单用户 | 直接用 `redis_memory.sh` |\n| 多用户但互信 | 共用 `redis_memory.sh`，按用户名读写 |\n| **多用户需完全隔离** | 每人一个隔离版脚本 + SOUL.md 铁律 |\n\n隔离版脚本（`redis_memory_isolated.sh`）要求通过 `REDIS_MEMORY_USER` 环境变量指定用户，从技术层面杜绝硬编码错误。配合 SOUL.md 的铁律禁止跨账号读取，形成**技术 + 行为**双重保障。\n\n### SOUL.md 隔离铁律范本\n\n```markdown\n## 🔴 Redis 隔离铁律（跨账号记忆保护）\n\n| 用户 | 脚本 | 数据key |\n|------|------|---------|\n| 用户A | `scripts/redis_memory_a.sh` | `memory:用户A` |\n| 用户B | `scripts/redis_memory_b.sh` | `memory:用户B` |\n\n### 对话中的选择规则\n- **用户A的 session** → 只用 `redis_memory_a.sh`\n- **用户B的 session** → 只用 `redis_memory_b.sh`\n\n### ❌ 绝对禁止\n- 在用户A的对话里读取用户B的Redis记忆\n- 用A的脚本查B的数据\n- 主动告诉任何一方对方在Redis里存了什么\n```\n\n## 配置参数\n\n| 参数 | 默认值 | 说明 |\n|------|--------|------|\n| Redis host | localhost | 可通过环境变量 `REDIS_HOST` 配置 |\n| Redis port | 6379 | 可通过环境变量 `REDIS_PORT` 配置 |\n| TTL | 604800 (7天) | 可通过脚本内 `EXPIRE` 命令调整 |\n| 查询窗口 | 最近3天 | `get` 默认查3天；`recent N` 可调 |\n\n## 磁盘占用预估\n\n每条记忆约 500 字节 - 2 KB。4个用户每天对话，一年的数据量 < 5 MB。\n内存占用同理——7天窗口在 Redis 里不过几十 KB。\n\nFile v1.0.3:README.md\n\n# Redis Memory System — 跨 Session 短期记忆\n\n开箱即用。运行安装脚本后无需任何配置，自动读写 Redis。\n\n## 一键安装\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n安装后自动：\n- 每次 Session 启动 → 加载近期记忆\n- 每小时整点 → 写入时间戳保底\n- 对话结束 → 自动写入摘要\n\n## 手动安装\n\n```bash\n# 1. 安装并启动 Redis\napt install redis-server -y # 或 yum install redis\nredis-server --daemonize yes\n\n# 2. 验证\nredis-cli PING # → PONG\n\n# 3. 使用脚本\nchmod +x scripts/redis_memory.sh\nbash scripts/redis_memory.sh set 用户名 2026-05-17 \"今天聊了什么\"\nbash scripts/redis_memory.sh get 用户名\n```\n\n## ⚠️ Redis 持久化\n\n**默认不保证持久化。** 如需重启不丢数据，修改 `/etc/redis/redis.conf`：\n\n```conf\nsave 900 1\nappendonly yes\n```\n\n不改也行——7 天过期，丢了就当自然遗忘。\n\n## 安全\n\n- 默认监听 127.0.0.1，仅本机可访问\n- 数据存明文，**不要存密码或密钥**\n- 7 天 TTL 自动过期，无需手动清理\n\n## 文件\n\n```\nredis-memory-system/\n├── README.md\n├── SKILL.md\n└── scripts/\n ├── setup.sh # 一键安装\n ├── redis_memory.sh # 通用版\n └── redis_memory_isolated.sh # 隔离版\n```\n\nFile v1.0.3:_meta.json\n\n{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"1.0.3\",\n \"publishedAt\": 1778996860262\n}","readmeExcerpt":"Skill: redis-memory-system Owner: hualang-c Summary: 跨会话自动记忆系统 v3.3.0 — 单脚本+配置驱动+语义标签索引。支持标签检索、倒排索引、语义搜索。 Tags: latest:3.3.0 Version history: v3.3.0 | 2026-05-27T01:09:06.544Z | user - **Version bump:** Unified version numbering to v3.3.0 across all files - **Fix:** sync now uses transcript file mtime for date key, preventing date misassignment on conversations spanning midnight - **Cleanup:** Removed deprecated open","codeSnippets":[],"executableExamples":[{"language":"text","snippet":"┌──────────────────────────────────────────────────────┐\n│ OpenClaw Cron (每1h, isolated session) │\n│ │\n│ ① 分布式锁 (SET NX EX 600) 防并发 │\n│ ② ls -t 找最新 transcript 文件（排除cron自引用） │\n│ ③ extract_dialog.py 提取末尾200行对话 │\n│ ④ LLM 语义去重 + 摘要生成 │\n│ ⑤ Lua EVAL 原子写入（HSET+EXPIRE+last_seen） │\n│ ⑥ 锁释放 │\n└───────────────────────┬──────────────────────────────┘\n │\n┌───────────────────────┴──────────────────────────────┐\n│ 系统 Cron (每1h) — 监控哨兵 │\n│ │\n│ ① 心跳写入隔离 key: cron:health │\n│ ② 逐用户检查 memory:<用户> 今天有无摘要 │\n│ ③ 异常时写告警 flag 到 /tmp/ │\n└───────────────────────┬──────────────────────────────┘\n │\n┌───────────────────────┴──────────────────────────────┐\n│ Agent Session 启动时 │\n│ │\n│ redis_memory.sh get <用户> → 查最近3天 │\n│ cat /tmp/*.flag → 检查告警 │\n└──────────────────────────────────────────────────────┘"},{"language":"bash","snippet":"chmod +x scripts/setup.sh\nbash scripts/setup.sh"},{"language":"bash","snippet":"# Create auto-sync cron job (runs every 1h)\n# 创建每 1 小时自动同步的 cron 任务\n\nPROMPT=$(cat scripts/openclaw_cron_prompt.txt)\nopenclaw cron add \\\n --name \"memory-auto-sync\" \\\n --every 1h \\\n --session isolated \\\n --timeout-seconds 180 \\\n --thinking minimal \\\n --tools \"exec,read\" \\\n --no-deliver \\\n --message \"$PROMPT\""},{"language":"bash","snippet":"# Read last 3 days of memory\n# 读取最近 3 天的记忆\nbash scripts/memory.sh get \n\n# Check for memory loss warnings\n# 检查是否有记忆丢失告警\ncat /tmp/memory_warning_.flag 2>/dev/null"},{"language":"bash","snippet":"# Check Redis connection · 检查 Redis 连通性\nbash scripts/memory.sh ping\n\n# View system overview · 查看系统概览\nbash scripts/memory.sh stats\n\n# Read user memory (last 3 days) · 查用户记忆（最近 3 天）\nbash scripts/memory.sh get \n\n# Read memory for a specific date · 查指定日期记忆\nbash scripts/memory.sh get 2026-05-26\n\n# Search by semantic tags · 按语义标签搜索\nbash scripts/memory.sh search \n\n# Manually write a summary · 手动写入摘要\nbash scripts/memory.sh set 2026-05-26 \"Summary text here\"\n\n## v3.2.3 相比 v3.2 的改动（2026-05-26）\n\n#### 语义标签索引（v3.2.3 新增）\n- **LLM 语义标签：** cron 同步时自动提取 5 个概念级标签，替代向量检索\n- **倒排索引：** `tagidx:<标签>` → 日期集合，Redis SINTER O(1) 查询\n- **标签搜索：** `memory.sh search <关键词>` 配合 Agent 语义匹配\n- **零额外内存：** 不用 embedding 模型和向量数据库，每日标签仅占 ~200 字节\n\n### 核心架构改动\n- **合并exec调用：** 文件查找+对话提取+Redis查重合并为一个脚本，变量不会跨exec丢失（原v3.1三步分离，变量会在独立shell中丢失）\n- **Redis原子写入：** 用 Lua 脚本（`EVAL`）替代三次独立 `redis-cli` 调用，保证 HSET + EXPIRE + SET last_seen 在同一事务中完成\n- **分布式锁：** `SET NX EX 600` 防并发，cron 卡住时最长600秒自动释放（`trap cleanup EXIT` 保底）\n- **重试机制：** 文件读取失败时最多重试 2 次，间隔 1 秒\n\n### 修复的 bug\n- **找文件：** 从按匹配数取最多改为按 `ls -t` 修改时间取最新，避免旧文件碾压新 session\n- **shell语法：** `grep -c` 后加 `|| echo 0` 兜底，消除 `[: 0: integer expression expected`\n- **阈值：** 从 5 降到 2，短对话也能被收录\n\n### 脚本改进\n- **参数校验完善：** 所有脚本增加参数个数和内容校验，防止因参数不足产生幽灵记录\n- **用户名校验：** `redis_memory_user.sh` 启动时检测 USERNAME 是否仍为占位符，防止写入 `memory:your_username`\n- **用户列表外部化：** `cron_heartbeat_ping.sh` 支持环境变量 `REDIS_MEMORY_USERS`、配置文件 `/etc/redis-memory-users.conf` 或硬编码数组三种方式\n- **redis_memory.sh 新增：** `ping` 命令（检查Redis连通性）、`stats` 命令（统计各用户记忆天数/字符数）\n- **天数限制：** `recent` 命令上限 30 天，防止误传大数字导致遍历全部历史\n\n## 版本历史\n\n- v1.0 (2026-05-16) — 基础 Redis 记忆存储\n- v1.1 (2026-05-17) — 多用户隔离 + SOUL 铁律\n- v2.0 (2026-05-20) — draft 机制 + 三层保底 + 启动恢复\n- v2.1 (2026-05-21) — cron 脚本增强 + 用户专用脚本\n- v3.0 (2026-05-23) — 系统自动读会话写摘要，Agent 零负担\n- **v3.1 (2026-05-23) — 修复 dmScope 隔离问题，改用文件路径；增加去重/过滤逻辑**\n- **v3.1.1 (2026-05-25) — 架构大修：合并exec、Lua原子写入、分布式锁、重试机制**\n- **v3.2 (2026-05-25) — 单脚本+配置驱动+JSON输出**\n- **v3.2.3 (2026-05-26) — "},{"language":"text","snippet":"## 用法 / Usage"}],"parameters":null,"dependencies":[],"permissions":[],"extractedFiles":[{"path":"SKILL.md","content":"---\nname: redis-memory-system\ndescription: \"跨会话自动记忆系统 v3.3.0 — 单脚本+配置驱动+语义标签索引。支持标签检索、倒排索引、语义搜索。\"\n---\n\n# Redis 记忆系统 v3.3.0\n\n**核心思路：Agent 零负担，系统自动完成。cron 子 session 绕过 dmScope 限制，通过文件系统直读 transcript。**\n\n## 架构\n\n```\n┌──────────────────────────────────────────────────────┐\n│ OpenClaw Cron (每1h, isolated session) │\n│ │\n│ ① 分布式锁 (SET NX EX 600) 防并发 │\n│ ② ls -t 找最新 transcript 文件（排除cron自引用） │\n│ ③ extract_dialog.py 提取末尾200行对话 │\n│ ④ LLM 语义去重 + 摘要生成 │\n│ ⑤ Lua EVAL 原子写入（HSET+EXPIRE+last_seen） │\n│ ⑥ 锁释放 │\n└───────────────────────┬──────────────────────────────┘\n │\n┌───────────────────────┴──────────────────────────────┐\n│ 系统 Cron (每1h) — 监控哨兵 │\n│ │\n│ ① 心跳写入隔离 key: cron:health │\n│ ② 逐用户检查 memory:<用户> 今天有无摘要 │\n│ ③ 异常时写告警 flag 到 /tmp/ │\n└───────────────────────┬──────────────────────────────┘\n │\n┌───────────────────────┴──────────────────────────────┐\n│ Agent Session 启动时 │\n│ │\n│ redis_memory.sh get <用户> → 查最近3天 │\n│ cat /tmp/*.flag → 检查告警 │\n└──────────────────────────────────────────────────────┘\n```\n\n## 关键解决的问题\n\n| 问题 | 方案 |\n|------|------|\n| dmScope 隔离导致 cron 子 session 看不到主会话 | 文件系统直读 transcript JSONL |\n| exec 间变量丢失（各自独立 shell） | 合并为单个 exec 脚本，变量只在进程内传递 |\n| 重复追加相同摘要 | LLM 语义去重—新旧摘要表达相同信息时跳过 |\n| cron 污染 memory hash | cron 心跳写到隔离 key `cron:health` |\n| 并发执行风险 | Redis SET NX EX 分布式锁，防止两个 cron 同时写 |\n| 非原子写入（HSET+EXPIRE 分开执行） | Lua 脚本（EVAL）保证一个事务内完成全部操作 |\n| 文件查找顺序错误 | `ls -t` 按修改时间取最新，而非按匹配数 |\n\n## 文件说明\n\n| 文件 | 用途 |\n|------|------|\n| `scripts/memory.sh` | 核心脚本：sync / get / set / tag / search / heartbeat / ping / stats |\n| `scripts/extract_dialog.py` | transcript 对话提取工具 |\n| `scripts/setup.sh` | 一键安装（Redis + 脚本 + 系统cron） |\n\n\n## 🔑 Redis Key 设计\n\n| Key | 类型 | TTL | 说明 |\n|-----|------|-----|------|\n| `memory:<用户名>` | Hash | 7天 | 每日对话摘要，field=日期，value=文本 |\n| `cron:health` | Hash | 7天 | 系统心跳（隔离，不污染记忆数据） |\n| `activity:<用户名>:last_seen` | String | 12h | 最后活跃时间标记 |\n| `cron_lock:memory_sync` | String | 10min | 分布式锁，防并发 |\n\n## 部署 / Deployment\n\n### 1. 基础安装 / Setup\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n### 2. 创建 OpenClaw cron（核心 / Core）\n\n```bash\n# Create auto-sync cron job (runs every 1h)\n# 创建每 1 小时自动同步的 cron 任务\n\nPROMPT=$(cat scripts/openclaw_cron_prompt.txt)\nopenclaw cron add \\\n --name \"memory-auto-sync\" \\\n --every 1h \\\n --session isolated \\\n --timeout-seconds 180 \\\n --thinking minimal \\\n --tools \"exec,read\" \\\n --no-deliver \\\n --message \"$PROMPT\"\n```\n\n**重要 / Important：**\n- `--tools \"exec,read\"` — restricts cron to script execution & file reading only, prevents recursiv"},{"path":"README.md","content":"# Redis Memory System v3.3.0\n\nFully automatic cross-session short-term memory system. Single script, config-driven, semantic tag index.\n\n全自动跨会话短期记忆系统。单脚本 + 配置驱动 + 语义标签索引。\n\n## 适配环境 / Requirements\n\n| 项目 / Item | 规格 / Spec |\n|-------------|-------------|\n| 实例 / Instance | 任意（Redis 占用 < 50MB） |\n| Redis | 单机模式 / Standalone |\n| Agent | OpenClaw |\n\n## 一键安装 / Quick Install\n\n```bash\nchmod +x scripts/setup.sh\nbash scripts/setup.sh\n```\n\n## 用法 / Usage\n\n```bash\n# Sync dialogue to Redis (for cron) · 同步对话到 Redis（给 cron 用）\nbash scripts/memory.sh sync\n\n# Read recent memory (last 3 days) · 查最近 3 天记忆\nbash scripts/memory.sh get \n\n# Read memory for N days · 查最近 N 天记忆\nbash scripts/memory.sh get 7\n\n# Read memory for a specific date · 查指定日期记忆\nbash scripts/memory.sh get 2026-05-26\n\n# Search by semantic tags · 按语义标签搜索\nbash scripts/memory.sh search \n\n# Manually write summary · 手动写入摘要\nbash scripts/memory.sh set 2026-05-26 \"Summary text\"\n\n# System overview · 系统状态\nbash scripts/memory.sh stats\n\n# Redis connection check · 检查 Redis 连通性\nbash scripts/memory.sh ping\n```\n\n## 语义标签索引 / Semantic Tags (v3.3.0)\n\n- LLM 自动为每日摘要提取 5 个概念级标签 / LLM auto-extracts 5 concept-level tags per day\n- 倒排索引 `tagidx:` → 日期集合 / Inverted index for cross-date lookup\n- Redis SINTER 支持 O(1) 多标签交集查询 / O(1) multi-tag intersection queries\n- 零额外内存，不用 embedding 模型 / Zero extra memory, no embedding model needed"},{"path":"_meta.json","content":"{\n \"ownerId\": \"kn70d6376ap34nzbax3sh94jvn8406xq\",\n \"slug\": \"redis-memory-system\",\n \"version\": \"3.3.0\",\n \"publishedAt\": 1779844146544\n}"},{"path":"skill-card.md","content":"## Description:\n\nFully automatic cross-session short-term memory system with a single script, configuration-driven operation, and a semantic tag index.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[hualang-c](https://clawhub.ai/user/hualang-c)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nDevelopers and OpenClaw users use this skill to install and operate a Redis-backed memory helper that syncs recent session dialogue summaries, retrieves recent memory, searches semantic tags, and checks memory-system status.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: The skill ingests cross-session transcript content into Redis, which can include sensitive user or session information.\n\nMitigation: Use an opt-in installation path, treat stored summaries and transcript excerpts as sensitive data, and avoid shared Redis databases.\n\nRisk: The setup script registers persistent cron-based background execution.\n\nMitigation: Manually review or remove cron registration before deployment, and approve scheduled execution only for intended users and environments.\n\nRisk: Redis-backed memory can be exposed if Redis access is broad or unauthenticated.\n\nMitigation: Restrict Redis access, validate configured usernames, and isolate memory data per user or deployment.\n\n## Reference(s):\n\n- [Redis Memory System README](artifact/README.md)\n- [ClawHub Skill Page](https://clawhub.ai/hualang-c/skills/redis-memory-system)\n\n## Skill Output:\n\n**Output Type(s):** [text, markdown, shell commands, configuration, guidance]\n\n**Output Format:** [Markdown with inline shell commands and JSON status output]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Produces Redis memory operations for sync, get, set, tag search, heartbeat, ping, and stats workflows.]\n\n## Skill Version(s):\n\n3.3.0 (source: server release evidence, artifact _meta.json)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment."}],"languages":[],"docsSourceLabel":"CLAWHUB","editorialOverview":null,"editorialQuality":{"score":100,"threshold":65,"status":"thin","wordCount":2304,"uniquenessScore":42,"reasons":["uniqueness-below-45"]}},"media":{"evidence":{"source":"no-media","verified":false,"confidence":"low","updatedAt":"2026-10-10T15:18:07.513Z","emptyReason":"No screenshots, media assets, or demo links are available."},"primaryImageUrl":null,"mediaAssetCount":0,"assets":[],"demoUrl":null},"ownerResources":{"evidence":{"source":"unclaimed","verified":false,"confidence":"low","updatedAt":"2026-10-10T15:18:07.513Z","emptyReason":"This page has not been claimed by the agent owner."},"hasCustomPage":false,"customPageUpdatedAt":null,"customLinks":[],"structuredLinks":{"docsUrl":null,"demoUrl":null,"supportUrl":null,"pricingUrl":null,"statusUrl":null},"customPage":null},"relatedAgents":{"evidence":{"source":"protocol-neighbors","verified":false,"confidence":"medium","updatedAt":"2026-10-10T17:35:50.700Z","emptyReason":null},"items":[{"id":"8ebccd8e-3863-4187-8355-c3f14e1f9edf","entityType":"agent","canonicalPath":"/agent/iofficeai-aionui","slug":"iofficeai-aionui","name":"AionUi","description":"Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!","url":"https://github.com/iOfficeAI/AionUi","homepage":"https://www.aionui.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-10-09T19:11:12.944Z","createdAt":"2026-02-25T03:38:16.584Z","downloads":null},{"id":"b917f68a-ebff-438e-84f8-3f4b2494c0bc","entityType":"agent","canonicalPath":"/agent/activepieces-activepieces","slug":"activepieces-activepieces","name":"activepieces","description":"AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents","url":"https://github.com/activepieces/activepieces","homepage":"https://www.activepieces.com","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-15T02:22:12.426Z","createdAt":"2026-02-25T03:38:12.412Z","downloads":null},{"id":"5cb26759-3a39-483f-94cf-276a98c13bb8","entityType":"agent","canonicalPath":"/agent/cherryhq-cherry-studio","slug":"cherryhq-cherry-studio","name":"cherry-studio","description":"AI productivity studio with smart chat, autonomous agents, and 300+ assistants. Unified access to frontier LLMs","url":"https://github.com/CherryHQ/cherry-studio","homepage":"https://cherry-ai.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-11T14:38:40.986Z","createdAt":"2026-02-25T03:38:19.379Z","downloads":null},{"id":"6f6582d0-5d76-4f0f-b81d-86520247950b","entityType":"agent","canonicalPath":"/agent/copilotkit-copilotkit","slug":"copilotkit-copilotkit","name":"CopilotKit","description":"The Frontend for Agents & Generative UI. React + Angular","url":"https://github.com/CopilotKit/CopilotKit","homepage":"https://docs.copilotkit.ai","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-03-25T09:50:57.846Z","createdAt":"2026-02-25T03:39:14.617Z","downloads":null}],"links":{"hub":"/agent","source":"/agent/source/clawhub","protocols":[{"label":"OpenClaw","href":"/agent/protocol/openclew"}]}}}