claude-smart 0.2.42 → 0.2.44

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/publish_clawhub.sh

@@ -0,0 +1,278 @@
+#!/usr/bin/env bash
+# Publishes the reflexio openclaw integration as a single ClawHub skill.
+#
+# Two modes:
+#   1) CLI publish — stages into a temp dir, generates top-level SKILL.md,
+#      runs `bun clawhub skill publish`. Requires bun + an authed session.
+#   2) Stage-only — same staging + SKILL.md generation, but skips publish
+#      and prints the staged path so you can drop it onto the web form at
+#      https://clawhub.ai/publish-skill.
+#
+# Usage:
+#   ./publish_clawhub.sh <semver> [changelog]            # CLI publish
+#   ./publish_clawhub.sh --stage-only                    # produce folder for web upload
+#
+# Prereqs:
+#   - CLI mode: `bun clawhub login` done, `bun` on PATH
+#   - Stage-only mode: just `rsync` and `python3` on PATH
+
+set -euo pipefail
+
+STAGE_ONLY=0
+if [[ "${1:-}" == "--stage-only" ]]; then
+  STAGE_ONLY=1
+  VERSION="0.0.0-staged"
+  CHANGELOG=""
+else
+  VERSION="${1:?usage: publish_clawhub.sh <semver> [changelog]  |  --stage-only}"
+  if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+([.-][A-Za-z0-9.-]+)?$ ]]; then
+    echo "error: version must be semver (got: $VERSION)" >&2
+    exit 1
+  fi
+  CHANGELOG="${2:-Release $VERSION}"
+fi
+
+SRC="$(cd "$(dirname "$0")" && pwd)"
+STAGE="$(mktemp -d -t reflexio-clawhub-XXXXXX)"
+if (( STAGE_ONLY == 0 )); then
+  trap 'rm -rf "$STAGE"' EXIT
+fi
+
+if (( STAGE_ONLY == 0 )); then
+  if ! command -v bun >/dev/null 2>&1; then
+    echo "error: bun not found on PATH (install from https://bun.sh)" >&2
+    exit 1
+  fi
+
+  if ! bun clawhub whoami >/dev/null 2>&1; then
+    echo "error: not logged in to clawhub. run: bun clawhub login" >&2
+    exit 1
+  fi
+fi
+
+echo "staging bundle → $STAGE"
+# Prune everything that shouldn't be in the published bundle. The web
+# uploader at clawhub.ai/publish-skill does NOT read .clawhubignore
+# (that's a CLI-only feature), so we pre-filter here and the same stage
+# dir works for both CLI publish and web drag-drop.
+rsync -a \
+  --exclude='node_modules/' \
+  --exclude='package-lock.json' \
+  --exclude='.DS_Store' \
+  --exclude='eval/' \
+  --exclude='TESTING.md' \
+  --exclude='publish_clawhub.sh' \
+  --exclude='.clawhubignore' \
+  "$SRC"/ "$STAGE"/
+
+echo "generating top-level SKILL.md from skill/SKILL.md"
+python3 - "$STAGE" <<'PY'
+import re
+import sys
+from pathlib import Path
+
+stage = Path(sys.argv[1])
+src_skill = stage / "skill" / "SKILL.md"
+body = src_skill.read_text()
+
+m = re.match(r"^---\n(.*?)\n---\n(.*)$", body, re.DOTALL)
+if not m:
+    sys.exit(f"error: {src_skill} has no YAML frontmatter")
+orig_frontmatter, orig_body = m.group(1), m.group(2)
+
+# Pull the original description verbatim (multi-line safe).
+desc_match = re.search(
+    r'^description:\s*"((?:[^"\\]|\\.)*)"', orig_frontmatter, re.MULTILINE
+)
+if not desc_match:
+    sys.exit("error: could not find description in skill/SKILL.md frontmatter")
+description = desc_match.group(1)
+
+frontmatter = (
+    "---\n"
+    "name: reflexio\n"
+    f'description: "{description}"\n'
+    "metadata:\n"
+    "  openclaw:\n"
+    "    homepage: https://github.com/reflexio-ai/reflexio/tree/main/reflexio/integrations/openclaw\n"
+    "    emoji: 🧠\n"
+    "    requires:\n"
+    "      bins: [reflexio]\n"
+    "---\n"
+)
+
+privacy = """
+## Privacy & Data Collection — Read This First
+
+**This skill causes the agent to automatically capture conversations and
+forward them to a local Reflexio server for LLM-based extraction.** Read this
+before enabling — there are two distinct network hops and you need to
+understand both.
+
+### Credential requirement (not declared in skill metadata)
+
+The skill's registry metadata declares no required environment variables and
+the hook reads none. **But the end-to-end system does require an LLM provider
+API key**, and you WILL be asked for one during First-Use Setup.
+
+- Step 2 of First-Use Setup below runs `reflexio setup openclaw`, which opens
+  an **interactive wizard** prompting you to choose an LLM provider (OpenAI,
+  Anthropic, Gemini, DeepSeek, OpenRouter, and several others) and paste an
+  API key.
+- The key is stored in `~/.reflexio/.env` and read by the local Reflexio
+  server during extraction. **The hook itself never reads the key** (the hook
+  has no environment variable access and no filesystem config reads — both
+  enforced in `handler.js`).
+- If you want fully offline operation, point the wizard at a local LLM
+  (Ollama at `http://127.0.0.1:11434`, LM Studio, vLLM, etc.) instead of a
+  hosted provider — the wizard accepts any LiteLLM-compatible base URL.
+
+**Why the metadata doesn't declare it:** ClawHub's `metadata.openclaw.requires.env`
+describes environment variables the hook's own code path reads. The hook is
+deliberately stateless at the credential level, so listing anything there
+would be inaccurate. The dependency is at the *backend server* level, one
+hop away. This disclosure is here instead of in the metadata because prose
+is the right place to explain the distinction.
+
+### Network hops — two of them
+
+**Hop 1: the hook → the local Reflexio server (always localhost).**
+The hook is hard-pinned to `http://127.0.0.1:8081`. It communicates via native
+`fetch()` with no configuration knobs; the destination is a hardcoded constant
+in `handler.js`. It reads zero environment variables and zero configuration
+files. This hop cannot leave your machine.
+
+**Hop 2: the local Reflexio server → an LLM provider (may leave your
+machine).** The server uses an LLM provider (OpenAI, Anthropic, Gemini,
+DeepSeek, etc.) to extract playbooks and profiles from captured conversations.
+That provider is configured in `~/.reflexio/.env`. **If you configured an
+external provider, excerpts of your conversations will be sent to that
+provider** as part of extraction — trigger text, sample content, and enough
+context for the extractor to produce a useful summary. The primary full
+conversation text stays in your local SQLite database at `~/.reflexio/`, but
+the extracted summaries and illustrative excerpts traverse whatever the LLM
+provider's network path is.
+
+**If you want fully offline operation**, configure the local server to use a
+local LLM (Ollama, LM Studio, vLLM, etc.) before enabling this skill. Do not
+rely on the hook's localhost pinning as a privacy guarantee for the system as
+a whole — that only bounds the hook, not the server behind it.
+
+**What is captured:** full user and assistant messages; every tool call, input,
+and output (including failed tool calls and exact error strings); self-correction
+text from the assistant's own output. None of this is scrubbed for PII,
+credentials, file paths, or API outputs. If you work on sensitive tasks,
+disable the hook before starting them, or tell the agent mid-task.
+
+**How to disable:**
+
+- Per-session, stop automatic capture: `openclaw hooks disable reflexio-context`
+- Remove the integration entirely: `reflexio setup openclaw --uninstall`
+- Search-only mode (keep retrieval, drop auto-publish): edit `hook/handler.js`,
+  remove the `command:stop` handler, and reinstall
+- Sensitive task: tell the agent "don't log this" — the workspace rule instructs
+  it to stop all capture and search calls for the rest of the session
+
+**Transparency contract:** the agent is instructed to tell you Reflexio is
+active on the first turn of each session, disclose what is captured AND
+mention that the local server may forward excerpts to an LLM provider, and
+honor session-level opt-outs. This is enforced by
+`~/.openclaw/workspace/reflexio.md`. Edit that file if your deployment needs
+different rules (require explicit approval before every publish, offline-only,
+etc).
+
+Full data-handling details live in the **Privacy & Data Collection** section
+further down in this SKILL.md.
+
+---
+
+"""
+
+first_use = """
+## First-Use Setup
+
+Run these commands the first time this skill is invoked. They are idempotent —
+skip if `reflexio` is already on PATH, the local Reflexio server is responding
+at `http://127.0.0.1:8081/health`, and `openclaw hooks list` shows
+`reflexio-context` as `ready`. **Only run them after reading the privacy
+disclosure above, and be aware that step 2 is interactive — it will prompt
+you to pick an LLM provider and paste an API key for the local server's
+extraction pipeline.**
+
+```bash
+# 1. Install the reflexio CLI (pipx preferred; pip as fallback).
+command -v reflexio >/dev/null 2>&1 \\
+  || pipx install reflexio-ai 2>/dev/null \\
+  || pip install --user reflexio-ai
+
+# 2. INTERACTIVE: activates the hook, slash commands, and workspace rule in
+# OpenClaw. Also prompts you to choose an LLM provider and paste an API key,
+# which gets written to ~/.reflexio/.env. That key is what the local server
+# uses to extract playbooks from captured conversations. Point at a local LLM
+# (Ollama / LM Studio / vLLM) here if you want fully offline operation.
+# Before running this, tell the user what will be asked and why.
+reflexio setup openclaw
+
+# 3. Start the local Reflexio backend in the background. The hook talks to
+# this server via HTTP on 127.0.0.1:8081 — it will NOT start the server for
+# you. Tell the user you are doing this before running it.
+curl -sf --max-time 2 http://127.0.0.1:8081/health >/dev/null 2>&1 \\
+  || (nohup reflexio services start --only backend --no-reload \\
+        >> ~/.reflexio/logs/server.log 2>&1 & \\
+      sleep 5)
+```
+
+This installs:
+
+- `reflexio-context` hook — HTTP-only capture + per-message playbook
+  injection (communicates only with `http://127.0.0.1:8081`)
+- `/reflexio-extract` slash command — publish session learnings mid-session
+- `/reflexio-aggregate` slash command — consolidate user playbooks into
+  shared agent playbooks
+- `~/.openclaw/workspace/reflexio.md` — always-active behavioral rule
+  (transparency + opt-out handling)
+
+If the local server is unreachable, the hook logs the error and the agent
+continues the user's task without Reflexio context that session.
+
+---
+
+"""
+
+(stage / "SKILL.md").write_text(frontmatter + privacy + first_use + orig_body)
+print(f"wrote {stage / 'SKILL.md'}")
+PY
+
+if (( STAGE_ONLY == 1 )); then
+  cat <<EOF
+
+─────────────────────────────────────────────────────────────
+Stage ready. Upload via web at https://clawhub.ai/publish-skill
+
+Drag this folder onto the drop zone:
+  $STAGE
+
+Form values to use:
+  Slug:        reflexio
+  Display name: Reflexio
+  Version:     <pick a semver, e.g. 1.0.0>
+  Tags:        latest
+  Changelog:   Initial release
+
+When done, delete the temp folder: rm -rf $STAGE
+─────────────────────────────────────────────────────────────
+EOF
+  exit 0
+fi
+
+echo "publishing to clawhub: slug=reflexio version=$VERSION"
+(
+  cd "$STAGE"
+  bun clawhub skill publish . \
+    --slug reflexio \
+    --version "$VERSION" \
+    --tags latest \
+    --changelog "$CHANGELOG"
+)
+
+echo "done. verify at https://clawhub.ai/skill/reflexio"

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/references/HOOK.md

@@ -0,0 +1,164 @@
+---
+name: reflexio-federated-plugin
+description: "Automatically capture conversations and inject cross-session context before every response"
+metadata:
+  openclaw:
+    emoji: "🧠"
+    hooks: ["before_prompt_build", "message_sent", "before_compaction", "before_reset", "session_end"]
+    requires:
+      bins: ["reflexio"]
+      env: ["REFLEXIO_USER_ID", "REFLEXIO_AGENT_VERSION"]
+---
+
+# Reflexio Federated Plugin
+
+The plugin is the core component that enables automatic conversation capture and cross-session context injection. It is implemented against the **Openclaw Plugin SDK** (`openclaw/plugin-sdk`) and runs on every agent session, persisting data to a local SQLite buffer.
+
+## Plugin SDK Hooks
+
+The plugin registers the following hooks via `api.on(...)` in the Plugin SDK:
+
+### `before_prompt_build` (before each response)
+
+Fires before the agent builds its next response. This is the primary hook — it handles:
+
+1. **First-use setup check** — detects whether the `reflexio` CLI is installed and configured. If setup is needed, injects a setup instruction into the system context.
+2. **Server auto-start** — checks if the local Reflexio server is healthy via a health check; if not, spawns `reflexio services start --only backend` in the background.
+3. **Retry unpublished turns** — publishes any buffered turns from previous sessions that failed to reach the server.
+4. **Search injection** — runs `reflexio search` on the user's message and, if results are found, prepends them as system context before the agent responds. Skips search for trivial/short inputs to reduce noise. Times out after `search.timeout_ms` (default: 5 000 ms) — never blocks the response.
+
+### `message_sent` (each turn)
+
+Fires after the agent sends a response. Buffers the (user message, agent response) pair into local SQLite at `~/.reflexio/sessions.db`. Lightweight local write — no network calls. If the buffer exceeds `publish.batch_size * 2` unpublished turns, triggers an incremental publish to the server.
+
+### `before_compaction` (before transcript compaction)
+
+Fires before Openclaw compacts the transcript. Flushes all unpublished buffered turns to the Reflexio server so no data is lost when the compaction discards history.
+
+### `before_reset` (before transcript wipe)
+
+Fires before Openclaw wipes the transcript (e.g., `/reset`). Same as `before_compaction` — flushes all remaining unpublished turns.
+
+### `session_end` (session end)
+
+Fires when the session ends. Performs a final flush of all remaining buffered turns to the Reflexio server.
+
+## Tool: `reflexio_publish`
+
+In addition to hooks, the plugin registers one agent-invocable tool:
+
+- **`reflexio_publish`** — immediately flushes all buffered conversation turns to the Reflexio server. Useful after user corrections or high-signal moments when automatic session-end flushing would be too late.
+
+> **Single-session limitation:** The `execute` callback in the Plugin SDK does not receive session context, so this tool always targets the most recently active session. Concurrent multi-session use is not supported.
+
+## Prerequisites
+
+1. **`reflexio` CLI on PATH** — `pipx install reflexio-ai` or `pip install --user reflexio-ai`. The plugin shells out to this CLI to start the backend server and publish conversations.
+
+2. **Node.js 18+** — Required to run the plugin.
+
+3. **An LLM provider API key in `~/.reflexio/.env`** — Required for the backend server to extract playbooks and profiles. The first-use setup wizard prompts you to configure this on the first agent session.
+
+## Configuration
+
+All settings are optional and defined in `plugin/openclaw.plugin.json` under the `configSchema`:
+
+### `publish` — Conversation capture and publish behavior
+
+```json
+"publish": {
+  "batch_size": 10,           // Number of turns to buffer before mid-session publish
+  "max_retries": 3,           // Retry count for failed publish attempts
+  "max_content_length": 10000 // Max characters per turn (prevents oversized payloads)
+}
+```
+
+### `search` — Context injection before each response
+
+```json
+"search": {
+  "timeout_ms": 5000,         // Max time to wait for search results
+  "top_k": 5,                 // Number of playbooks to return per search
+  "min_prompt_length": 5      // Skip search for inputs shorter than this
+}
+```
+
+### `server` — Reflexio server health and startup
+
+```json
+"server": {
+  "health_check_timeout_ms": 3000,  // Time limit for health checks
+  "stale_flag_ms": 120000           // Flag file age before retry (2 minutes)
+}
+```
+
+## Security and Privacy
+
+### What the plugin reads
+
+- **Environment variables**: `REFLEXIO_USER_ID` (overrides auto-derived user ID) and `REFLEXIO_AGENT_VERSION` (overrides agent version label). Both are optional.
+- **`~/.openclaw/openclaw.json`**: read by the Openclaw host process to load the plugin; the plugin itself does not read this file directly.
+- **`~/.reflexio/.env`**: read to resolve `REFLEXIO_URL` if the env var is not set in the process environment.
+
+### What the plugin shells out to
+
+The plugin spawns the `reflexio` CLI for:
+- `reflexio services start --only backend` — starts the local server if not running
+- `reflexio search <query>` — fetches context from the local server
+- `reflexio interactions publish --file <payload.json>` — publishes buffered turns
+
+All spawned processes use the binary on your `PATH`. If `reflexio` is not found, the `error` event on the child process is caught, the affected turns are marked for retry, and the plugin continues working without blocking the agent.
+
+### Network destinations
+
+The plugin communicates only with the Reflexio server at the URL resolved from `REFLEXIO_URL` / `~/.reflexio/.env` / default `http://127.0.0.1:8081`. Local-server detection uses exact hostname matching (`127.0.0.1` or `localhost`); only local servers are auto-started.
+
+**The local Reflexio server makes outbound LLM API calls** for profile/playbook extraction. The destination depends on your `~/.reflexio/.env` configuration (OpenAI, Anthropic, Gemini, or a local LLM). For a fully offline setup, configure a local LLM provider (Ollama, LM Studio, vLLM) during first-use setup.
+
+## Buffering and Retry
+
+The plugin uses SQLite to buffer conversations locally:
+
+- **Location**: `~/.reflexio/sessions.db`
+- **Retention**: Buffered turns are kept until successfully published to the server
+- **Retry logic**: On every `before_prompt_build`, the plugin retries any unpublished sessions from previous runs (up to `max_retries`)
+- **Graceful degradation**: If the server is down, the agent works normally and buffers persist
+
+## Lifecycle Summary
+
+| Hook | Trigger | Actions |
+|------|---------|---------|
+| `before_prompt_build` | Before each agent response | Setup check, server auto-start, retry old sessions, search injection |
+| `message_sent` | After each agent response | Buffer turn to SQLite, incremental publish if batch threshold exceeded |
+| `before_compaction` | Before transcript compaction | Flush all unpublished turns |
+| `before_reset` | Before transcript wipe | Flush all unpublished turns |
+| `session_end` | Session ends | Final flush of all remaining turns |
+
+## Implementation
+
+The plugin is implemented in TypeScript in `plugin/`:
+
+- **`index.ts`** — SDK wiring: `definePluginEntry`, hook registration, tool registration
+- **`hook/handler.ts`** — Core logic: `handleBeforePromptBuild`, `handleMessageSent`, `handleSessionFlush`, `handleToolPublish`
+- **`hook/setup.ts`** — First-use setup: CLI detection, LLM provider prompt, server start
+
+Supporting libraries in `plugin/lib/`:
+
+- **`server.ts`** — URL resolution, health check, auto-start
+- **`user-id.ts`** — User identity and agent version resolution from env vars / session key
+- **`sqlite-buffer.ts`** — Turn buffering, retry management
+- **`publish.ts`** — Payload construction, CLI spawn with error handling
+- **`search.ts`** — Search invocation, result formatting, trivial-input filtering
+
+## Debugging
+
+All plugin log lines are prefixed with `[reflexio]` for easy filtering:
+
+```bash
+# Option A: capture stderr to file and tail it
+openclaw chat 2>reflexio-plugin.log
+tail -f reflexio-plugin.log | grep "\[reflexio\]"
+
+# Option B: watch inline
+openclaw chat 2>&1 | grep "\[reflexio\]"
+```

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/scripts/install.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# reflexio-federated install.sh — plugin installation.
+set -euo pipefail
+
+PLUGIN_DIR="$(cd "$(dirname "$0")/../plugin" && pwd)"
+OPENCLAW_HOME="${OPENCLAW_HOME:-$HOME/.openclaw}"
+
+die() { echo "error: $*" >&2; exit 1; }
+info() { echo "==> $*"; }
+
+# 1. Prereq checks
+info "Checking prerequisites..."
+command -v openclaw >/dev/null || die "openclaw CLI required but not found on PATH"
+command -v node >/dev/null     || die "node required but not found on PATH"
+
+# 2. Install the plugin
+info "Installing plugin..."
+openclaw plugins uninstall --force reflexio-federated 2>/dev/null || true
+rm -rf "$OPENCLAW_HOME/extensions/reflexio-federated"
+openclaw plugins install "$PLUGIN_DIR"
+openclaw plugins enable reflexio-federated 2>/dev/null || true
+
+# 3. Restart gateway
+info "Restarting openclaw gateway..."
+openclaw gateway restart
+
+# 4. Verify
+info "Verification:"
+if openclaw plugins inspect reflexio-federated 2>/dev/null | grep -q "Status: loaded"; then
+  info "  ✓ plugin registered and loaded"
+else
+  die "Plugin did not reach 'loaded' status. Run 'openclaw plugins inspect reflexio-federated' to debug."
+fi
+
+info "Installation complete."
+info "Reflexio setup (CLI install, storage config, server start) happens automatically on first agent session."

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/scripts/uninstall.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# reflexio-federated uninstall.sh — reverses install.sh.
+# Leaves ~/.reflexio/ user data intact unless --purge is passed.
+set -euo pipefail
+
+OPENCLAW_HOME="${OPENCLAW_HOME:-$HOME/.openclaw}"
+PURGE_DATA="${1:-}"
+
+info() { echo "==> $*"; }
+
+info "Disabling plugin..."
+openclaw plugins disable reflexio-federated 2>/dev/null || echo "(already disabled)"
+
+info "Uninstalling plugin..."
+openclaw plugins uninstall --force reflexio-federated 2>/dev/null || echo "(already uninstalled)"
+rm -rf "$OPENCLAW_HOME/extensions/reflexio-federated"
+
+info "Cleaning up state files..."
+rm -f "$HOME/.reflexio/sessions.db"
+rm -f "$HOME/.reflexio/logs/.server-starting"
+
+# Remove setup markers
+find "$HOME/.reflexio/" -name ".setup_complete_*" -delete 2>/dev/null || true
+
+if [[ "$PURGE_DATA" == "--purge" ]]; then
+  info "Purging ~/.reflexio/ user data per --purge flag..."
+  rm -rf "$HOME/.reflexio"
+else
+  info "User data at ~/.reflexio/ preserved. Use --purge to delete it too."
+fi
+
+info "Restarting openclaw gateway..."
+openclaw gateway restart || echo "warning: gateway restart failed — you may need to restart manually"
+
+info "Uninstall complete."

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/tests/publish.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from "vitest";
+import { buildPayload } from "../plugin/lib/publish.ts";
+import type { Turn } from "../plugin/lib/sqlite-buffer.ts";
+
+describe("buildPayload", () => {
+  it("builds correct JSON structure", () => {
+    const turns: Turn[] = [
+      { id: 1, session_id: "s1", role: "user", content: "hello", timestamp: "2026-01-01T00:00:00Z", published: 0, retry_count: 0 },
+      { id: 2, session_id: "s1", role: "assistant", content: "hi", timestamp: "2026-01-01T00:00:01Z", published: 0, retry_count: 0 },
+    ];
+    const payload = buildPayload(turns, "user1", "openclaw-agent", "sess1");
+    const parsed = JSON.parse(payload);
+    expect(parsed.user_id).toBe("user1");
+    expect(parsed.source).toBe("openclaw");
+    expect(parsed.agent_version).toBe("openclaw-agent");
+    expect(parsed.session_id).toBe("sess1");
+    expect(parsed.interactions).toHaveLength(2);
+    expect(parsed.interactions[0].role).toBe("user");
+    expect(parsed.interactions[0].content).toBe("hello");
+  });
+
+  it("returns empty interactions for empty turns", () => {
+    const payload = buildPayload([], "user1", "openclaw-agent", "sess1");
+    const parsed = JSON.parse(payload);
+    expect(parsed.interactions).toHaveLength(0);
+  });
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/tests/search.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "vitest";
+import { shouldSkipSearch, formatSearchContext } from "../plugin/lib/search.ts";
+
+describe("shouldSkipSearch", () => {
+  it("skips short messages", () => {
+    expect(shouldSkipSearch("hi", 5)).toBe(true);
+  });
+
+  it("skips trivial responses", () => {
+    expect(shouldSkipSearch("yes", 5)).toBe(true);
+    expect(shouldSkipSearch("ok", 5)).toBe(true);
+    expect(shouldSkipSearch("thanks", 5)).toBe(true);
+    expect(shouldSkipSearch("Sure", 5)).toBe(true);
+  });
+
+  it("does not skip real messages", () => {
+    expect(shouldSkipSearch("Write a Python function to sort a list", 5)).toBe(false);
+  });
+});
+
+describe("formatSearchContext", () => {
+  it("returns null for empty results", () => {
+    expect(formatSearchContext("")).toBeNull();
+    expect(formatSearchContext("Found 0 profiles, 0 playbooks")).toBeNull();
+  });
+
+  it("returns trimmed content for real results", () => {
+    const result = formatSearchContext("## Playbooks\n- Use type hints");
+    expect(result).toBe("## Playbooks\n- Use type hints");
+  });
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/tests/server.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { resolveServerUrl, isLocalServer } from "../plugin/lib/server.ts";
+
+describe("resolveServerUrl", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it("returns REFLEXIO_URL env var when set", () => {
+    process.env.REFLEXIO_URL = "https://custom.server:9090";
+    expect(resolveServerUrl()).toBe("https://custom.server:9090");
+  });
+
+  it("returns default when no env var and no .env file", () => {
+    delete process.env.REFLEXIO_URL;
+    expect(resolveServerUrl()).toBe("http://127.0.0.1:8081");
+  });
+});
+
+describe("isLocalServer", () => {
+  it("returns true for localhost", () => {
+    expect(isLocalServer("http://localhost:8081")).toBe(true);
+  });
+
+  it("returns true for 127.0.0.1", () => {
+    expect(isLocalServer("http://127.0.0.1:8081")).toBe(true);
+  });
+
+  it("returns false for remote URL", () => {
+    expect(isLocalServer("https://reflexio.ai:8081")).toBe(false);
+  });
+
+  it("returns false for localhost.evil.com", () => {
+    expect(isLocalServer("https://localhost.evil.com")).toBe(false);
+  });
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/tests/setup.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  isSetupComplete,
+  markSetupComplete,
+  checkReflexioInstalled,
+  checkReflexioConfigured,
+} from "../plugin/hook/setup.ts";
+
+describe("isSetupComplete", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "reflexio-setup-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns false when marker does not exist", () => {
+    expect(isSetupComplete(tmpDir, "main")).toBe(false);
+  });
+
+  it("returns true after markSetupComplete", () => {
+    markSetupComplete(tmpDir, "main");
+    expect(isSetupComplete(tmpDir, "main")).toBe(true);
+  });
+
+  it("is per-agent", () => {
+    markSetupComplete(tmpDir, "main");
+    expect(isSetupComplete(tmpDir, "work")).toBe(false);
+  });
+});
+
+describe("checkReflexioInstalled", () => {
+  it("returns a boolean", async () => {
+    const result = await checkReflexioInstalled();
+    expect(typeof result).toBe("boolean");
+  });
+});
+
+describe("checkReflexioConfigured", () => {
+  it("returns false for nonexistent directory", () => {
+    expect(checkReflexioConfigured("/tmp/nonexistent-reflexio-dir-" + Date.now())).toBe(false);
+  });
+});