feat: upgrade from skill to lifecycle plugin (v2.0.0)

Replace prompt-based skill approach with OpenClaw lifecycle hooks
(before_agent_start, agent_end, before_compaction, before_reset).
State injection now happens automatically at the hook level,
making it model-agnostic and reliable across all providers.

- Add index.js with 5 lifecycle hooks
- Add openclaw.plugin.json manifest
- Rewrite post-install.sh to handle plugin installation
- Update README with plugin architecture docs

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

README.md

@@ -1,110 +1,106 @@
 # memory-continuity
 
-**Current release:** `v0.3.0-probe`
+**Current release:** `v2.0.0`
 
-OpenClaw continuity package for **short-term working continuity** — currently shipped as:
+OpenClaw **lifecycle plugin** for short-term working continuity. Preserves structured in-flight work state across `/new`, reset, gateway restarts, model fallback, and context compaction.
-- a **skill** (`SKILL.md`) for behavior contract / fallback recovery
-- a **lifecycle plugin probe** (`plugin/lifecycle-prototype.ts`) for validating the primary runtime path
-
-Its goal is to let an agent recover structured in-flight work state after `/new`, reset, gateway interruption, model fallback, or compaction.
 
 ## What problem does this solve?
 
-OpenClaw already preserves a lot:
+OpenClaw already preserves transcripts, compaction summaries, memory files, and session memory search. But those don't always answer the most operational question:
-- transcripts
-- compaction summaries
-- memory files
-- session memory search
-
-But those do not always answer the most operational question:
 
 > What were we doing right now, where did we stop, and what should happen next?
 
-That is the problem this skill solves.
+That is the problem this plugin solves.
 
 **One-line summary:**
 - long-term memory = what you know
 - memory continuity = what you are doing right now
 
-## Current architecture stance
+## How it works
 
-> **Alpha support boundary (`v0.3.0-probe`)**
+The plugin uses OpenClaw lifecycle hooks to **automatically** save and restore working state — no model cooperation needed.
->
-> Currently validated:
-> - resident subagent startup continuity
->
-> Not currently supported / not yet validated for reliable recovery:
-> - Discord main/channel/thread continuity
->
 
-This repository should now be understood as a **continuity package**, not just a standalone skill.
+| Hook | What it does |
+|---|---|
+| `before_agent_start` | Reads `memory/CURRENT_STATE.md` and injects it into the agent's system context |
+| `before_compaction` | Injects state before compaction so it survives context compression |
+| `before_reset` | Archives current state to `session_archive/` before `/new` |
+| `agent_end` | Auto-extracts working state from conversation if no explicit state exists |
+| `session_end` | Ensures `CURRENT_STATE.md` exists for future sessions |
 
-### Included forms
+Because state injection happens at the hook level (before the model sees anything), it works with **any model** — GPT-4o, MiniMax, Claude, etc.
-- **Skill** = behavior contract / fallback implementation / human-readable protocol
-- **Lifecycle plugin probe** = current runtime experiment for the primary architecture
-
-The intended primary runtime path is a **standard lifecycle plugin** that can
-improve startup, `/new`, and compaction continuity **without consuming
-OpenClaw’s exclusive `contextEngine` slot**.
-
-A ContextEngine implementation remains a **future option**, not the default
-v1 direction.
 
 ## Quick Start
 
 ### Install
 
 ```bash
-cd ~/.openclaw/workspace/main/skills/
+# Clone the plugin
 git clone https://github.com/dtzp555-max/memory-continuity.git
+
+# Run the installer
 cd memory-continuity
 bash scripts/post-install.sh
 ```
 
+The installer will:
+1. Copy the plugin to `~/.openclaw/extensions/memory-continuity/`
+2. Add the plugin entry to `~/.openclaw/openclaw.json`
+3. Restart the gateway
+
 No npm install, no API keys, no external database.
 
-> **Why `post-install.sh`?**
+### Verify
-> OpenClaw caches each session's skill list in a `skillsSnapshot`. If you
-> install this skill while the gateway is stopped (or restart the gateway
-> after cloning), existing sessions won't detect the new skill until their
-> snapshot is cleared. The post-install script handles this automatically.
-> New sessions created after install are unaffected.
-
-### Test the current skill version
-
-1. Start a multi-step task with your agent
-2. Make a few concrete decisions
-3. Check whether `memory/CURRENT_STATE.md` exists and reflects the work state
-4. Trigger `/new`
-5. Ask a recovery question like:
-   - “刚才我们说到哪了”
-   - “continue”
-   - “what were we doing”
-
-A good recovery should surface the current objective / step / next action,
-not generic small talk.
-
-### Run the doctor
 
 ```bash
-python3 scripts/continuity_doctor.py --workspace ~/.openclaw/workspace
+openclaw gateway restart 2>&1 | grep memory-continuity
+# Should show: [memory-continuity] Plugin registered successfully
 ```
 
-## How the current skill version works
+### Test
 
-The skill defines a discipline around one file:
+1. Tell your agent something memorable (e.g., "I'll tell you a secret: Ethan is super kid")
-- `memory/CURRENT_STATE.md`
+2. Send `/new` to reset the session
+3. Ask "what was the secret?" or "我们刚才聊到哪了"
+4. The agent should immediately surface the recovered state
 
-That file is the short-term workbench for active work. It is:
+## Configuration
-- overwritten, not appended
-- intentionally short
-- structured for fast recovery
 
-### The checkpoint shape
+The plugin works with zero configuration. Optional settings in `openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "memory-continuity": {
+        "enabled": true,
+        "hooks": {
+          "allowPromptInjection": true
+        },
+        "config": {
+          "maxStateLines": 50,
+          "archiveOnNew": true,
+          "autoExtract": true
+        }
+      }
+    }
+  }
+}
+```
+
+| Option | Default | Description |
+|---|---|---|
+| `maxStateLines` | `50` | Max lines for CURRENT_STATE.md |
+| `archiveOnNew` | `true` | Archive state to `session_archive/` before `/new` |
+| `autoExtract` | `true` | Auto-extract state from conversation at session end |
+
+## The checkpoint file
+
+The plugin maintains one file: `$WORKSPACE/memory/CURRENT_STATE.md`
 
 ```markdown
 # Current State
-> Last updated: 2026-03-12T14:30:00Z
+> Last updated: 2026-03-15T14:00:00Z
 
 ## Objective
 Build the user authentication module
@@ -114,7 +110,6 @@ Completed JWT token generation, starting refresh endpoint
 
 ## Key Decisions
 - Using RS256 for token signing (user approved)
-- Token expiry: 15 minutes access, 7 days refresh
 
 ## Next Action
 Implement POST /auth/refresh endpoint
@@ -126,103 +121,67 @@ None
 None
 ```
 
-## Recovery rules
+This file is:
+- **Overwritten**, not appended (it's a checkpoint, not a journal)
+- **Human-readable** plain markdown
+- **Portable** — just copy the file to backup or migrate
+- **Model-agnostic** — injected via hooks, not dependent on model behavior
 
-In recovery scenarios, the skill expects the agent to prioritize:
+## Backup & Migration
-- Objective
-- Current Step
-- Next Action
-- Blockers
-- Unsurfaced Results
 
-A generic greeting should **not** outrank recovery state when the checkpoint
+```bash
-contains active work.
+# Backup
+cp $WORKSPACE/memory/CURRENT_STATE.md /backup/
 
-## Relationship to native OpenClaw features
+# Migrate to another machine
+scp -r ~/.openclaw/extensions/memory-continuity/ newhost:~/.openclaw/extensions/
+scp $WORKSPACE/memory/CURRENT_STATE.md newhost:$WORKSPACE/memory/
+```
 
-### Native OpenClaw already handles
+No database, no vector embeddings, no API keys to transfer.
-- transcript persistence
-- compaction
-- pre-compaction `memoryFlush`
-- session memory search
-- system prompt/bootstrap assembly
 
-### memory-continuity adds
+## Architecture: Plugin vs Skill
-- a **structured working-state checkpoint**
-- explicit short-term recovery fields
-- a deterministic place to look for active work state
-- explicit handling for `Unsurfaced Results`
 
-### Important boundary
+Previous versions (v0.x) shipped as a **skill** — a markdown file that asked the model to read/write `CURRENT_STATE.md`. This was unreliable because models could ignore the instructions.
-Session memory search is useful for:
-- “what did we discuss before?”
-- “what decision was mentioned in a prior session?”
 
-Memory continuity is for:
+v2.0 is a **lifecycle plugin** that uses OpenClaw hooks. The key difference:
-- “what are we doing right now?”
+
-- “where did we stop?”
+| | Skill (v0.x) | Plugin (v2.0) |
-- “what should happen next?”
+|---|---|---|
+| State injection | Model must read the file | Hook injects automatically |
+| State saving | Model must write the file | Hook saves automatically |
+| Model dependency | Requires model cooperation | Model-agnostic |
+| Reliability | Varies by model | Consistent |
+
+The skill (`SKILL.md`) is retained as documentation and fallback protocol.
 
 ## Repository layout
 
 ```text
 memory-continuity/
-├── SKILL.md                       # Behavior contract / skill definition
+├── openclaw.plugin.json           # Plugin manifest
-├── skill.json                     # Skill metadata for OpenClaw loader
+├── index.js                       # Plugin entry point (hooks)
-├── _meta.json                     # Workspace skill registry metadata
+├── SKILL.md                       # Behavior contract / protocol docs
 ├── README.md
 ├── LICENSE
 ├── plugin/
-│   └── lifecycle-prototype.ts     # Phase 2 probe / not production yet
+│   └── lifecycle-prototype.ts     # Original prototype (reference)
 ├── references/
 │   ├── template.md
 │   ├── doctor-spec.md
 │   └── phase2-hook-validation.md
 └── scripts/
-    ├── post-install.sh            # Clears stale skill snapshots
+    ├── post-install.sh            # Automated installer
-    └── continuity_doctor.py
+    └── continuity_doctor.py       # Health check
-```
-
-At runtime, the skill works primarily with:
-
-```text
-$WORKSPACE/
-└── memory/
-    ├── CURRENT_STATE.md
-    └── session_archive/
 ```
 
 ## Design principles
 
-1. **Files are the source of truth**
+1. **Files are the source of truth** — plain markdown, no database
-2. **Structured checkpoint beats free-form recollection**
+2. **Hooks over prompts** — don't rely on model behavior
-3. **Recovery must prefer truth over confident guessing**
+3. **Zero external dependencies** — no API keys, no vector DB
-4. **This complements native OpenClaw memory; it does not replace it**
+4. **Portable and backupable** — `cp` is your backup tool
-5. **Read access is helpful, but should not be the only long-term path**
+5. **Complements native OpenClaw memory** — does not replace it
-6. **The primary plugin direction should coexist with other ecosystem plugins such as `lossless-claw`**
-
-## Current roadmap
-
-### Phase 1
-Strengthen the current skill version:
-- tighten recovery behavior
-- tighten checkpoint discipline
-- improve doctor and docs
-
-### Phase 2
-Build and validate a **standard lifecycle plugin** as the primary runtime path:
-- startup recovery behavior
-- `/new` checkpointing
-- compaction-boundary checkpointing
-- end-of-run safety writes
-- hook validation in real resident subagent sessions
-
-### Future option
-Evaluate a ContextEngine variant later only if the slot tradeoff is justified.
-
-## Release notes
-
-See `CHANGELOG.md` for the current packaged milestone history.
 
 ## License
 

index.js

@@ -0,0 +1,269 @@
+import fs from "node:fs";
+import path from "node:path";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const PLACEHOLDER_VALUES = new Set([
+  "", "none", "n/a", "na", "idle",
+  "[one sentence: what are we trying to accomplish]",
+  "[exactly what should happen next]",
+]);
+
+const STATE_TEMPLATE = `# Current State
+> Last updated: ${new Date().toISOString()}
+
+## Objective
+None
+
+## Current Step
+None
+
+## Key Decisions
+- None
+
+## Next Action
+None
+
+## Blockers
+None
+
+## Unsurfaced Results
+None
+`;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function resolveStatePath(workspaceDir) {
+  if (!workspaceDir) return null;
+  return path.join(workspaceDir, "memory", "CURRENT_STATE.md");
+}
+
+function readFile(filePath) {
+  try { return fs.readFileSync(filePath, "utf8"); } catch { return null; }
+}
+
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf8");
+}
+
+function extractSection(md, heading) {
+  const re = new RegExp(`^##\\s+${heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`, "m");
+  return (md.match(re)?.[1] ?? "").trim();
+}
+
+function isMeaningful(value) {
+  return !PLACEHOLDER_VALUES.has(value.trim().toLowerCase());
+}
+
+function buildSnapshot(md) {
+  const objective = extractSection(md, "Objective");
+  if (!isMeaningful(objective)) return null;
+
+  const fields = {
+    "Objective": objective,
+    "Current Step": extractSection(md, "Current Step") || "unknown",
+    "Key Decisions": extractSection(md, "Key Decisions") || "None",
+    "Next Action": extractSection(md, "Next Action") || "unknown",
+    "Blockers": extractSection(md, "Blockers") || "None",
+    "Unsurfaced Results": extractSection(md, "Unsurfaced Results") || "None",
+  };
+  const updated = md.match(/^> Last updated:\s*(.+)$/m)?.[1]?.trim() ?? "unknown";
+
+  return [
+    "=== CONTINUITY RECOVERY ===",
+    ...Object.entries(fields).map(([k, v]) => `${k}: ${v}`),
+    `Last Updated: ${updated}`,
+    "=== END RECOVERY ===",
+  ].join("\n");
+}
+
+function archiveState(workspaceDir, md) {
+  const now = new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const stamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}-${pad(now.getMinutes())}`;
+  const archiveDir = path.join(workspaceDir, "memory", "session_archive");
+  fs.mkdirSync(archiveDir, { recursive: true });
+  fs.writeFileSync(path.join(archiveDir, `${stamp}.md`), md, "utf8");
+}
+
+function extractStateFromMessages(messages) {
+  if (!messages || messages.length === 0) return null;
+
+  // Walk messages backwards to find the last meaningful exchange
+  const userMessages = [];
+  const assistantMessages = [];
+
+  for (const msg of messages) {
+    const role = msg?.role;
+    const content = typeof msg?.content === "string"
+      ? msg.content
+      : Array.isArray(msg?.content)
+        ? msg.content.filter(b => b?.type === "text").map(b => b.text).join("\n")
+        : null;
+    if (!content) continue;
+    if (role === "user") userMessages.push(content);
+    if (role === "assistant") assistantMessages.push(content);
+  }
+
+  if (userMessages.length === 0 && assistantMessages.length === 0) return null;
+
+  // Build a simple state from the conversation tail
+  const lastUser = userMessages[userMessages.length - 1] || "";
+  const lastAssistant = assistantMessages[assistantMessages.length - 1] || "";
+
+  // Truncate to keep it compact
+  const truncate = (s, max = 200) => s.length > max ? s.slice(0, max) + "..." : s;
+
+  return `# Current State
+> Last updated: ${new Date().toISOString()}
+
+## Objective
+${truncate(lastUser, 300)}
+
+## Current Step
+Conversation ended after ${messages.length} messages
+
+## Key Decisions
+- Auto-extracted from conversation
+
+## Next Action
+Continue from where we left off
+
+## Blockers
+None
+
+## Unsurfaced Results
+${truncate(lastAssistant, 500)}
+`;
+}
+
+// ---------------------------------------------------------------------------
+// Plugin Definition
+// ---------------------------------------------------------------------------
+
+const plugin = {
+  id: "memory-continuity",
+  name: "Memory Continuity",
+
+  register(api) {
+    const log = api.logger || console;
+    const getWorkspace = () => api.runtime?.workspaceDir;
+    const getConfig = () => api.pluginConfig || {};
+
+    // ------------------------------------------------------------------
+    // HOOK 1: before_agent_start — inject recovered state into context
+    // ------------------------------------------------------------------
+    api.on("before_agent_start", async (_event, _ctx) => {
+      const ws = getWorkspace();
+      const statePath = resolveStatePath(ws);
+      if (!statePath) return;
+
+      const md = readFile(statePath);
+      if (!md) return;
+
+      const snapshot = buildSnapshot(md);
+      if (!snapshot) return;
+
+      log.info?.("[memory-continuity] Injecting recovered state into context");
+
+      return {
+        prependSystemContext:
+          snapshot + "\n\n" +
+          "IMPORTANT: The above is recovered working state from a previous session. " +
+          "If the user appears to be resuming work, surface this state immediately " +
+          "before any generic greeting. This is a continuity requirement, not optional.",
+      };
+    }, { priority: 10 });
+
+    // ------------------------------------------------------------------
+    // HOOK 2: before_compaction — inject state so it survives compaction
+    // ------------------------------------------------------------------
+    api.on("before_compaction", async (_event, _ctx) => {
+      const ws = getWorkspace();
+      const statePath = resolveStatePath(ws);
+      if (!statePath) return;
+
+      const md = readFile(statePath);
+      if (!md) return;
+
+      const snapshot = buildSnapshot(md);
+      if (!snapshot) return;
+
+      log.info?.("[memory-continuity] Injecting state before compaction");
+
+      return {
+        prependSystemContext: snapshot,
+      };
+    }, { priority: 10 });
+
+    // ------------------------------------------------------------------
+    // HOOK 3: before_reset (/new) — archive current state
+    // ------------------------------------------------------------------
+    api.on("before_reset", async (_event, _ctx) => {
+      const ws = getWorkspace();
+      const config = getConfig();
+      if (!ws || config.archiveOnNew === false) return;
+
+      const statePath = resolveStatePath(ws);
+      if (!statePath) return;
+
+      const md = readFile(statePath);
+      if (!md) return;
+
+      if (buildSnapshot(md)) {
+        archiveState(ws, md);
+        log.info?.("[memory-continuity] Archived state before /new");
+      }
+    }, { priority: 10 });
+
+    // ------------------------------------------------------------------
+    // HOOK 4: agent_end — extract and save working state
+    // ------------------------------------------------------------------
+    api.on("agent_end", async (event, _ctx) => {
+      const ws = getWorkspace();
+      const config = getConfig();
+      if (!ws || config.autoExtract === false) return;
+
+      const statePath = resolveStatePath(ws);
+      if (!statePath) return;
+
+      // If there's already a meaningful state file, don't overwrite with
+      // auto-extracted content (agent or user wrote it explicitly)
+      const existing = readFile(statePath);
+      if (existing && buildSnapshot(existing)) {
+        log.info?.("[memory-continuity] Existing state is meaningful, skipping auto-extract");
+        return;
+      }
+
+      // Extract from conversation messages
+      const newState = extractStateFromMessages(event?.messages);
+      if (!newState) return;
+
+      writeFile(statePath, newState);
+      log.info?.("[memory-continuity] Auto-extracted state from conversation");
+    }, { priority: 90 }); // low priority, run after other hooks
+
+    // ------------------------------------------------------------------
+    // HOOK 5: session_end — ensure state file exists
+    // ------------------------------------------------------------------
+    api.on("session_end", async (_event, _ctx) => {
+      const ws = getWorkspace();
+      const statePath = resolveStatePath(ws);
+      if (!statePath) return;
+
+      if (!readFile(statePath)) {
+        writeFile(statePath, STATE_TEMPLATE);
+        log.info?.("[memory-continuity] Created initial CURRENT_STATE.md");
+      }
+    }, { priority: 90 });
+
+    log.info?.("[memory-continuity] Plugin registered successfully");
+  },
+};
+
+export default plugin;

openclaw.plugin.json

@@ -0,0 +1,32 @@
+{
+  "id": "memory-continuity",
+  "name": "Memory Continuity",
+  "description": "Preserves working state across /new, reset, compaction, and gateway restarts via a simple markdown checkpoint file.",
+  "version": "2.0.0",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "maxStateLines": {
+        "type": "number",
+        "default": 50,
+        "description": "Max lines for CURRENT_STATE.md before auto-compress warning"
+      },
+      "archiveOnNew": {
+        "type": "boolean",
+        "default": true,
+        "description": "Archive CURRENT_STATE.md to session_archive/ on /new"
+      },
+      "autoExtract": {
+        "type": "boolean",
+        "default": true,
+        "description": "Auto-extract working state from conversation at agent_end"
+      }
+    }
+  },
+  "uiHints": {
+    "maxStateLines": { "label": "Max state file lines", "help": "Keep checkpoint small for fast recovery" },
+    "archiveOnNew": { "label": "Archive on /new", "help": "Save a snapshot before session reset" },
+    "autoExtract": { "label": "Auto-extract state", "help": "Automatically save working state when conversation ends" }
+  }
+}

scripts/post-install.sh

@@ -1,71 +1,116 @@
 #!/usr/bin/env bash
-# post-install.sh — Flush stale skill snapshots after installing memory-continuity
+# post-install.sh — Install memory-continuity as an OpenClaw lifecycle plugin
 #
-# OpenClaw caches a "skillsSnapshot" per session. If this skill was installed
+# This script:
-# while the gateway was stopped (or after a gateway restart), the file watcher
+#   1. Copies the plugin to ~/.openclaw/extensions/memory-continuity/
-# won't detect the new SKILL.md and existing sessions will never refresh.
+#   2. Adds the plugin entry to openclaw.json (if not present)
-#
+#   3. Restarts the gateway
-# This script clears stale snapshots so every session rebuilds on next turn.
 #
 # Usage:
-#   bash scripts/post-install.sh [--agent-id <id>]
+#   bash scripts/post-install.sh
-#
-# Options:
-#   --agent-id <id>   Agent ID (default: main)
 #
 # Safe to run multiple times (idempotent).
 
 set -euo pipefail
 
-AGENT_ID="main"
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --agent-id) AGENT_ID="$2"; shift 2 ;;
-    *) echo "Unknown option: $1" >&2; exit 1 ;;
-  esac
-done
-
 OPENCLAW_DIR="${OPENCLAW_STATE_DIR:-$HOME/.openclaw}"
-SESSIONS_FILE="$OPENCLAW_DIR/agents/$AGENT_ID/sessions/sessions.json"
+EXTENSIONS_DIR="$OPENCLAW_DIR/extensions"
+PLUGIN_DIR="$EXTENSIONS_DIR/memory-continuity"
+CONFIG_FILE="$OPENCLAW_DIR/openclaw.json"
 
-if [[ ! -f "$SESSIONS_FILE" ]]; then
+# Resolve the repo root (parent of scripts/)
-  echo "No sessions file found at $SESSIONS_FILE — nothing to do."
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-  exit 0
+REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+echo "=== memory-continuity plugin installer ==="
+echo ""
+
+# Step 1: Copy plugin files to extensions directory
+echo "[1/3] Installing plugin to $PLUGIN_DIR ..."
+mkdir -p "$EXTENSIONS_DIR"
+
+# Remove old installation if exists
+if [[ -d "$PLUGIN_DIR" || -L "$PLUGIN_DIR" ]]; then
+  rm -rf "$PLUGIN_DIR"
+  echo "  Removed previous installation"
 fi
 
-# Count and clear stale skillsSnapshot entries
+# Copy essential plugin files (not the entire repo)
-BEFORE=$(python3 -c "
+mkdir -p "$PLUGIN_DIR"
+for f in index.js openclaw.plugin.json SKILL.md; do
+  if [[ -f "$REPO_DIR/$f" ]]; then
+    cp "$REPO_DIR/$f" "$PLUGIN_DIR/"
+  fi
+done
+echo "  Copied plugin files"
+
+# Step 2: Add plugin entry to openclaw.json
+echo "[2/3] Configuring openclaw.json ..."
+if [[ ! -f "$CONFIG_FILE" ]]; then
+  echo "  WARNING: $CONFIG_FILE not found. Skipping config update."
+  echo "  You'll need to manually add the plugin entry."
+else
+  # Check if memory-continuity entry already exists
+  if python3 -c "
 import json, sys
-with open('$SESSIONS_FILE') as f:
+with open('$CONFIG_FILE') as f:
     data = json.load(f)
-count = sum(1 for v in data.values() if isinstance(v, dict) and 'skillsSnapshot' in v)
+entries = data.get('plugins', {}).get('entries', {})
-print(count)
+if 'memory-continuity' in entries:
-" 2>/dev/null || echo "0")
+    print('exists')
-
+    sys.exit(0)
-if [[ "$BEFORE" == "0" ]]; then
+else:
-  echo "No stale skill snapshots found — all sessions will discover skills normally."
+    sys.exit(1)
-  exit 0
+" 2>/dev/null; then
-fi
+    echo "  Plugin entry already exists in config"
-
+  else
+    # Add the plugin entry
     python3 -c "
 import json
-path = '$SESSIONS_FILE'
+path = '$CONFIG_FILE'
 with open(path) as f:
     data = json.load(f)
-for key in data:
+if 'plugins' not in data:
-    if isinstance(data[key], dict) and 'skillsSnapshot' in data[key]:
+    data['plugins'] = {}
-        del data[key]['skillsSnapshot']
+if 'entries' not in data['plugins']:
+    data['plugins']['entries'] = {}
+data['plugins']['entries']['memory-continuity'] = {
+    'enabled': True,
+    'hooks': {
+        'allowPromptInjection': True
+    },
+    'config': {
+        'maxStateLines': 50,
+        'archiveOnNew': True,
+        'autoExtract': True
+    }
+}
 with open(path, 'w') as f:
     json.dump(data, f, indent=2)
-"
+print('  Added plugin entry to config')
+" 2>/dev/null || echo "  WARNING: Could not update config automatically. Add manually."
+  fi
+fi
 
-echo "Cleared skillsSnapshot from $BEFORE session(s) in $SESSIONS_FILE"
+# Step 3: Restart gateway
-echo "All sessions will rebuild their skill list on next turn."
+echo "[3/3] Restarting gateway ..."
-
-# Restart gateway if running, so file watcher picks up the new SKILL.md
 if command -v openclaw &>/dev/null; then
   if openclaw gateway status 2>&1 | grep -q "running"; then
-    echo "Restarting gateway to activate file watcher..."
+    openclaw gateway restart 2>/dev/null && echo "  Gateway restarted" || echo "  Gateway restart failed — try: openclaw gateway restart"
-    openclaw gateway restart 2>/dev/null && echo "Gateway restarted." || echo "Gateway restart failed — try manually: openclaw gateway restart"
+  else
+    echo "  Gateway not running — start it with: openclaw gateway start"
   fi
+else
+  echo "  openclaw command not found — install OpenClaw first"
 fi
+
+echo ""
+echo "=== Installation complete ==="
+echo ""
+echo "Verify with:"
+echo "  openclaw gateway restart 2>&1 | grep memory-continuity"
+echo ""
+echo "Test with:"
+echo "  1. Tell your agent something memorable"
+echo "  2. Send /new"
+echo "  3. Ask what you told it"