@byte5ai/palaia 2.3.6 → 2.5.1

package/README.md

@@ -122,7 +122,7 @@ OpenClaw Agent
 
 ```bash
 # Clone the repo
-git clone https://github.com/iret77/palaia.git
+git clone https://github.com/byte5ai/palaia.git
 cd palaia/packages/openclaw-plugin
 
 # Install deps

package/index.ts

@@ -4,16 +4,20 @@
  * Plugin entry point. Loaded by OpenClaw via jiti (no build step needed).
  *
  * Registers:
- * - memory_search: Semantic search over Palaia memory
- * - memory_get: Read a specific memory entry
- * - memory_write: Write new entries (optional, opt-in)
- * - before_prompt_build: Query-based contextual recall (opt-in, Issue #65)
- * - agent_end: Auto-capture of significant exchanges (opt-in, Issue #64)
- * - palaia-recovery: WAL replay on startup
+ * - Tools: memory_search, memory_get, memory_write
+ * - MemoryPromptSection: Guided tool usage hints
+ * - Session hooks (always): session_start, session_end, before_reset,
+ *   llm_input, llm_output, after_tool_call, subagent_spawning, subagent_ended
+ * - ContextEngine (modern) OR legacy hooks (before_prompt_build, agent_end,
+ *   message_received, message_sending)
  *
- * Phase 1.5: ContextEngine adapter support. When the host provides
- * api.registerContextEngine, palaia registers as a ContextEngine.
- * Otherwise, falls back to legacy hook-based integration.
+ * v3.0 Features:
+ * - Session continuity: Auto-briefing on session start / LLM switch
+ * - Session summaries: Auto-saved on session end / reset
+ * - Tool observations: Tracked via after_tool_call
+ * - Progressive disclosure: Compact mode for large memory stores
+ * - Privacy markers: <private> blocks excluded from capture
+ * - Recency boost: Fresh memories ranked higher
  *
  * Activation:
  *   plugins: { slots: { memory: "palaia" } }
@@ -22,6 +26,7 @@
 import { resolveConfig, type PalaiaPluginConfig } from "./src/config.js";
 import { registerTools } from "./src/tools.js";
 import { registerHooks } from "./src/hooks/index.js";
+import { registerSessionHooks } from "./src/hooks/session.js";
 import { createPalaiaContextEngine } from "./src/context-engine.js";
 import type { OpenClawPluginApi, OpenClawPluginEntry } from "./src/types.js";
 
@@ -29,14 +34,12 @@ import type { OpenClawPluginApi, OpenClawPluginEntry } from "./src/types.js";
 const palaiaPlugin: OpenClawPluginEntry = {
   id: "palaia",
   name: "Palaia Memory",
-  async register(api: OpenClawPluginApi) {
-    // Issue #66: Plugin config is currently resolved GLOBALLY via api.getConfig("palaia").
+  register(api: OpenClawPluginApi) {
+    // Issue #66: Plugin config is resolved GLOBALLY via api.pluginConfig.
     // OpenClaw does NOT provide per-agent config resolution — all agents share the same
-    // plugin config from openclaw.json → plugins.config.palaia.
-    // A per-agent resolver would require an OpenClaw upstream change where api.getConfig()
-    // accepts an agentId parameter or automatically scopes to the current agent context.
-    // See: https://github.com/iret77/palaia/issues/66
-    const rawConfig = api.getConfig?.("palaia") as
+    // plugin config from openclaw.json → plugins.entries.palaia.config.
+    // See: https://github.com/byte5ai/palaia/issues/66
+    const rawConfig = api.pluginConfig as
       | Partial<PalaiaPluginConfig>
       | undefined;
     const config = resolveConfig(rawConfig);
@@ -51,9 +54,31 @@ const palaiaPlugin: OpenClawPluginEntry = {
     // Register agent tools (memory_search, memory_get, memory_write)
     registerTools(api, config);
 
+    // Register MemoryPromptSection for guided memory tool usage (v3.0)
+    if (api.registerMemoryPromptSection) {
+      api.registerMemoryPromptSection(({ availableTools }) => {
+        const lines: string[] = [];
+        if (availableTools.has("memory_search")) {
+          lines.push("Use `memory_search` to find relevant memories by semantic query.");
+        }
+        if (availableTools.has("memory_get")) {
+          lines.push("Use `memory_get <id>` to retrieve full memory details by ID.");
+        }
+        if (availableTools.has("memory_write")) {
+          lines.push("Use `memory_write` for processes/SOPs and tasks only — conversation knowledge is auto-captured.");
+        }
+        return lines;
+      });
+    }
+
+    // Session lifecycle hooks are always registered (session_start, session_end,
+    // before_reset, llm_input, llm_output, after_tool_call).
+    // These work independently of the ContextEngine vs legacy hooks choice.
+    registerSessionHooks(api, config);
+
     // Register ContextEngine when available, otherwise use legacy hooks
     if (api.registerContextEngine) {
-      api.registerContextEngine("palaia", createPalaiaContextEngine(api, config));
+      api.registerContextEngine("palaia", () => createPalaiaContextEngine(api, config));
     } else {
       registerHooks(api, config);  // Legacy fallback
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byte5ai/palaia",
-  "version": "2.3.6",
+  "version": "2.5.1",
   "description": "Palaia memory backend for OpenClaw",
   "main": "index.ts",
   "openclaw": {
@@ -25,7 +25,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/iret77/palaia.git",
+    "url": "https://github.com/byte5ai/palaia.git",
     "directory": "packages/openclaw-plugin"
   },
   "peerDependencies": {

package/skill/SKILL.md

@@ -1,14 +1,143 @@
 ---
 name: palaia
-version: "2.2.0"
+version: "2.5.1"
 description: >
   Local, crash-safe persistent memory for OpenClaw agents.
   SQLite-backed by default. Semantic search, projects, scopes, auto-capture.
+  After installing or updating, run: palaia doctor --fix to complete setup.
+metadata:
+  openclaw:
+    emoji: "\U0001F9E0"
+    requires:
+      bins: ["palaia"]
+    install:
+      - id: pip
+        kind: pip
+        package: "palaia[fastembed]"
+        bins: ["palaia"]
+        label: "Install Palaia with semantic search (pip)"
+    postInstall:
+      - command: "palaia init"
+        label: "Initialize Palaia store"
+      - command: "npm install -g @byte5ai/palaia@latest"
+        label: "Install OpenClaw plugin (npm)"
+    postUpdate:
+      - command: "python3 -m pip install --upgrade 'palaia[fastembed]' && (npm install -g @byte5ai/palaia@latest 2>/dev/null || true) && palaia doctor --fix && palaia warmup"
+        label: "Upgrade Palaia with semantic search (pip + npm plugin) and run health checks"
+    postUpdateMessage: >
+      Palaia has been updated to v2.5. New: agent isolation mode (--isolated), modern CLI
+      design, backup-restore auto-fix. Run `palaia doctor --fix` to upgrade.
+    plugin:
+      slot: memory
+      package: "@byte5ai/palaia"
 ---
 
-# Palaia v2.2 — Agent Memory (Plugin)
+# Palaia v2.4 — Agent Memory Skill
 
-Palaia is your memory system. It gives you persistent, searchable, crash-safe memory across sessions. Palaia is already installed and configured via the OpenClaw plugin — just use the commands below.
+Palaia is the memory system for OpenClaw agents. It gives you persistent, searchable, crash-safe memory across sessions. You don't need to understand how it works — just use the commands below.
+
+<!-- begin:install -->
+## First-Time Setup
+
+When a user asks you to "set up palaia", "enable memory", or "remember things across sessions", run these steps:
+
+```bash
+pip install "palaia[fastembed]"
+```
+
+```bash
+palaia init
+```
+
+This creates `.palaia/` with SQLite storage and automatically configures fastembed for semantic search. No manual configuration needed.
+
+Confirm success to the user: "Memory is ready. I'll automatically remember important context from our conversations."
+
+If `pip` is not available, try alternatives in this order:
+```bash
+python3 -m pip install "palaia[fastembed]"
+uv tool install "palaia[fastembed]"
+pipx install "palaia[fastembed]"
+```
+
+Optional extras (install as needed):
+```bash
+pip install "palaia[mcp]"          # MCP server for Claude Desktop, Cursor
+pip install "palaia[curate]"       # Knowledge curation
+```
+
+Note: `palaia[fastembed]` already includes sqlite-vec for native SIMD vector search. No separate install needed.
+
+### OpenClaw Plugin Setup (for Auto-Capture and Auto-Recall)
+
+After the CLI is installed, wire it into OpenClaw:
+
+```bash
+npm install -g @byte5ai/palaia@latest
+```
+
+Then activate in OpenClaw config (read existing values first, never overwrite arrays):
+```bash
+PALAIA_PATH="$(npm root -g)/@byte5ai/palaia"
+```
+
+Add to `openclaw.json`:
+```json
+{
+  "plugins": {
+    "load": { "paths": ["<PALAIA_PATH>"] },
+    "allow": ["..existing..", "palaia"],
+    "slots": { "memory": "palaia" },
+    "entries": { "palaia": { "enabled": true } }
+  }
+}
+```
+
+Restart the gateway and verify:
+```bash
+openclaw gateway restart
+palaia doctor
+```
+
+### Agent Identity (optional)
+
+Single-agent systems work with the default name. For multi-agent setups:
+```bash
+palaia init --agent YOUR_AGENT_NAME
+```
+
+## Updating Palaia
+
+When the user asks to update, or when `palaia status` shows a version mismatch:
+
+```bash
+palaia upgrade
+```
+This auto-detects the install method (pip/uv/pipx), preserves all installed extras (fastembed, mcp, sqlite-vec, curate), runs `palaia doctor --fix`, and upgrades the OpenClaw plugin if installed. No manual steps needed.
+
+**If `palaia upgrade` is not recognized** (versions before v2.3.0), update manually:
+
+```bash
+# Step 1: Find install method
+which palaia
+
+# Step 2: Upgrade (use the method matching the path from Step 1)
+# pip (path contains site-packages or .local):
+pip install --upgrade "palaia[fastembed]"
+# uv (path contains uv):
+uv tool install "palaia[fastembed]"
+# pipx (path contains pipx):
+pipx install "palaia[fastembed]" --force
+
+# Step 3: Health check + migration
+palaia doctor --fix
+
+# Step 4: Update OpenClaw plugin (if installed)
+npm install -g @byte5ai/palaia@latest
+```
+
+After the manual update, `palaia upgrade` will be available for future updates.
+<!-- end:install -->
 
 ## Auto-Check (run every time this skill is loaded)
 
@@ -38,6 +167,100 @@ Conversations are automatically captured when the OpenClaw plugin is active. You
 
 ---
 
+## Storage & Search
+
+### Database Backends
+
+| Backend | Use Case | Vector Search | Install |
+|---------|----------|---------------|---------|
+| **SQLite** (default) | Local, single-agent or small team | sqlite-vec (native KNN) or Python fallback | Included |
+| **PostgreSQL** | Distributed teams, multiple hosts | pgvector (ANN, IVFFlat/HNSW) | `pip install 'palaia[postgres]'` |
+
+SQLite is zero-config — `palaia init` creates a single `palaia.db` file with WAL mode for crash safety. For teams with agents on multiple machines, PostgreSQL centralizes the store:
+```bash
+palaia config set database_url postgresql://user:pass@host/db
+# or: export PALAIA_DATABASE_URL=postgresql://...
+```
+
+### Semantic Vector Search
+
+Palaia uses **hybrid search**: BM25 keyword matching (always active) combined with semantic vector embeddings (when a provider is configured). This finds memories by meaning, not just keywords.
+
+**Embedding providers** (checked in chain order, first available wins):
+
+| Provider | Type | Latency | Install |
+|----------|------|---------|---------|
+| **fastembed** | Local (CPU) | ~10ms/query | `pip install 'palaia[fastembed]'` (default) |
+| **sentence-transformers** | Local (CPU/GPU) | ~10ms/query | `pip install 'palaia[sentence-transformers]'` |
+| **Ollama** | Local (server) | ~50ms/query | `ollama pull nomic-embed-text` |
+| **OpenAI** | API | ~200ms/query | Set `OPENAI_API_KEY` |
+| **Gemini** | API | ~200ms/query | Set `GEMINI_API_KEY` |
+| **BM25** | Built-in | <1ms/query | Always available (keyword only) |
+
+Configure the chain: `palaia config set embedding_chain '["fastembed", "bm25"]'`
+
+Check what's available: `palaia detect`
+
+### Embed Server (Performance)
+
+For fast CLI queries, palaia runs a background embed-server that keeps the model loaded in memory:
+```bash
+palaia embed-server --socket --daemon   # Start background server
+palaia embed-server --status            # Check if running
+palaia embed-server --stop              # Stop server
+```
+Without the server, each CLI call loads the model fresh (~3-5s). With the embed-server: **~1.5s per CLI query** (Python startup + server call) or **<500ms via MCP/Plugin** (no CLI overhead).
+
+The OpenClaw plugin starts the embed-server automatically. For CLI-only usage, it auto-starts on first query when a local provider (fastembed, sentence-transformers) is configured.
+
+### MCP Server (Claude Desktop, Cursor, any MCP host)
+
+Palaia works as a standalone MCP memory server — **no OpenClaw required**. Any AI tool that supports MCP can use palaia as persistent local memory.
+
+```bash
+pip install 'palaia[mcp]'
+palaia-mcp                              # Start MCP server (stdio)
+palaia-mcp --root /path/to/.palaia      # Explicit store
+palaia-mcp --read-only                  # No writes (untrusted hosts)
+```
+
+**Claude Desktop** (`~/.config/claude/claude_desktop_config.json`):
+```json
+{
+  "mcpServers": {
+    "palaia": {
+      "command": "palaia-mcp",
+      "args": []
+    }
+  }
+}
+```
+
+**Cursor** (Settings → MCP Servers → Add, or `.cursor/mcp.json`):
+- Command: `palaia-mcp`
+- Arguments: (none, or `--root /path/to/.palaia`)
+
+**Claude Code** (`~/.claude/settings.json`):
+```json
+{"mcpServers": {"palaia": {"command": "palaia-mcp"}}}
+```
+
+**MCP Tools:**
+
+| Tool | Purpose |
+|------|---------|
+| `palaia_search` | Semantic + keyword search across all memories |
+| `palaia_store` | Save new memory (fact, process, task) |
+| `palaia_read` | Read a specific entry by ID |
+| `palaia_edit` | Update an existing entry |
+| `palaia_list` | List entries by tier, type, or project |
+| `palaia_status` | Show store health, entry counts, provider info |
+| `palaia_gc` | Run garbage collection (tier rotation) |
+
+**Read-only mode** (`--read-only`): Disables `palaia_store`, `palaia_edit`, `palaia_gc`. Use this when connecting untrusted AI tools that should only read memories, not modify them.
+
+---
+
 ## Commands Reference
 
 ### `palaia write` — Save structured knowledge
@@ -69,6 +292,9 @@ palaia query "what's the rate limit"
 # Filter by type and status
 palaia query "tasks" --type task --status open
 
+# Filter by tags
+palaia query "session-summary" --tags session-summary
+
 # Search within a project
 palaia query "deploy steps" --project myapp
 
@@ -103,6 +329,9 @@ palaia list
 # Filter by tier, type, status
 palaia list --tier warm --type task --status open --priority high
 
+# Limit results
+palaia list --type task --status open --limit 5
+
 # Filter by project or assignee
 palaia list --project myapp --assignee Elliot
 ```
@@ -136,7 +365,7 @@ palaia memo inbox              # Check for messages
 palaia memo ack <memo-id>      # Mark as read
 ```
 
-### `palaia priorities` — Injection priority management
+### `palaia priorities` — Injection priority management (NEW in v2.2)
 
 Control which memories are injected into each agent's context.
 
@@ -156,7 +385,7 @@ palaia priorities set typeWeight.process 0.5 --agent orchestrator
 
 Config stored in `.palaia/priorities.json` with layered overrides: global -> per-agent -> per-project.
 
-### `palaia curate analyze/apply` — Knowledge curation
+### `palaia curate analyze/apply` — Knowledge curation (NEW in v2.2)
 
 For migrating knowledge to a new instance, cleaning up old entries, or reviewing accumulated knowledge.
 
@@ -186,6 +415,8 @@ palaia sync import ./export/ --dry-run   # Preview first
 palaia sync import ./export/
 ```
 
+Note: The old `palaia export`/`palaia import` aliases still work but are deprecated.
+
 ### `palaia package export/import` — Portable knowledge packages
 
 ```bash
@@ -199,6 +430,14 @@ palaia package import myapp.palaia-pkg.json --project target --merge skip
 palaia package info myapp.palaia-pkg.json
 ```
 
+### `palaia upgrade` — Update to latest version
+
+```bash
+palaia upgrade
+```
+
+Auto-detects the install method (pip/uv/pipx/brew), preserves all installed extras (fastembed, mcp, sqlite-vec, curate), runs `palaia doctor --fix`, and upgrades the OpenClaw npm plugin if present. Always use this instead of manual pip commands.
+
 ### `palaia doctor` — Diagnostics and auto-fix
 
 ```bash
@@ -285,7 +524,7 @@ Palaia's CLI output contains contextual hints prefixed with `[palaia]`. These ar
 
 ---
 
-## Multi-Agent Coordination
+## Multi-Agent Setup
 
 ### Scopes across agents
 - `private` entries are only visible to the writing agent
@@ -344,6 +583,66 @@ Distinguish sessions of the same agent:
 palaia instance set Claw-Main
 ```
 
+### Agent Isolation Mode
+
+For focused agents (Sonnet/Codex) that should only see their own memories:
+
+**1. Configure in `priorities.json`:**
+```json
+{
+  "agents": {
+    "dev-worker": {
+      "scopeVisibility": ["private"],
+      "captureScope": "private",
+      "maxInjectedChars": 2000,
+      "recallMinScore": 0.85
+    }
+  }
+}
+```
+Or via CLI:
+```bash
+palaia priorities set scopeVisibility private --agent dev-worker
+palaia priorities set captureScope private --agent dev-worker
+palaia priorities set maxInjectedChars 2000 --agent dev-worker
+palaia priorities set recallMinScore 0.85 --agent dev-worker
+```
+
+**2. Set agent identity:**
+```bash
+export PALAIA_AGENT=dev-worker
+```
+
+**3. Auto-capture stays on** (crash safety net). Cleanup happens after the work package.
+
+**4. After accepting work:**
+```bash
+palaia prune --agent dev-worker --tags auto-capture --protect-type process
+```
+This removes session noise while preserving learned SOPs.
+
+#### Pre-configured Agent Profiles
+
+| Profile | scopeVisibility | captureScope | maxInjectedChars | recallMinScore | autoCapture |
+|---------|----------------|--------------|-----------------|----------------|-------------|
+| **Isolated Worker** | `["private"]` | `private` | 2000 | 0.85 | true |
+| **Orchestrator** | `["private","team","public"]` | `team` | 4000 | 0.7 | true |
+| **Lean Worker** | `["private"]` | `private` | 1000 | 0.9 | false |
+
+#### Orchestrator Lifecycle (process template)
+
+Save this as a process entry for the orchestrator to recall:
+```bash
+palaia write "## Dev-Agent Lifecycle
+1. Create agent identity: export PALAIA_AGENT=dev-worker-{task-id}
+2. Configure isolation: palaia priorities set scopeVisibility private --agent dev-worker-{task-id}
+3. Configure capture: palaia priorities set captureScope private --agent dev-worker-{task-id}
+4. Assign work package via prompt
+5. After acceptance: palaia prune --agent dev-worker-{task-id} --tags auto-capture --protect-type process
+6. Verify: palaia list --agent dev-worker-{task-id} --type process
+7. Process knowledge persists for future tasks" --type process --tags workflow,orchestration --scope private
+```
+
 ---
 
 ## When to Use What
@@ -359,10 +658,11 @@ palaia instance set Claw-Main
 | Check system health | `palaia status` |
 | Something is wrong | `palaia doctor --fix` |
 | Clean up old entries | `palaia gc` |
+| Clean up agent session noise | `palaia prune --agent NAME --tags auto-capture --protect-type process` |
 | Review accumulated knowledge | `palaia curate analyze` |
 | Share knowledge | `palaia sync export` or `palaia package export` |
 | Check for messages | `palaia memo inbox` |
-| Start of session | `palaia doctor` then `palaia query "active work"` then `palaia memo inbox` |
+| Start of session | Session briefing is now automatic. Just run `palaia doctor` and check `palaia memo inbox`. |
 
 **Do NOT manually write:** facts, decisions, or preferences that came up in the current conversation. Auto-Capture handles these.
 
@@ -401,6 +701,33 @@ palaia init --capture-level <off|minimal|normal|aggressive>
 
 ---
 
+## Session Continuity (NEW in v2.4)
+
+Session continuity gives agents automatic context restoration across sessions. These features work out of the box with the OpenClaw plugin -- no manual setup needed.
+
+### Session Briefings
+On session start, Palaia automatically injects a briefing with the last session summary and any open tasks. This means agents resume work without needing to manually search for context.
+
+### Session Summaries
+When a session ends or resets, Palaia auto-saves a summary of what happened. These are stored as entries with the `session-summary` tag and can be queried:
+```bash
+palaia query "session-summary" --tags session-summary
+```
+
+### Privacy Markers
+Wrap sensitive content in `<private>...</private>` blocks to exclude it from auto-capture. Private blocks are stripped before any extraction runs.
+
+### Recency Boost
+Fresh memories are ranked higher in recall results. The boost factor is configurable via `recallRecencyBoost` (default `0.3`, set to `0` to disable).
+
+### Progressive Disclosure
+When result sets exceed 100 entries, Palaia uses compact mode to keep context manageable. Use `--limit` to control result size explicitly:
+```bash
+palaia list --type task --status open --limit 5
+```
+
+---
+
 ## Plugin Configuration (OpenClaw)
 
 Set in `openclaw.json` under `plugins.entries.palaia.config`:
@@ -418,6 +745,11 @@ Set in `openclaw.json` under `plugins.entries.palaia.config`:
 | `embeddingServer` | `true` | Keep embedding model loaded for fast queries |
 | `showMemorySources` | `true` | Show memory source footnotes |
 | `showCaptureConfirm` | `true` | Show capture confirmations |
+| `sessionSummary` | `true` | Auto-save session summaries on end/reset |
+| `sessionBriefing` | `true` | Load session context on session start |
+| `sessionBriefingMaxChars` | `1500` | Max chars for session briefing injection |
+| `captureToolObservations` | `true` | Track tool usage as session context |
+| `recallRecencyBoost` | `0.3` | Boost factor for fresh memories (0=off) |
 
 ---
 
@@ -437,15 +769,33 @@ Set in `openclaw.json` under `plugins.entries.palaia.config`:
 | Problem | What to do |
 |---------|-----------|
 | Something is wrong | `palaia doctor --fix` first, debug second |
+| `palaia init` fails | Check permissions on the directory, disk space, and Python version. Report the exact error to the user. |
 | `palaia write` fails | Run `palaia doctor --fix`, then retry. If WAL replay needed, run `palaia recover`. |
 | `palaia query` returns nothing | Try `palaia query "..." --all` to include COLD tier. Check `palaia list` to verify entries exist. |
 | Entries seem missing | `palaia recover` then `palaia list --tier cold` |
-| Slow queries | `palaia warmup` then check `palaia detect` |
+| Slow queries | `pip install 'palaia[sqlite-vec]'` for native vector search, then `palaia warmup`. Check `palaia detect` and `palaia status` |
 | Provider not available | Chain auto-falls back. Check `palaia status` |
+| `.palaia` missing | `palaia init` |
 | Embedding provider unavailable | BM25 works without embeddings. Check `palaia detect` for available providers. |
 
 If `palaia doctor --fix` cannot resolve an issue, report the full error output to the user. Do not guess at fixes.
 
 ---
 
+## Configuration Keys
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `default_scope` | `team` | Default visibility for new entries |
+| `embedding_chain` | *(auto)* | Ordered list of search providers |
+| `database_backend` | `sqlite` | Storage backend (`sqlite` or `postgres`) |
+| `hot_threshold_days` | `7` | Days before HOT -> WARM |
+| `warm_threshold_days` | `30` | Days before WARM -> COLD |
+| `hot_max_entries` | `50` | Max entries in HOT tier |
+| `decay_lambda` | `0.1` | Decay rate for memory scores |
+| `embed_server_auto_start` | `true` | Auto-start embed-server daemon on first CLI query |
+| `embed_server_idle_timeout` | `1800` | Daemon auto-shutdown after N seconds idle |
+
+---
+
 (c) 2026 byte5 GmbH -- MIT License

package/src/config.ts

@@ -62,6 +62,18 @@ export interface PalaiaPluginConfig {
   // ── Embedding Server (v2.0.8) ──────────────────────────────
   /** Enable long-lived embedding server subprocess for fast queries (default: true) */
   embeddingServer: boolean;
+
+  // ── Session Continuity (v3.0) ─────────────────────────────
+  /** Enable automatic session summaries on session end/reset (default: true) */
+  sessionSummary: boolean;
+  /** Enable session briefing injection on session start (default: true) */
+  sessionBriefing: boolean;
+  /** Max characters for session briefing (default: 1500) */
+  sessionBriefingMaxChars: number;
+  /** Enable tool observation tracking via after_tool_call hook (default: true) */
+  captureToolObservations: boolean;
+  /** Recency boost factor for recall (0 = off, 0.3 = 30% boost for <24h entries) */
+  recallRecencyBoost: number;
 }
 
 export const DEFAULT_RECALL_TYPE_WEIGHTS: RecallTypeWeights = {
@@ -86,6 +98,11 @@ export const DEFAULT_CONFIG: PalaiaPluginConfig = {
   recallTypeWeight: { ...DEFAULT_RECALL_TYPE_WEIGHTS },
   recallMinScore: 0.7,
   embeddingServer: true,
+  sessionSummary: true,
+  sessionBriefing: true,
+  sessionBriefingMaxChars: 1500,
+  captureToolObservations: true,
+  recallRecencyBoost: 0.3,
 };
 
 /**