@byte5ai/palaia 2.5.1 → 2.7.1

package/README.md

@@ -1,13 +1,13 @@
 # @byte5ai/palaia
 
-**Palaia memory backend for OpenClaw.**
+**palaia memory backend for OpenClaw.**
 
-Replace OpenClaw's built-in `memory-core` with Palaia — local, cloud-free, WAL-backed agent memory with tier routing and semantic search.
+Replace OpenClaw's built-in `memory-core` with palaia — local, cloud-free, WAL-backed agent memory with tier routing and semantic search.
 
 ## Installation
 
 ```bash
-# Install Palaia (Python CLI)
+# Install palaia (Python CLI)
 pip install palaia
 
 # Install the OpenClaw plugin
@@ -59,7 +59,7 @@ All options are optional — sensible defaults are used:
 
 ### `memory_search` (always available)
 
-Semantically search Palaia memory:
+Semantically search palaia memory:
 
 ```
 memory_search({ query: "deployment process", maxResults: 5, tier: "all" })

package/index.ts

@@ -1,5 +1,5 @@
 /**
- * @byte5ai/palaia — Palaia Memory Backend for OpenClaw
+ * @byte5ai/palaia — palaia Memory Backend for OpenClaw
  *
  * Plugin entry point. Loaded by OpenClaw via jiti (no build step needed).
  *
@@ -33,7 +33,7 @@ import type { OpenClawPluginApi, OpenClawPluginEntry } from "./src/types.js";
 // Plugin entry point compatible with OpenClaw plugin-sdk definePluginEntry
 const palaiaPlugin: OpenClawPluginEntry = {
   id: "palaia",
-  name: "Palaia Memory",
+  name: "palaia Memory",
   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

package/openclaw.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "palaia",
-  "name": "Palaia Memory",
+  "name": "palaia Memory",
   "kind": "memory",
   "skills": ["./skill"],
   "configSchema": {
@@ -12,7 +12,7 @@
       },
       "workspace": {
         "type": "string",
-        "description": "Palaia workspace path (default: agent workspace)"
+        "description": "palaia workspace path (default: agent workspace)"
       },
       "tier": {
         "type": "string",
@@ -106,7 +106,7 @@
   },
   "uiHints": {
     "binaryPath": {
-      "label": "Palaia Binary Path",
+      "label": "palaia Binary Path",
       "placeholder": "auto-detect"
     },
     "workspace": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@byte5ai/palaia",
-  "version": "2.5.1",
-  "description": "Palaia memory backend for OpenClaw",
+  "version": "2.7.1",
+  "description": "palaia memory backend for OpenClaw",
   "main": "index.ts",
   "openclaw": {
     "extensions": [

package/skill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: palaia
-version: "2.5.1"
+version: "2.7.1"
 description: >
   Local, crash-safe persistent memory for OpenClaw agents.
   SQLite-backed by default. Semantic search, projects, scopes, auto-capture.
@@ -15,26 +15,28 @@ metadata:
         kind: pip
         package: "palaia[fastembed]"
         bins: ["palaia"]
-        label: "Install Palaia with semantic search (pip)"
+        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)"
+        label: "Initialize palaia store"
+      - command: "openclaw plugins install @byte5ai/palaia"
+        label: "Install OpenClaw plugin"
     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"
+      - command: "python3 -m pip install --upgrade 'palaia[fastembed]' && openclaw plugins install @byte5ai/palaia && palaia doctor --fix && palaia warmup"
+        label: "Upgrade palaia with semantic search + 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.
+      palaia has been updated to v2.7. New: WebUI memory explorer (`palaia ui`),
+      improved doctor checks (legacy files, plugin registration), search timeout
+      fix, security hardening (localhost-only UI).
+      Run `palaia doctor --fix` to upgrade.
     plugin:
       slot: memory
       package: "@byte5ai/palaia"
 ---
 
-# Palaia v2.4 — Agent Memory Skill
+# palaia v2.7 — Agent Memory Skill
 
-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.
+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
@@ -73,22 +75,15 @@ Note: `palaia[fastembed]` already includes sqlite-vec for native SIMD vector sea
 After the CLI is installed, wire it into OpenClaw:
 
 ```bash
-npm install -g @byte5ai/palaia@latest
+openclaw plugins install @byte5ai/palaia
 ```
 
-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
+Then activate the memory slot in OpenClaw config:
+```json5
+// openclaw.json
 {
-  "plugins": {
-    "load": { "paths": ["<PALAIA_PATH>"] },
-    "allow": ["..existing..", "palaia"],
-    "slots": { "memory": "palaia" },
-    "entries": { "palaia": { "enabled": true } }
+  plugins: {
+    slots: { memory: "palaia" }
   }
 }
 ```
@@ -106,7 +101,7 @@ Single-agent systems work with the default name. For multi-agent setups:
 palaia init --agent YOUR_AGENT_NAME
 ```
 
-## Updating Palaia
+## Updating palaia
 
 When the user asks to update, or when `palaia status` shows a version mismatch:
 
@@ -133,7 +128,7 @@ pipx install "palaia[fastembed]" --force
 palaia doctor --fix
 
 # Step 4: Update OpenClaw plugin (if installed)
-npm install -g @byte5ai/palaia@latest
+openclaw plugins install @byte5ai/palaia
 ```
 
 After the manual update, `palaia upgrade` will be available for future updates.
@@ -141,14 +136,19 @@ After the manual update, `palaia upgrade` will be available for future updates.
 
 ## Auto-Check (run every time this skill is loaded)
 
-Before doing anything else with Palaia, run `palaia doctor` silently. If it reports ANY warnings, address them immediately by following `palaia doctor --fix` recommendations. Do not proceed with other Palaia tasks until doctor reports no issues.
+Before doing anything else with palaia, run `palaia doctor` silently. If it reports ANY warnings, address them immediately by following `palaia doctor --fix` recommendations. Do not proceed with other palaia tasks until doctor reports no issues.
 
 ---
 
 ## Core Concepts
 
-### Auto-Capture
-Conversations are automatically captured when the OpenClaw plugin is active. You do NOT need to manually write things from conversations — Palaia handles it. Manual `palaia write` is only for structured knowledge: processes, tasks, and knowledge from external sources.
+### Auto-Capture vs. Manual Write
+Conversations are automatically captured when the OpenClaw plugin is active. Auto-capture handles routine knowledge extraction from conversations.
+
+**Manual writes (`palaia write`) are higher value.** When you or the user identify something as especially important — a key decision, a reusable workflow, a critical fact from an external source — write it manually. Manually written entries are ranked higher than auto-captured ones in recall results, so they surface more prominently in future sessions. Use manual writes for:
+- Important facts, decisions, or context from external sources
+- Reusable processes and workflows (team runbooks)
+- Sticky notes / reminders for future sessions (tasks)
 
 ### Three Tiers
 - **HOT** — Active memories (< 7 days or frequently accessed). Always searched.
@@ -162,8 +162,8 @@ Conversations are automatically captured when the OpenClaw plugin is active. You
 
 ### Entry Types
 - **memory** — Facts, decisions, learnings (default)
-- **process** — Workflows, checklists, SOPs
-- **task** — Action items with status, priority, assignee, due date
+- **process** — Workflows, checklists, SOPs (team runbooks)
+- **task** — Sticky notes / reminders for future sessions. Tasks are ephemeral: when marked done, they are automatically deleted. Never auto-captured — only created by explicit `palaia write --type task`.
 
 ---
 
@@ -184,7 +184,7 @@ palaia config set database_url postgresql://user:pass@host/db
 
 ### 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.
+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):
 
@@ -215,7 +215,7 @@ The OpenClaw plugin starts the embed-server automatically. For CLI-only usage, i
 
 ### 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.
+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]'
@@ -265,22 +265,28 @@ palaia-mcp --read-only                  # No writes (untrusted hosts)
 
 ### `palaia write` — Save structured knowledge
 
-Only use for explicit process/task entries, or knowledge from external sources. Conversation knowledge is auto-captured.
+Use for important facts, reusable processes, sticky-note tasks, and knowledge from external sources. Manually written entries rank higher than auto-captured ones in recall.
 
 ```bash
-# Save a fact from outside the conversation
+# Save an important fact (ranks higher than auto-capture)
 palaia write "API rate limit is 100 req/min" --type memory --tags api,limits
 
-# Record a step-by-step process
-palaia write "1. Build 2. Test 3. Deploy" --type process --project myapp
+# Record a reusable team workflow (use specific, unique titles!)
+palaia write "Backend: Deploy to staging via Docker" --type process --project myapp --scope team
 
-# Create a task with structured fields
-palaia write "fix login bug" --type task --priority high --assignee Elliot --due-date 2026-04-01
+# Create a sticky note for a future session (deleted when done)
+palaia write "verify backup works after schema migration" --type task
 
 # Save to a specific project with scope
 palaia write "Use JWT for auth" --project backend --scope team --tags decision
 ```
 
+**Process naming convention:** Use the format `[Domain]: [What it does]` for process titles. Specific titles prevent duplicates and make processes findable.
+- Good: `"Release: PyPI publish + ClawHub sync"`, `"Backend: Deploy to staging via Docker"`
+- Bad: `"Deploy steps"`, `"Release process"` (too generic, will collide with other similar processes)
+
+Before writing a new process, search for existing ones: `palaia query "deploy" --type process`. If a similar process exists, update it with `palaia edit <id>` instead of creating a new one.
+
 ### `palaia query` — Semantic search
 
 Find memories by meaning, not just keywords.
@@ -438,6 +444,17 @@ 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 ui` — Local memory explorer (NEW in v2.7)
+
+```bash
+pip install 'palaia[ui]'   # One-time: install FastAPI + uvicorn
+palaia ui                  # Opens browser at http://127.0.0.1:8384
+palaia ui --port 9000      # Custom port (auto-fallback if busy)
+palaia ui --no-browser     # Don't auto-open browser
+```
+
+Browse, search, create, edit, and delete entries in the browser. Manual entries are highlighted with a gold border (1.3× recall boost). Tasks are post-its: clicking ✓ deletes them. The health pill in the header shows doctor status with actionable warnings. Localhost only — no authentication, no network exposure.
+
 ### `palaia doctor` — Diagnostics and auto-fix
 
 ```bash
@@ -457,6 +474,15 @@ palaia gc --aggressive      # Also clears COLD tier
 palaia gc --budget 200      # Keep max N entries
 ```
 
+### `palaia prune` — Selective cleanup (NEW in v2.5)
+
+```bash
+palaia prune --agent moneypenny     # Remove auto-captured entries by agent
+palaia prune --tags auto-capture    # Remove all auto-captured entries
+palaia prune --dry-run              # Preview what would be removed
+palaia prune --protect-type process # Never delete process entries
+```
+
 ### `palaia config` — Configuration
 
 ```bash
@@ -486,10 +512,13 @@ palaia project locks                      # List all active locks
 ### `palaia edit` — Modify existing entries
 
 ```bash
-palaia edit <id> --status done
+palaia edit <id> --status done         # For tasks: this DELETES the entry (sticky note completed)
+palaia edit <id> --status wontfix      # For tasks: also deletes (cancelled reminder)
 palaia edit <id> "updated content" --tags new,tags --priority high
 ```
 
+**Task lifecycle:** Tasks are sticky notes. When you mark a task as `done` or `wontfix`, it is automatically deleted — not archived. This is intentional: completed reminders have no long-term value. If the outcome of the task should be remembered, write a separate memory entry before marking the task done.
+
 ### Other commands
 
 ```bash
@@ -508,7 +537,7 @@ All commands support `--json` for machine-readable output.
 
 ## Smart Nudging
 
-Palaia's CLI output contains contextual hints prefixed with `[palaia]`. These are important guidance.
+palaia's CLI output contains contextual hints prefixed with `[palaia]`. These are important guidance.
 
 **As an agent, you should:**
 - Read and act on nudge messages in CLI output
@@ -649,12 +678,12 @@ palaia write "## Dev-Agent Lifecycle
 
 | Situation | Command |
 |-----------|---------|
-| Remember a fact (not from conversation) | `palaia write "..." --type memory` |
-| Record a process/SOP | `palaia write "steps..." --type process` |
-| Create a task | `palaia write "fix bug" --type task --priority high` |
-| Mark task done | `palaia edit <id> --status done` |
+| Save an important fact or decision | `palaia write "..." --type memory` (ranks higher than auto-capture) |
+| Document a reusable workflow | `palaia write "Domain: Steps..." --type process --scope team` |
+| Leave a reminder for future sessions | `palaia write "check X after Y" --type task` (auto-deleted when done) |
+| Mark a reminder as done | `palaia edit <id> --status done` (deletes the task) |
 | Find something | `palaia query "..."` |
-| Find open tasks | `palaia list --type task --status open` |
+| Find open reminders | `palaia list --type task --status open` |
 | Check system health | `palaia status` |
 | Something is wrong | `palaia doctor --fix` |
 | Clean up old entries | `palaia gc` |
@@ -662,11 +691,11 @@ palaia write "## Dev-Agent Lifecycle
 | Review accumulated knowledge | `palaia curate analyze` |
 | Share knowledge | `palaia sync export` or `palaia package export` |
 | Check for messages | `palaia memo inbox` |
-| Start of session | Session briefing is now automatic. Just run `palaia doctor` and check `palaia memo inbox`. |
+| Start of session | Session briefing is 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.
+**Auto-capture** handles routine conversation knowledge. **Manual writes rank higher** in recall — use them when something is especially important, reusable, or comes from an external source.
 
-**DO manually write:** processes, tasks with structured fields, knowledge from external sources, project setup.
+**DO manually write:** key decisions, reusable processes (team runbooks), sticky-note reminders (tasks), important facts from external sources.
 
 ---
 
@@ -706,10 +735,10 @@ palaia init --capture-level <off|minimal|normal|aggressive>
 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 briefings are injected automatically at session start. They contain your last session summary and any open tasks (sticky notes). Read the briefing carefully — it is your primary context for continuing previous work. Do not ask the user "where did we leave off?" when a briefing is present. Instead, acknowledge the context and continue seamlessly.
 
 ### 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:
+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
 ```
@@ -721,7 +750,7 @@ Wrap sensitive content in `<private>...</private>` blocks to exclude it from aut
 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:
+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
 ```
@@ -750,6 +779,7 @@ Set in `openclaw.json` under `plugins.entries.palaia.config`:
 | `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) |
+| `manualEntryBoost` | `1.3` | Boost factor for manually written entries vs auto-captured (1.0=off) |
 
 ---
 

package/src/config.ts

@@ -12,7 +12,7 @@ export interface RecallTypeWeights {
 export interface PalaiaPluginConfig {
   /** Path to palaia binary (default: auto-detect) */
   binaryPath?: string;
-  /** Palaia workspace path (default: agent workspace) */
+  /** palaia workspace path (default: agent workspace) */
   workspace?: string;
   /** Default tier filter: "hot" | "warm" | "all" */
   tier: string;
@@ -74,6 +74,8 @@ export interface PalaiaPluginConfig {
   captureToolObservations: boolean;
   /** Recency boost factor for recall (0 = off, 0.3 = 30% boost for <24h entries) */
   recallRecencyBoost: number;
+  /** Boost factor for manually written entries vs auto-captured (default: 1.3 = 30% boost) */
+  manualEntryBoost: number;
 }
 
 export const DEFAULT_RECALL_TYPE_WEIGHTS: RecallTypeWeights = {
@@ -103,6 +105,7 @@ export const DEFAULT_CONFIG: PalaiaPluginConfig = {
   sessionBriefingMaxChars: 1500,
   captureToolObservations: true,
   recallRecencyBoost: 0.3,
+  manualEntryBoost: 1.3,
 };
 
 /**

package/src/context-engine.ts

@@ -33,7 +33,7 @@ import {
   extractWithLLM,
   shouldAttemptCapture,
   extractSignificance,
-  stripPalaiaInjectedContext,
+  strippalaiaInjectedContext,
   stripPrivateBlocks,
   trimToRecentExchanges,
   parsePalaiaHints,
@@ -174,12 +174,12 @@ async function buildMemoryContext(
   }
 
   // Apply type-weighted reranking and blocked filtering (Issue #121)
-  const rankedRaw = rerankByTypeWeight(entries, resolvedPrio.recallTypeWeight, config.recallRecencyBoost);
+  const rankedRaw = rerankByTypeWeight(entries, resolvedPrio.recallTypeWeight, config.recallRecencyBoost, config.manualEntryBoost);
   const ranked = filterBlocked(rankedRaw, resolvedPrio.blocked);
 
   // Build context string — progressive disclosure for large stores
   const compact = shouldUseCompactMode(ranked.length);
-  let text = "## Active Memory (Palaia)\n\n";
+  let text = "## Active Memory (palaia)\n\n";
   if (compact) {
     text += "_Compact mode — use `memory_get <id>` for full details._\n\n";
   }
@@ -193,7 +193,7 @@ async function buildMemoryContext(
   }
 
   // Build nudge text and check remaining budget before appending
-  const USAGE_NUDGE = "[palaia] auto-capture=on. Manual write: --type process (SOPs/checklists) or --type task (todos with assignee/deadline) only. Conversation knowledge is auto-captured — do not duplicate with manual writes.";
+  const USAGE_NUDGE = "[palaia] auto-capture=on. Manual writes rank higher in recall. Use --type process for reusable workflows, --type task for sticky-note reminders (auto-deleted when done), --type memory for important facts.";
   let agentNudges = "";
   try {
     const pluginState = await loadPluginState(config.workspace);
@@ -203,7 +203,7 @@ async function buildMemoryContext(
     }
     const { nudges } = checkNudges(pluginState);
     if (nudges.length > 0) {
-      agentNudges = "\n\n## Agent Nudge (Palaia)\n\n" + nudges.join("\n\n");
+      agentNudges = "\n\n## Agent Nudge (palaia)\n\n" + nudges.join("\n\n");
     }
     await savePluginState(pluginState, config.workspace);
   } catch {
@@ -255,11 +255,17 @@ async function runAutoCapture(
   logger: { info(...a: unknown[]): void; warn(...a: unknown[]): void },
 ): Promise<boolean> {
   if (!config.autoCapture) return false;
-  if (!messages || messages.length === 0) return false;
+  if (!messages || messages.length === 0) {
+    logger.info("[palaia] Auto-capture skipped: no messages");
+    return false;
+  }
 
   const allTexts = extractMessageTexts(messages);
   const userTurns = allTexts.filter((t) => t.role === "user").length;
-  if (userTurns < config.captureMinTurns) return false;
+  if (userTurns < config.captureMinTurns) {
+    logger.info(`[palaia] Auto-capture skipped: ${userTurns} user turns < captureMinTurns=${config.captureMinTurns}`);
+    return false;
+  }
 
   // Parse capture hints
   const collectedHints: { project?: string; scope?: string }[] = [];
@@ -272,7 +278,7 @@ async function runAutoCapture(
   const cleanedTexts = allTexts.map(t => ({
     ...t,
     text: stripPrivateBlocks(
-      t.role === "user" ? stripPalaiaInjectedContext(t.text) : t.text
+      t.role === "user" ? strippalaiaInjectedContext(t.text) : t.text
     ),
   }));
   const recentTexts = trimToRecentExchanges(cleanedTexts);
@@ -283,7 +289,10 @@ async function runAutoCapture(
   }
   const exchangeText = exchangeParts.join("\n");
 
-  if (!shouldAttemptCapture(exchangeText)) return false;
+  if (!shouldAttemptCapture(exchangeText)) {
+    logger.info(`[palaia] Auto-capture skipped: content did not pass significance filter (${exchangeText.length} chars)`);
+    return false;
+  }
 
   const hookOpts = buildRunnerOpts(config);
   const knownProjects = await loadProjects(hookOpts);
@@ -295,6 +304,7 @@ async function runAutoCapture(
   try {
     const results = await extractWithLLM(messages, api.config, {
       captureModel: config.captureModel,
+      workspace: config.workspace,
     }, knownProjects);
 
     for (const r of results) {
@@ -330,7 +340,10 @@ async function runAutoCapture(
   if (!llmHandled) {
     if (config.captureFrequency === "significant") {
       const significance = extractSignificance(exchangeText);
-      if (!significance) return false;
+      if (!significance) {
+        logger.info("[palaia] Auto-capture skipped: rule-based extraction found no significance (need ≥2 distinct tags)");
+        return false;
+      }
       const tags = [...significance.tags];
       if (!tags.includes("auto-capture")) tags.push("auto-capture");
       const scope = effectiveCaptureScope !== "team"
@@ -379,7 +392,7 @@ export function createPalaiaContextEngine(
   const engine: ContextEngine = {
     info: {
       id: "palaia",
-      name: "Palaia Memory",
+      name: "palaia Memory",
       version: "2.3",
     },
 

package/src/hooks/capture.ts

@@ -237,12 +237,8 @@ WHAT TO CAPTURE (be thorough — capture anything worth remembering):
 - Project context changes: scope changes, timeline shifts, requirement updates, priority changes
 - Workflow patterns the user established ("my process is...", "I always do X before Y")
 
-STRICT TASK CLASSIFICATION RULES — a "task" MUST have ALL three of:
-1. A clear, completable action (not just an observation or idea)
-2. An identifiable responsible party (explicitly named or unambiguously inferable from context)
-3. A concrete deliverable or measurable end state
-If ANY of these is missing, classify as "memory" instead of "task". When in doubt, use "memory".
-Observations, learnings, insights, opinions, and general knowledge are ALWAYS "memory", never "task".
+IMPORTANT: Never classify as "task". Tasks are manually created sticky notes (post-its) — they must only come from explicit user/agent intent via palaia write --type task. Auto-capture must use "memory" or "process" only.
+Observations, learnings, insights, opinions, action items, and general knowledge are ALWAYS "memory" or "process", never "task".
 
 Only extract genuinely significant knowledge. Skip small talk, acknowledgments, routine exchanges.
 Do NOT extract if similar knowledge was likely captured in a recent exchange. Prefer quality over quantity. Skip routine status updates and acknowledgments.
@@ -461,7 +457,7 @@ export function trimToRecentExchanges(
 export async function extractWithLLM(
   messages: unknown[],
   config: any,
-  pluginConfig?: { captureModel?: string },
+  pluginConfig?: { captureModel?: string; workspace?: string },
   knownProjects?: CachedProject[],
 ): Promise<ExtractionResult[]> {
   const runEmbeddedPiAgent = await getEmbeddedPiAgent();
@@ -472,10 +468,10 @@ export async function extractWithLLM(
   }
 
   const allTexts = extractMessageTexts(messages);
-  // Strip Palaia-injected recall context and private blocks from user messages
+  // Strip palaia-injected recall context and private blocks from user messages
   const cleanedTexts = allTexts.map(t =>
     t.role === "user"
-      ? { ...t, text: stripPrivateBlocks(stripPalaiaInjectedContext(t.text)) }
+      ? { ...t, text: stripPrivateBlocks(strippalaiaInjectedContext(t.text)) }
       : { ...t, text: stripPrivateBlocks(t.text) }
   );
   // Only extract from recent exchanges — full history causes LLM timeouts
@@ -519,7 +515,7 @@ export async function extractWithLLM(
     const result = await runEmbeddedPiAgent({
       sessionId,
       sessionFile,
-      workspaceDir: config?.agents?.defaults?.workspace ?? process.cwd(),
+      workspaceDir: pluginConfig?.workspace || config?.agents?.defaults?.workspace || process.cwd(),
       config,
       prompt,
       timeoutMs: 15_000,
@@ -551,7 +547,8 @@ export async function extractWithLLM(
       const content = typeof item.content === "string" ? item.content.trim() : "";
       if (!content) continue;
 
-      const validTypes = new Set(["memory", "process", "task"]);
+      const validTypes = new Set(["memory", "process"]);
+      // Tasks are manual-only (post-its) — auto-capture never creates tasks
       const type = validTypes.has(item.type) ? item.type : "memory";
 
       const validTags = new Set([
@@ -614,9 +611,9 @@ const SIGNIFICANCE_RULES: Array<{
   { pattern: /(?:mistake was|fehler war|should have|hätten sollen|next time)/i, tag: "lesson", type: "memory" },
   // Surprises
   { pattern: /(?:surprising|überraschend|unexpected|unerwartet|didn'?t expect|nicht erwartet|plot twist)/i, tag: "surprise", type: "memory" },
-  // Commitments and tasks
-  { pattern: /(?:i will|ich werde|todo:|action item|must do|muss noch|need to|commit to|verspreche)/i, tag: "commitment", type: "task" },
-  { pattern: /(?:deadline|frist|due date|bis zum|by end of|spätestens)/i, tag: "commitment", type: "task" },
+  // Commitments (captured as memory — tasks are manual-only post-its)
+  { pattern: /(?:i will|ich werde|todo:|action item|must do|muss noch|need to|commit to|verspreche)/i, tag: "commitment", type: "memory" },
+  { pattern: /(?:deadline|frist|due date|bis zum|by end of|spätestens)/i, tag: "commitment", type: "memory" },
   // Processes and workflows
   { pattern: /(?:the process is|der prozess|steps?:|workflow:|how to|anleitung|recipe:|checklist)/i, tag: "process", type: "process" },
   { pattern: /(?:first,?\s.*then|schritt \d|step \d|1\.\s.*2\.\s)/i, tag: "process", type: "process" },
@@ -725,22 +722,22 @@ export function extractSignificance(
 }
 
 /**
- * Strip Palaia-injected recall context from message text.
+ * Strip palaia-injected recall context from message text.
  * The recall block is prepended to user messages by before_prompt_build via prependContext.
  * OpenClaw merges it into the user message, so agent_end sees it as user content.
  * Without stripping, auto-capture re-captures the injected memories -> feedback loop.
  *
  * The block has a stable structure:
- * - Starts with "## Active Memory (Palaia)"
+ * - Starts with "## Active Memory (palaia)"
  * - Contains [t/m], [t/pr], [t/tk] prefixed entries
  * - Ends with "[palaia] auto-capture=on..." nudge line
  */
-export function stripPalaiaInjectedContext(text: string): string {
-  // Pattern: "## Active Memory (Palaia)" ... "[palaia] auto-capture=on..." + optional trailing newlines
+export function strippalaiaInjectedContext(text: string): string {
+  // Pattern: "## Active Memory (palaia)" ... "[palaia] auto-capture=on..." + optional trailing newlines
   // The nudge line is always present and marks the end of the injected block
-  const PALAIA_BLOCK_RE = /## Active Memory \(Palaia\)[\s\S]*?\[palaia\][^\n]*\n*/;
+  const PALAIA_BLOCK_RE = /## Active Memory \(palaia\)[\s\S]*?\[palaia\][^\n]*\n*/;
   // Also strip Session Briefing blocks
-  const BRIEFING_BLOCK_RE = /## Session Briefing \(Palaia\)[\s\S]*?(?=\n##|\n\n\n|$)/;
+  const BRIEFING_BLOCK_RE = /## Session Briefing \(palaia\)[\s\S]*?(?=\n##|\n\n\n|$)/;
   return text
     .replace(PALAIA_BLOCK_RE, '')
     .replace(BRIEFING_BLOCK_RE, '')

package/src/hooks/index.ts

@@ -1,5 +1,5 @@
 /**
- * Lifecycle hooks for the Palaia OpenClaw plugin.
+ * Lifecycle hooks for the palaia OpenClaw plugin.
  *
  * - before_prompt_build: Query-based contextual recall (Issue #65).
  *   Returns appendSystemContext with brain instruction when memory is used.
@@ -81,7 +81,7 @@ export {
   isNoiseContent,
   shouldAttemptCapture,
   extractSignificance,
-  stripPalaiaInjectedContext,
+  strippalaiaInjectedContext,
 } from "./capture.js";
 
 // Reaction exports
@@ -130,7 +130,7 @@ import {
   resolveCaptureModel,
   shouldAttemptCapture,
   extractSignificance,
-  stripPalaiaInjectedContext,
+  strippalaiaInjectedContext,
   trimToRecentExchanges,
   setLogger as setCaptureLogger,
   getLlmImportFailureLogged,
@@ -278,7 +278,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
   // ── /palaia status command ─────────────────────────────────────
   api.registerCommand({
     name: "palaia-status",
-    description: "Show Palaia memory status",
+    description: "Show palaia memory status",
     async handler(_args: string) {
       try {
         const state = await loadPluginState(config.workspace);
@@ -293,7 +293,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
 
         return { text: formatStatusResponse(state, stats, config) };
       } catch (error) {
-        return { text: `Palaia status error: ${error}` };
+        return { text: `palaia status error: ${error}` };
       }
     },
   });
@@ -482,13 +482,13 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
         }
 
         // Apply type-weighted reranking and blocked filtering (Issue #121)
-        const rankedRaw = rerankByTypeWeight(entries, resolvedPrio.recallTypeWeight, config.recallRecencyBoost);
+        const rankedRaw = rerankByTypeWeight(entries, resolvedPrio.recallTypeWeight, config.recallRecencyBoost, config.manualEntryBoost);
         const ranked = filterBlocked(rankedRaw, resolvedPrio.blocked);
 
         // Build context string with char budget
         // Progressive disclosure: compact mode for large stores (title + first line + ID)
         const compact = shouldUseCompactMode(ranked.length);
-        let text = "## Active Memory (Palaia)\n\n";
+        let text = "## Active Memory (palaia)\n\n";
         if (compact) {
           text += "_Compact mode — use `memory_get <id>` for full details._\n\n";
         }
@@ -512,7 +512,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
           }
           const { nudges } = checkNudges(pluginState);
           if (nudges.length > 0) {
-            nudgeContext = "\n\n## Agent Nudge (Palaia)\n\n" + nudges.join("\n\n");
+            nudgeContext = "\n\n## Agent Nudge (palaia)\n\n" + nudges.join("\n\n");
           }
           await savePluginState(pluginState, resolved.workspace);
         } catch {
@@ -556,7 +556,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
         return {
           prependContext: briefingText + text,
           appendSystemContext: config.showMemorySources
-            ? "You used Palaia memory in this turn. Add \u{1f9e0} at the very end of your response (after everything else, on its own line)."
+            ? "You used palaia memory in this turn. Add \u{1f9e0} at the very end of your response (after everything else, on its own line)."
             : undefined,
         };
       } catch (error) {
@@ -587,6 +587,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
       const hookOpts = buildRunnerOpts(config, { workspace: resolved.workspace });
 
       if (!event.success || !event.messages || event.messages.length === 0) {
+        logger.info(`[palaia] Auto-capture skipped: success=${event.success}, messages=${event.messages?.length ?? 0}`);
         return;
       }
 
@@ -597,6 +598,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
 
         const userTurns = allTexts.filter((t) => t.role === "user").length;
         if (userTurns < config.captureMinTurns) {
+          logger.info(`[palaia] Auto-capture skipped: ${userTurns} user turns < captureMinTurns=${config.captureMinTurns}`);
           return;
         }
 
@@ -607,7 +609,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
           collectedHints.push(...hints);
         }
 
-        // Strip Palaia-injected recall context and private blocks from messages.
+        // Strip palaia-injected recall context and private blocks from messages.
         // The recall block is prepended to user messages by before_prompt_build.
         // Without stripping, auto-capture would re-capture previously recalled memories.
         // Private blocks (<private>...</private>) must be excluded from capture.
@@ -615,7 +617,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
         const cleanedTexts = allTexts.map(t => ({
           ...t,
           text: stripPrivateBlocks(
-            t.role === "user" ? stripPalaiaInjectedContext(t.text) : t.text
+            t.role === "user" ? strippalaiaInjectedContext(t.text) : t.text
           ),
         }));
 
@@ -632,6 +634,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
         const exchangeText = exchangeParts.join("\n");
 
         if (!shouldAttemptCapture(exchangeText)) {
+          logger.info(`[palaia] Auto-capture skipped: content did not pass significance filter (${exchangeText.length} chars)`);
           return;
         }
 
@@ -733,6 +736,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
         try {
           const results = await extractWithLLM(event.messages, api.config, {
             captureModel: config.captureModel,
+            workspace: resolved.workspace,
           }, knownProjects);
 
           await storeLLMResults(results);
@@ -752,6 +756,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
               // Retry without captureModel -> resolveCaptureModel will use primary model
               const fallbackResults = await extractWithLLM(event.messages, api.config, {
                 captureModel: undefined,
+                workspace: resolved.workspace,
               }, knownProjects);
               await storeLLMResults(fallbackResults);
               llmHandled = true;
@@ -776,6 +781,7 @@ export function registerHooks(api: OpenClawPluginApi, config: PalaiaPluginConfig
           if (config.captureFrequency === "significant") {
             const significance = extractSignificance(exchangeText);
             if (!significance) {
+              logger.info("[palaia] Auto-capture skipped: rule-based extraction found no significance (need ≥2 distinct tags)");
               return;
             }
             captureData = significance;

package/src/hooks/recall.ts

@@ -6,7 +6,7 @@
  */
 
 import type { RecallTypeWeights } from "../config.js";
-import { stripPalaiaInjectedContext } from "./capture.js";
+import { strippalaiaInjectedContext } from "./capture.js";
 
 // ============================================================================
 // Types
@@ -79,7 +79,7 @@ export function buildFootnote(
     const dateStr = formatShortDate(e.date);
     return dateStr ? `"${e.title}" (${dateStr})` : `"${e.title}"`;
   });
-  return `\n\n\u{1f4ce} Palaia: ${parts.join(", ")}`;
+  return `\n\n\u{1f4ce} palaia: ${parts.join(", ")}`;
 }
 
 // Re-export formatShortDate from state for use here
@@ -96,7 +96,7 @@ const TRANSPARENCY_RECALL_THRESHOLD = 50;
 const TRANSPARENCY_DAYS_THRESHOLD = 7;
 
 const SATISFACTION_NUDGE_TEXT =
-  "Your user has been using Palaia for a while now. " +
+  "Your user has been using palaia for a while now. " +
   "Ask them casually if they're happy with the memory system. " +
   "If there are issues, suggest `palaia doctor`.";
 
@@ -268,7 +268,7 @@ function isSystemOnlyContent(text: string): boolean {
 export function buildRecallQuery(messages: unknown[]): string {
   const texts = extractMessageTexts(messages).map(t =>
     t.role === "user"
-      ? { ...t, text: stripPalaiaInjectedContext(t.text) }
+      ? { ...t, text: strippalaiaInjectedContext(t.text) }
       : t
   );
 
@@ -367,12 +367,17 @@ export function rerankByTypeWeight(
   results: QueryResult["results"],
   weights: Record<string, number>,
   recencyBoost = 0,
+  manualEntryBoost = 1.3,
 ): RankedEntry[] {
   return results
     .map((r) => {
       const type = r.type || "memory";
       const weight = weights[type] ?? 1.0;
       const recency = calcRecencyBoost(r.created, recencyBoost);
+      // Manual entries (no auto-capture tag) get a boost over auto-captured ones.
+      // This ensures intentionally stored knowledge ranks higher than conversation noise.
+      const isAutoCapture = r.tags?.includes("auto-capture") ?? false;
+      const sourceBoost = isAutoCapture ? 1.0 : manualEntryBoost;
       return {
         id: r.id,
         body: r.content || r.body || "",
@@ -383,7 +388,7 @@ export function rerankByTypeWeight(
         score: r.score,
         bm25Score: r.bm25_score,
         embedScore: r.embed_score,
-        weightedScore: r.score * weight * recency,
+        weightedScore: r.score * weight * recency * sourceBoost,
         created: r.created,
         tags: r.tags,
       };

package/src/hooks/session.ts

@@ -20,7 +20,7 @@ import {
   type ToolObservation,
 } from "./state.js";
 import {
-  stripPalaiaInjectedContext,
+  strippalaiaInjectedContext,
   stripPrivateBlocks,
   trimToRecentExchanges,
   extractWithLLM,
@@ -111,7 +111,7 @@ export function formatBriefing(briefing: PendingBriefing, maxChars: number): str
   if (maxChars <= 0) return "";
   if (!briefing.summary && briefing.openTasks.length === 0) return "";
 
-  const parts: string[] = ["## Session Briefing (Palaia)\n"];
+  const parts: string[] = ["## Session Briefing (palaia)\n"];
 
   if (briefing.summary) {
     const agoMs = Date.now() - briefing.timestamp;
@@ -161,6 +161,7 @@ export async function captureSessionSummary(
     try {
       const results = await extractWithLLM(messages, api.config, {
         captureModel: config.captureModel,
+        workspace: config.workspace,
       }, []);
 
       if (results.length > 0) {
@@ -176,7 +177,7 @@ export async function captureSessionSummary(
       const cleaned = allTexts.map((t: { role: string; text: string }) => ({
         ...t,
         text: stripPrivateBlocks(
-          t.role === "user" ? stripPalaiaInjectedContext(t.text) : t.text
+          t.role === "user" ? strippalaiaInjectedContext(t.text) : t.text
         ),
       }));
       const recent = trimToRecentExchanges(cleaned, 3);

package/src/hooks/state.ts

@@ -338,10 +338,11 @@ const VALID_SCOPES = ["private", "team", "public"];
 
 /**
  * Check if a scope string is valid for palaia write.
- * Valid: "private", "team", "public", or any "shared:*" prefix.
+ * Valid: "private", "team", "public".
+ * Legacy shared:X is accepted but normalized to "team" by the CLI.
  */
 export function isValidScope(s: string): boolean {
-  return VALID_SCOPES.includes(s) || s.startsWith("shared:");
+  return VALID_SCOPES.includes(s);
 }
 
 /**
@@ -395,7 +396,7 @@ export function formatStatusResponse(
   stats: Record<string, unknown>,
   config: PalaiaPluginConfig,
 ): string {
-  const lines: string[] = ["Palaia Memory Status", ""];
+  const lines: string[] = ["palaia Memory Status", ""];
 
   // Recall count
   const sinceDate = state.firstRecallTimestamp

package/src/runner.ts

@@ -1,5 +1,5 @@
 /**
- * Palaia CLI subprocess runner.
+ * palaia CLI subprocess runner.
  *
  * Executes palaia CLI commands, parses JSON output, handles binary detection
  * and timeouts. This is the bridge between the OpenClaw plugin and the
@@ -92,7 +92,7 @@ export async function detectBinary(
   }
 
   throw new Error(
-    "Palaia binary not found. Install with: pip install palaia\n" +
+    "palaia binary not found. Install with: pip install palaia\n" +
       "Or set binaryPath in plugin config."
   );
 }
@@ -129,7 +129,7 @@ function execCommand(
       (error, stdout, stderr) => {
         if (error && (error as any).killed) {
           reject(
-            new Error(`Palaia command timed out after ${timeout}ms: ${cmd} ${args.join(" ")}`)
+            new Error(`palaia command timed out after ${timeout}ms: ${cmd} ${args.join(" ")}`)
           );
           return;
         }
@@ -184,7 +184,7 @@ export async function run(
 
   if (result.exitCode !== 0) {
     const errMsg = result.stderr.trim() || result.stdout.trim();
-    throw new Error(`Palaia CLI error (exit ${result.exitCode}): ${errMsg}`);
+    throw new Error(`palaia CLI error (exit ${result.exitCode}): ${errMsg}`);
   }
 
   return result.stdout;

package/src/tools.ts

@@ -1,13 +1,13 @@
 /**
  * Agent tools: memory_search, memory_get, memory_write.
  *
- * These tools are the core of the Palaia OpenClaw integration.
+ * These tools are the core of the palaia OpenClaw integration.
  * They shell out to the palaia CLI with --json and return results
  * in the format OpenClaw agents expect.
  */
 
 import { Type } from "@sinclair/typebox";
-import { run, runJson, type RunnerOpts } from "./runner.js";
+import { run, runJson, getEmbedServerManager, type RunnerOpts } from "./runner.js";
 import type { PalaiaPluginConfig } from "./config.js";
 import { sanitizeScope, isValidScope } from "./hooks/index.js";
 import { loadPriorities, resolvePriorities } from "./priorities.js";
@@ -62,7 +62,7 @@ function buildRunnerOpts(config: PalaiaPluginConfig): RunnerOpts {
 }
 
 /**
- * Register all Palaia agent tools on the given plugin API.
+ * Register all palaia agent tools on the given plugin API.
  */
 export function registerTools(api: OpenClawPluginApi, config: PalaiaPluginConfig): void {
   const opts = buildRunnerOpts(config);
@@ -71,7 +71,7 @@ export function registerTools(api: OpenClawPluginApi, config: PalaiaPluginConfig
   api.registerTool({
     name: "memory_search",
     description:
-      "Semantically search Palaia memory for relevant notes and context.",
+      "Semantically search palaia memory for relevant notes and context.",
     parameters: Type.Object({
       query: Type.String({ description: "Search query" }),
       maxResults: Type.Optional(
@@ -114,30 +114,48 @@ export function registerTools(api: OpenClawPluginApi, config: PalaiaPluginConfig
       }
 
       const limit = params.maxResults || config.maxResults || 5;
-      const args: string[] = ["query", params.query, "--limit", String(limit)];
+      const includeCold = params.tier === "all" || config.tier === "all";
 
-      // --all flag includes cold tier
-      if (params.tier === "all" || config.tier === "all") {
-        args.push("--all");
+      // Try embed server first — its queue correctly handles concurrent requests
+      // without counting wait time against the timeout.
+      let result: QueryResult | null = null;
+      if (config.embeddingServer) {
+        try {
+          const mgr = getEmbedServerManager(opts);
+          const resp = await mgr.query({
+            text: params.query,
+            top_k: limit,
+            include_cold: includeCold,
+            ...(params.type ? { type: params.type } : {}),
+          }, config.timeoutMs || 3000);
+          if (resp?.result?.results && Array.isArray(resp.result.results)) {
+            result = { results: resp.result.results };
+          }
+        } catch {
+          // Fall through to CLI
+        }
       }
 
-      // Type filter (Issue #82)
-      if (params.type) {
-        args.push("--type", params.type);
+      // CLI fallback — longer timeout since it includes process spawn overhead
+      if (!result) {
+        const args: string[] = ["query", params.query, "--limit", String(limit)];
+        if (includeCold) {
+          args.push("--all");
+        }
+        if (params.type) {
+          args.push("--type", params.type);
+        }
+        result = await runJson<QueryResult>(args, { ...opts, timeoutMs: 15000 });
       }
 
-      const result = await runJson<QueryResult>(args, opts);
-
       // Apply scope visibility filter (Issue #145: agent isolation)
       let filteredResults = result.results || [];
       if (scopeVisibility) {
         filteredResults = filteredResults.filter((r) => {
           const scope = r.scope || "team";
-          return scopeVisibility!.some((allowed) => {
-            if (scope === allowed) return true;
-            if (allowed === "shared" && scope.startsWith("shared:")) return true;
-            return false;
-          });
+          // Legacy shared:X entries are treated as team
+          const effectiveScope = scope.startsWith("shared:") ? "team" : scope;
+          return scopeVisibility!.includes(effectiveScope);
         });
       }
 
@@ -173,7 +191,7 @@ export function registerTools(api: OpenClawPluginApi, config: PalaiaPluginConfig
   // ── memory_get ─────────────────────────────────────────────────
   api.registerTool({
     name: "memory_get",
-    description: "Read a specific Palaia memory entry by path or id.",
+    description: "Read a specific palaia memory entry by path or id.",
     parameters: Type.Object({
       path: Type.String({ description: "Memory path or UUID" }),
       from: Type.Optional(
@@ -213,12 +231,12 @@ export function registerTools(api: OpenClawPluginApi, config: PalaiaPluginConfig
     {
       name: "memory_write",
       description:
-        "Write a new memory entry to Palaia. WAL-backed, crash-safe.",
+        "Write a new memory entry to palaia. WAL-backed, crash-safe.",
       parameters: Type.Object({
         content: Type.String({ description: "Memory content to write" }),
         scope: Type.Optional(
           Type.String({
-            description: "Scope: private|team|shared:X|public (default: team)",
+            description: "Scope: private|team|public (default: team)",
             default: "team",
           })
         ),
@@ -306,7 +324,7 @@ export function registerTools(api: OpenClawPluginApi, config: PalaiaPluginConfig
               content: [
                 {
                   type: "text" as const,
-                  text: `Invalid scope "${params.scope}". Valid scopes: private, team, public, shared:<name>`,
+                  text: `Invalid scope "${params.scope}". Valid scopes: private, team, public`,
                 },
               ],
             };

package/src/types.ts

@@ -324,7 +324,7 @@ export type SubagentEndReason = "deleted" | "completed" | "swept" | "released";
 /**
  * ContextEngine interface — matches OpenClaw v2026.3.28.
  *
- * This is the full interface. Palaia implements a subset;
+ * This is the full interface. palaia implements a subset;
  * optional methods are marked with `?`.
  */
 export interface ContextEngine {