Skip to content
Back to search

claude-memory-engine

SkillWorks with Claude CodeGitHub

Claude Code 的記憶系統 | A memory system built with hooks + markdown. Zero dependencies.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/helloruru--claude-memory-engine/badge.svg)](/listings/helloruru--claude-memory-engine)

HTML

<a href="/listings/helloruru--claude-memory-engine"><img src="/api/listings/helloruru--claude-memory-engine/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 578 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <h1 align="center">Claude Memory Engine</h1>
  2. <p align="center">
  3. <strong>Not just memory — it learns.</strong><br>
  4. Learn from mistakes. Learn to improve.<br>
  5. AI can be a student too, growing through every cycle.
  6. </p>
  7. <p align="center">
  8. Built with hooks and markdown. No database. No external API.<br>
  9. Just scripts and files. Nothing hiding.
  10. </p>
  11. <p align="center">
  12. <img src="https://img.shields.io/badge/license-MIT-D4A5A5?style=flat-square" alt="MIT License">
  13. <img src="https://img.shields.io/badge/node-18%2B-B8A9C9?style=flat-square" alt="Node 18+">
  14. <img src="https://img.shields.io/badge/dependencies-zero-A8B5A0?style=flat-square" alt="Zero Dependencies">
  15. <img src="https://img.shields.io/badge/claude_code-hooks-E8B4B8?style=flat-square" alt="Claude Code Hooks">
  16. <img src="https://img.shields.io/badge/version-2.0-C4B7D7?style=flat-square" alt="v2.0">
  17. </p>
  18. <p align="center">
  19. <b>English</b> &nbsp;|&nbsp; <a href="README.zh-TW.md">繁體中文</a> &nbsp;|&nbsp; <a href="README.ja.md">日本語</a>
  20. </p>
  21. ---
  22. ## WHAT — Every new conversation, Claude starts from zero
  23. - That bug you spent 30 minutes on last session — it hits the same wall again
  24. - Your preferences, your project rules — gone the moment a new session starts
  25. - Switch from Project A to Project B — it can't tell which is which
  26. - Long conversations get fuzzy — important decisions vanish after compression
  27. - Memory files pile up — no one organizes them, they just keep growing
  28. - Your computer dies — local memory gone, no backup
  29. Memory tools can help it "remember." But remembering is not the same as learning.
  30. ---
  31. ## WHY — Because it learns
  32. Memory Engine doesn't just help Claude remember — it teaches Claude to learn like a student:
  33. - Mistakes don't repeat — it saves both the problem and the fix
  34. - Switching projects doesn't mean starting over — it knows what you're working on
  35. - It gets better over time — each cycle, it understands you a little more
  36. - You can see how it learns — everything is markdown and JS, no black box
  37. ---
  38. ## HOW — Through the Student Loop
  39. - **Student Loop** — 8-step learning cycle, like cramming for finals but it keeps getting better
  40. - **Smart Context** — auto-loads the right project's memory based on your working directory
  41. - **Auto Learn** — saves both the problem and the fix when it hits a wall, won't repeat the same mistake
  42. ### :brain: The Student Loop
  43. > Think of it like exam prep. I'm trying to make Claude Code act like a student cramming for finals — take notes after every class, organize them, review for patterns, build an error notebook, and do a big end-of-term review. Each cycle, it gets a little better.
  44. **In class (automatic, runs every session)**
  45. There is no real "end" to a Claude Code conversation — it might close, idle out, or get compressed. So Memory Engine doesn't rely on any single moment. Instead, it saves at three different points:
  46. 1. **Every 20 messages** (`mid-session-checkpoint`) — saves a checkpoint + mini analysis. The most reliable save point, because it counts messages itself
  47. 2. **Before context compression** (`pre-compact`) — fires right before context is compressed. Saves a snapshot, detects pitfalls, runs backup. This is when context is fullest, so pitfall detection is most accurate here
  48. 3. **When the conversation ends** (`session-end`) — saves a final summary + backup. Nice to have, but not guaranteed to fire (window might just close)
  49. You don't need to remember to run any command before closing — your important stuff is already saved before you close.
  50. On top of that, Claude also:
  51. - **Takes notes** — records what was done, which files changed, key decisions made
  52. - **Links them** — tags the project, connects to previous notes
  53. - **Spots patterns** — scans for pitfall signals (retrying 5+ times, errors followed by fixes, user corrections)
  54. **Final exam review (manual, run `/reflect`)**
  55. After a few days of notes, run `/reflect` and Claude will:
  56. 4. **Review** — read the past 7 days of notes and pitfall records, mark what's still useful and what's outdated
  57. 5. **Refine** — apply four decision questions: Keep it? -> Condense it? -> Already covered by a rule? -> Delete only as last resort
  58. 6. **Re-study** — re-analyze the cleaned-up data to find patterns that were buried in noise
  59. 7. **Slim down** — list items that can be removed, wait for your confirmation before deleting anything
  60. 8. **Wrap up** — produce a report: what was learned, what changed, what to watch for next cycle
  61. > This isn't a one-time thing. Each cycle makes the notes sharper, the patterns clearer, the mistakes fewer. It's a loop that keeps improving.
  62. ### :pencil2: Correction Cycle
  63. Some mistakes don't show up in error logs. You correct its output, and only then does it realize — "oh, that was wrong." These mistakes don't get remembered automatically. Unless someone builds it an error notebook.
  64. **Record** (`/analyze`, manual — run right after you correct something)
  65. - You fix its work, type `/analyze`
  66. - It compares both versions against existing rules
  67. - Known rules it missed → logged, counted
  68. - Patterns not in the rules yet → distilled into new ones
  69. - The sooner you run it, the fresher the context
  70. **Review** (automatic: before each task / manual: type `/correct` anytime)
  71. - Before starting work, it scans the error notebook automatically
  72. - Not re-learning — just a reminder: "I got this wrong last time, don't repeat it"
  73. - Want to review on your own? Type `/correct` — no need to wait for a task or a cycle
  74. **Clean up** (`/reflect` step 6, manual)
  75. - Periodically scan the full notebook
  76. - Same mistake 3+ times → upgrade to a hard rule
  77. - Already internalized → mark cleared, free up space
  78. But you know that from here on, your AI has grown a little more.
  79. <details>
  80. <summary><strong>FAQ</strong></summary>
  81. **Can I just type `/correct` directly?**
  82. Yes. `/correct` works anytime — no need to wait for a task or a cycle. It simply opens the error notebook and shows you what's active.
  83. **How often should I run `/reflect`?**
  84. There's no fixed schedule. A good rhythm is once a week, or whenever the notebook feels cluttered. Step 6 of `/reflect` handles cleanup — upgrading repeat offenders to hard rules and clearing ones you've already internalized.
  85. **Do I have to run `/analyze` first before `/correct` works?**
  86. No. `/analyze` records new mistakes; `/correct` reviews existing ones. They're independent. Even if you never run `/analyze`, `/correct` still shows whatever is already in the notebook.
  87. </details>
  88. ### :detective: Smart Context + Auto Learn
  89. **Smart Context** (automatic, no config needed)
  90. - Whatever folder you're working in, it loads that project's memory
  91. - Switch projects and it switches automatically
  92. **Auto Learn** (automatic, on session end)
  93. - Hit a wall and figured it out? It saves both the problem and the fix
  94. - Reminds itself next time a new conversation starts
  95. - Same kind of mistake 3+ times across different days → suggests writing it into permanent rules
  96. ### :link: Day-to-day tools
  97. Memory and learning are the core, but day-to-day work needs more:
  98. | Feature | Description |
  99. | :--- | :--- |
  100. | Health | `/check` daily scan + `/full-check` weekly audit to keep the memory system healthy |
  101. | Tasks | `/todo` tracks pending items across all projects |
  102. | Backup | `/backup` `/sync` connect to GitHub — bidirectional sync, safe even if your machine dies |
  103. | Cross-device | Set up a GitHub memory repo, and your memory works across machines. New device? Run `/recover` and it's all there |
  104. | Recovery | `/recover` restores lost memory from GitHub backup |
  105. | Search | `/memory-search` keyword search across all memory files |
  106. | Bilingual | Every command has an English + Traditional Chinese version (36 files) |
  107. <details>
  108. <summary><strong>Full command list</strong></summary>
  109. > **Not sure what commands are available?** Type `/overview` (`/全覽`) to see them all.
  110. **Daily Operations**
  111. | EN | ZH | Function |
  112. | :--- | :- | :--- |
  113. | `/save` | `/存記憶` | Save memory across sessions — auto-dedup and route to the right file |
  114. | `/reload` | `/讀取` | Load memory into the current conversation |
  115. | `/todo` | `/待辦` | Cross-project task tracking |
  116. | `/backup` | `/備份` | Push local memory to GitHub |
  117. | `/sync` | `/同步` | Bidirectional sync — push local, pull remote |
  118. **Reflection & Learning**
  119. | EN | ZH | Function |
  120. | :--- | :- | :--- |
  121. | `/diary` | `/回顧` | Generate a reflection diary |
  122. | `/reflect` | `/反思` | Analyze pitfall records and find recurring patterns |
  123. | `/learn` | `/學習` | Manually save a pitfall experience |
  124. **Health Checks**
  125. | EN | ZH | Function |
  126. | :--- | :- | :--- |
  127. | `/check` | `/健檢` | Quick scan — capacity, broken links, orphan files |
  128. | `/full-check` | `/大健檢` | Full audit — commands, git repos, environment config |
  129. | `/memory-health` | `/記憶健檢` | Memory file line counts, update dates, capacity warnings |
  130. **Search & Maintenance**
  131. | EN | ZH | Function |
  132. | :--- | :- | :--- |
  133. | `/memory-search` | `/搜尋記憶` | Keyword search across all memory files |
  134. | `/recover` | `/想起來` | Restore memory from GitHub backup |
  135. | `/compact-guide` | `/壓縮建議` | Guide for when to compress and when not to |
  136. | `/overview` | `/全覽` | List all available commands |
  137. **Collaboration**
  138. You have three Claude Code windows open. One's fixing a bug, one's writing docs, one's cleaning up code. You switch over — and that window has zero clue what you were just doing.
  139. `/save` is for things you want to remember long-term. `/backup` pushes everything to GitHub. `/handoff` is for right now — what you were working on, what's done, what's not.
  140. | EN | ZH | Function |
  141. | :--- | :- | :--- |
  142. | `/handoff` | `/交接` | Generate a handoff file so another session can pick up where you left off |
  143. **How it works:** Run `/handoff` in window A. It saves a handoff file with your progress, decisions, and unfinished tasks. Window B picks it up automatically — no command needed on the receiving end. If B is already mid-conversation, it detects the new handoff in real time. If B starts a new conversation, it loads the handoff on startup. Either way, B sees it once and moves on.
  144. **Engine maintenance (new in v2.0)**
  145. | EN | ZH | Function |
  146. | :--- | :- | :--- |
  147. | `/bb-pause` | `/暫停同步` | Pause SessionEnd auto-commit while refactoring engine internals |
  148. When you're editing `memory-backup.sh`, `hooks/*.js`, or `CLAUDE.md`, the SessionEnd hook might auto-commit a half-finished version. `/bb-pause on` creates a `.bb-pause` lock file that makes the script exit early. Run `/bb-pause off` when you're done.
  149. </details>
  150. <details>
  151. <summary><strong>8 Hooks (all automatic)</strong></summary>
  152. | Hook | Trigger | What it does |
  153. | :--- | :------ | :----------- |
  154. | `session-start` | New conversation | Load last summary + project memory + pending handoffs |
  155. | `session-end` | Conversation ends | Save summary + backup (best-effort, may not fire) |
  156. | `pre-compact` | Context compression (auto or manual) | Save snapshot + pitfall detection + backup — the real safety net |
  157. | `memory-sync` | Every message sent | Detect cross-session memory changes + new handoffs |
  158. | `write-guard` | Before file writes | Sensitive file interception |
  159. | `pre-push-check` | Before git push | Safety check |
  160. | `mid-session-checkpoint` | Every 20 messages | Save checkpoint + mini analysis |
  161. </details>
  162. ---
  163. ## :arrows_counterclockwise: Cross-device Sync (rewritten in v2.0)
  164. Memory Engine supports cross-device sync through a GitHub repo. Set it up once, and your memory works on every machine.
  165. **How it works:**
  166. 1. `/backup` pushes local memory to your private GitHub repo (`memory-backup.sh push`)
  167. 2. `/sync` does bidirectional sync — pull remote updates, then push local changes (`memory-backup.sh sync`)
  168. 3. `/recover` on a new device pulls everything back and distributes to all local projects (`memory-backup.sh pull`)
  169. **What this means:** Switch laptops, reinstall your OS, set up a new workstation — run `/recover` and Claude picks up right where you left off. No re-explaining your preferences, no lost context.
  170. > The GitHub repo is private by default. Your memory never touches any external service beyond your own GitHub account.
  171. ### v2.0 — Full Environment Engine
  172. v1.6 only synced memory files, which meant your second machine forever ran an older `CLAUDE.md`, missing slash commands, and stale hooks. v2.0 rewrites the sync as a **full environment engine** — the entire `~/.claude/` working environment travels with you:
  173. | Synced Artifact | v1.6 | v2.0 |
  174. | :--- | :---: | :---: |
  175. | MEMORY.md + per-project memory | ✅ | ✅ |
  176. | CLAUDE.md (top-level rules) | ❌ | ✅ |
  177. | commands/ (slash commands) | ❌ | ✅ |
  178. | hooks/ (the engine itself) | push only | ✅ bidirectional |
  179. | settings.json (hook registry) | ❌ | ✅ (auto-backup before overwrite) |
  180. | skills/ and skills/learned/ | partial | ✅ |
  181. **Core architecture: SYNC_TABLE**
  182. A single source-of-truth table inside `memory-backup.sh`. Both push and pull read the **same table**, fixing the asymmetric bug where push synced X but pull silently skipped X. Adding a new sync target is one line:
  183. ```bash
  184. SYNC_TABLE=(
  185. "$CLAUDE_DIR/CLAUDE.md|$REPO_DIR/CLAUDE.md|file|CLAUDE.md (top-level rules)"
  186. "$CLAUDE_DIR/commands|$REPO_DIR/commands|dir-md|slash commands"
  187. # ... add a line, push/pull both pick it up
  188. )
  189. ```
  190. ### v2.0 Features
  191. | Feature | Usage | Purpose |
  192. | :--- | :--- | :--- |
  193. | **Dry-run** | `bash memory-backup.sh push --dry-run` | Preview what would change before doing it. No real copies. |
  194. | **Status** | `bash memory-backup.sh status` | Show local-vs-repo diff + git commits behind/ahead |
  195. | **Machine-id** | `echo "laptop" > ~/.claude/machine-id` | Tags commits with machine name for multi-device attribution |
  196. | **`.bb-pause` lock** | `/bb-pause on` / `off` | Pause SessionEnd auto-commit while refactoring engine itself |
  197. | **`.bak.*` filter** | automatic | settings backup files stay out of the repo |
  198. ---
  199. ## :package: Installation
  200. **Step 1** — Create a GitHub repo for memory backup (cross-device sync):
  201. > Without a backup repo, `/backup`, `/sync`, and `/recover` won't work. Memory only lives locally — if your machine dies, it's all gone. With a repo, your memory works across devices.
  202. ```bash
  203. gh repo create claude-memory --private
  204. git clone https://github.com/YOUR_USERNAME/claude-memory.git ~/.claude/claude-memory
  205. ```
  206. **Step 2** — Copy files:
  207. ```bash
  208. cp hooks/*.js ~/.claude/scripts/hooks/
  209. cp hooks/*.sh ~/.claude/scripts/hooks/
  210. cp commands/*.md ~/.claude/commands/
  211. cp -r skill/ ~/.claude/skills/learned/memory-engine/
  212. ```
  213. **Step 3** — Create directories:
  214. ```bash
  215. mkdir -p ~/.claude/sessions/diary
  216. mkdir -p ~/.claude/scripts/hooks
  217. ```
  218. **Step 4** — Add hooks config to `~/.claude/settings.json`:
  219. <details>
  220. <summary><strong>Click to expand full config</strong></summary>
  221. ```json
  222. {
  223. "hooks": {
  224. "SessionStart": [
  225. {
  226. "matcher": "*",
  227. "hooks": [
  228. {
  229. "type": "command",
  230. "command": "node ~/.claude/scripts/hooks/session-start.js"
  231. }
  232. ]
  233. }
  234. ],
  235. "SessionEnd": [
  236. {
  237. "matcher": "*",
  238. "hooks": [
  239. {
  240. "type": "command",
  241. "command": "node ~/.claude/scripts/hooks/session-end.js"
  242. }
  243. ]
  244. }
  245. ],
  246. "UserPromptSubmit": [
  247. {
  248. "matcher": "*",
  249. "hooks": [
  250. {
  251. "type": "command",
  252. "command": "node ~/.claude/scripts/hooks/memory-sync.js"
  253. },
  254. {
  255. "type": "command",
  256. "command": "node ~/.claude/scripts/hooks/mid-session-checkpoint.js"
  257. }
  258. ]
  259. }
  260. ],
  261. "PreCompact": [
  262. {
  263. "matcher": "*",
  264. "hooks": [
  265. {
  266. "type": "command",
  267. "command": "node ~/.claude/scripts/hooks/pre-compact.js"
  268. }
  269. ]
  270. }
  271. ],
  272. "PreToolUse": [
  273. {
  274. "matcher": "Bash",
  275. "hooks": [
  276. {
  277. "type": "command",
  278. "command": "node ~/.claude/scripts/hooks/pre-push-check.js"
  279. }
  280. ]
  281. },
  282. {
  283. "matcher": "Write",
  284. "hooks": [
  285. {
  286. "type": "command",
  287. "command": "node ~/.claude/scripts/hooks/write-guard.js"
  288. }
  289. ]
  290. }
  291. ]
  292. }
  293. }
  294. ```
  295. </details>
  296. **Step 5** — Restart Claude Code. Done!
  297. ---
  298. ## :rocket: Quick Start
  299. Done installing? Here's what to do next.
  300. 1. **Just start working** — open Claude Code and go. `session-start` loads your last session's context automatically
  301. 2. **Just close when done** — `session-end` saves a summary if it fires; `mid-session-checkpoint` and `pre-compact` already have your back
  302. 3. **Want to remember something?** — `/save` stores it in long-term memory
  303. 4. **Switching windows?** — `/handoff` passes your progress to the next window
  304. 5. **After a few days** — `/reflect` reviews your notes, finds patterns, cleans up
  305. That's it. Everything else runs in the background.
  306. ---
  307. ## :zap: Token Impact
  308. Memory Engine adds almost no token overhead to your daily usage.
  309. | Hook | When it runs | Token cost |
  310. | :--- | :----------- | :--------- |
  311. | `session-start` | Once per conversation | ~200–500 tokens (loads last summary + project memory) |
  312. | `memory-sync` | Every message | **0** unless another session changed memory files |
  313. | `mid-session-checkpoint` | Every message | **0** unless it's the 20th message |
  314. | `write-guard` | Before file writes | **0** unless writing a sensitive file |
  315. | `pre-push-check` | Before git push | **0** unless pushing |
  316. | `session-end` / `pre-compact` | End of conversation / compression | Output not injected into context |
  317. **SKILL.md** (136 lines) is a learned skill — Claude Code only loads it when relevant, not every conversation.
  318. **Bottom line:** ~200–500 extra tokens at the start of each conversation. Everything else is zero unless triggered.
  319. ---
  320. ## :wrench: Customization
  321. | What | Where |
  322. | :--- | :---- |
  323. | Context map | Smart Context auto-resolves per-project memory directory (no config needed). Override in `session-start.js` |
  324. | Keywords | `correctionKeywords` in `shared-utils.js` |
  325. | Sensitive files | `PROTECTED_PATTERNS` in `write-guard.js` |
  326. | Retention | `MAX_SESSIONS` in `session-end.js` (default: 30) |
  327. ---
  328. ## :bulb: Design Philosophy
  329. **Why not a database?**
  330. - Markdown — you can open it, read it, edit it, git commit it
  331. - Claude Code already reads `.md` natively — why add complexity?
  332. **Why not a Plugin?**
  333. - Plugins are black boxes
  334. - Hooks + Commands are transparent — every `.js` file is right there to inspect
  335. - Don't like something? Change it. Think it's unnecessary? Delete it
  336. - Tools should be something you control, not something that controls you
  337. ---
  338. ## :pray: Credits
  339. > **All code was written from scratch. No code was copied, forked, or adapted from any source project.**
  340. | Project | What it inspired |
  341. | :--- | :--- |
  342. | [contextstream/claude-code](https://github.com/contextstream/claude-code) | Smart Context, auto-learning from mistakes |
  343. | [memvid/claude-brain](https://github.com/memvid/claude-brain) | Memory statistics, lightweight design |
  344. | [rlancemartin/claude-diary](https://github.com/rlancemartin/claude-diary) | Reflection diary, pattern analysis |
  345. ---
  346. <details>
  347. <summary><strong>Changelog</strong></summary>
  348. **v1.6 — Cross-Device Sync**
  349. - Added `memory-backup.sh` — bidirectional sync script with `push`, `pull`, and `sync` modes
  350. - `pull` mode distributes global memory files from the backup repo into every local project directory (newer file wins, won't overwrite local changes)
  351. - `push` mode auto-detects all project directories instead of hardcoding paths
  352. - `/sync` command updated: now runs pull + push in one step
  353. - `/recover` command updated: uses `memory-backup.sh pull` for automatic distribution
  354. - New troubleshooting entry: "Memory from another device not showing up"
  355. **v1.5.2 — Save System Rewrite**
  356. - Pitfall detection moved from `session-end` to `pre-compact` (runs before compression, catches more context)
  357. - Save system documented with three save points ranked by reliability
  358. - `reflect.md`, `反思.md`, `交接.md` generalized for public use
  359. - Correction Cycle FAQ added (EN + ZH, 3 questions each)
  360. - Design Philosophy converted to bullet-point format
  361. **v1.5.1 — Quick Reference**
  362. - Added `/overview` (`/全覽`) to command tables and SKILL.md
  363. - 36 bilingual command files (18 pairs EN + ZH)
  364. **v1.5 — Session Handoff + Shared Core**
  365. - Session Handoff — switch between Claude Code windows without losing context. `/handoff` saves a handoff file, the next session picks it up automatically
  366. - Correction Cycle — `/analyze` compares your edits against rules, logs mistakes, builds an error notebook that auto-reviews before each task
  367. - `shared-utils.js` — extracted shared functions from `session-end.js` and `pre-compact.js`, eliminating ~80% duplicated code
  368. - Smart Context now resolves the correct memory directory per-project automatically — no hardcoded paths
  369. - Backup scope expanded: hooks, engine skill, and all project memories included in `/backup` and `/sync`
  370. - 36 bilingual command files (EN + ZH), up from 28
  371. **v1.4 — The Real Safety Net**
  372. - PreCompact hook — saves snapshot before context compression (auto or manual)
  373. - Cross-device sync — GitHub memory repo works across machines, `/recover` on new device pulls everything back
  374. - Fires one step before compression — always has a save point, no matter how the conversation ends
  375. **v1.3 — The Student Loop**
  376. - 8-step learning cycle (first 3 automatic, last 5 via `/reflect`)
  377. - Mid-session checkpoints (every 20 messages)
  378. - `/reflect` 4-question decision tree
  379. - SessionEnd fixes (transcript parsing, IDE noise filtering, pitfall threshold raised to 5)
  380. **v1.2 — Full Command Suite**
  381. - 14 bilingual commands (daily ops / reflection / health checks / search & recovery)
  382. - Two-tier health checks (`/check` + `/full-check`)
  383. - Cross-project tasks, backup sync, disaster recovery, compression guide
  384. **v1.1 — Smart Context Auto-detect**
  385. - No manual config needed — auto-scans project memory directories
  386. - Chinese correction detection (13 Chinese keywords)
  387. - Pitfall records include solutions, session summaries revamped, weekly auto-digest
  388. </details>
  389. <details>
  390. <summary><strong>File structure</strong></summary>
  391. ```
  392. claude-memory-engine/
  393. hooks/
  394. session-start.js # New session -> load recall + smart-context + handoff
  395. session-end.js # Session end -> save summary + backup (best-effort)
  396. pre-compact.js # Context compression -> snapshot + pitfall detection + backup
  397. shared-utils.js # Shared functions (transcript, pitfall, backup)
  398. memory-sync.js # Every message -> cross-session memory sync + handoff
  399. write-guard.js # Before file write -> sensitive file warning
  400. pre-push-check.js # Before git push -> safety check
  401. mid-session-checkpoint.js # Every 20 messages -> checkpoint
  402. memory-backup.sh # Bidirectional sync (push/pull/sync) — v1.6
  403. commands/
  404. save.md / 存記憶.md # Save memory across sessions
  405. reload.md / 讀取.md # Load memory
  406. todo.md / 待辦.md # Cross-project tasks
  407. backup.md / 備份.md # Push to GitHub
  408. sync.md / 同步.md # Bidirectional sync
  409. diary.md / 回顧.md # Reflection diary
  410. reflect.md / 反思.md # Pattern analysis
  411. learn.md / 學習.md # Pitfall learning
  412. check.md / 健檢.md # Quick health check
  413. full-check.md / 大健檢.md # Full audit
  414. memory-health.md / 記憶健檢.md
  415. memory-search.md / 搜尋記憶.md
  416. recover.md / 想起來.md
  417. compact-guide.md / 壓縮建議.md
  418. handoff.md / 交接.md # Session handoff
  419. skill/
  420. SKILL.md
  421. references/
  422. smart-context.md
  423. auto-learn.md
  424. ```
  425. </details>
  426. ---
  427. ## Requirements
  428. - Claude Code (with hooks support)
  429. - Node.js 18+
  430. - Zero dependencies
  431. ## License
  432. MIT — see [LICENSE](LICENSE) for details.
  433. ---
  434. <p align="center">
  435. Made by <a href="https://ohruru.com">HelloRuru</a>
  436. </p>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.