@karmaniverous/jeeves-watcher-openclaw 0.2.0 → 0.3.1

package/README.md

@@ -38,7 +38,7 @@ Set the `apiUrl` in the plugin configuration to point at your jeeves-watcher ser
 
 ```json
 {
-  "apiUrl": "http://localhost:3000"
+  "apiUrl": "http://127.0.0.1:3458"
 }
 ```
 
@@ -54,6 +54,8 @@ Set the `apiUrl` in the plugin configuration to point at your jeeves-watcher ser
 | `watcher_config_apply` | Apply a new configuration |
 | `watcher_reindex` | Trigger a full reindex |
 | `watcher_issues` | List indexing issues and errors |
+| `memory_search` | Semantically search memory files (MEMORY.md and memory/*.md) |
+| `memory_get` | Read content from memory files with optional line range |
 
 ## Documentation
 

package/dist/cli.js

@@ -22,15 +22,12 @@ import { fileURLToPath } from 'url';
 const PLUGIN_ID = 'jeeves-watcher-openclaw';
 /** Resolve the OpenClaw home directory. */
 function resolveOpenClawHome() {
-    // 1. OPENCLAW_CONFIG points directly to the config file
     if (process.env.OPENCLAW_CONFIG) {
         return dirname(resolve(process.env.OPENCLAW_CONFIG));
     }
-    // 2. OPENCLAW_HOME points to the .openclaw directory
     if (process.env.OPENCLAW_HOME) {
         return resolve(process.env.OPENCLAW_HOME);
     }
-    // 3. Default location
     return join(homedir(), '.openclaw');
 }
 /** Resolve the config file path. */
@@ -43,8 +40,6 @@ function resolveConfigPath(home) {
 /** Get the package root (where this CLI lives). */
 function getPackageRoot() {
     const thisFile = fileURLToPath(import.meta.url);
-    // In dist: dist/cli.js → package root is ..
-    // In src: src/cli.ts → package root is ..
     return resolve(dirname(thisFile), '..');
 }
 /** Read and parse JSON, returning null on failure. */
@@ -60,6 +55,79 @@ function readJson(path) {
 function writeJson(path, data) {
     writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
 }
+/**
+ * Patch an allowlist array: add or remove the plugin ID.
+ * Returns a log message if a change was made, or undefined.
+ */
+function patchAllowList(parent, key, label, mode) {
+    if (!Array.isArray(parent[key]) || parent[key].length === 0)
+        return undefined;
+    const list = parent[key];
+    if (mode === 'add') {
+        if (!list.includes(PLUGIN_ID)) {
+            list.push(PLUGIN_ID);
+            return `Added "${PLUGIN_ID}" to ${label}`;
+        }
+    }
+    else {
+        const filtered = list.filter((id) => id !== PLUGIN_ID);
+        if (filtered.length !== list.length) {
+            parent[key] = filtered;
+            return `Removed "${PLUGIN_ID}" from ${label}`;
+        }
+    }
+    return undefined;
+}
+/** Patch OpenClaw config for install or uninstall. Returns log messages. */
+function patchConfig(config, mode) {
+    const messages = [];
+    // Ensure plugins section
+    if (!config.plugins || typeof config.plugins !== 'object') {
+        config.plugins = {};
+    }
+    const plugins = config.plugins;
+    // plugins.allow
+    const pluginAllow = patchAllowList(plugins, 'allow', 'plugins.allow', mode);
+    if (pluginAllow)
+        messages.push(pluginAllow);
+    // plugins.entries
+    if (!plugins.entries || typeof plugins.entries !== 'object') {
+        plugins.entries = {};
+    }
+    const entries = plugins.entries;
+    if (mode === 'add') {
+        if (!entries[PLUGIN_ID]) {
+            entries[PLUGIN_ID] = { enabled: true };
+            messages.push(`Added "${PLUGIN_ID}" to plugins.entries`);
+        }
+    }
+    else if (PLUGIN_ID in entries) {
+        Reflect.deleteProperty(entries, PLUGIN_ID);
+        messages.push(`Removed "${PLUGIN_ID}" from plugins.entries`);
+    }
+    // plugins.slots — claim or release the memory slot
+    if (!plugins.slots || typeof plugins.slots !== 'object') {
+        plugins.slots = {};
+    }
+    const slots = plugins.slots;
+    if (mode === 'add') {
+        const prev = slots.memory;
+        slots.memory = PLUGIN_ID;
+        if (prev !== PLUGIN_ID) {
+            messages.push(`Set plugins.slots.memory to "${PLUGIN_ID}"${prev ? ` (was "${prev}")` : ''}`);
+        }
+    }
+    else if (slots.memory === PLUGIN_ID) {
+        slots.memory = 'memory-core';
+        messages.push(`Reverted plugins.slots.memory to "memory-core"`);
+    }
+    // tools.allow
+    const tools = (config.tools ?? {});
+    const toolAllow = patchAllowList(tools, 'allow', 'tools.allow', mode);
+    if (toolAllow)
+        messages.push(toolAllow);
+    return messages;
+}
 /** Install the plugin into OpenClaw's extensions directory. */
 function install() {
     const home = resolveOpenClawHome();
@@ -71,19 +139,16 @@ function install() {
     console.log(`Extensions dir: ${extDir}`);
     console.log(`Package root:   ${pkgRoot}`);
     console.log();
-    // Validate OpenClaw home exists
     if (!existsSync(home)) {
         console.error(`Error: OpenClaw home directory not found at ${home}`);
         console.error('Set OPENCLAW_HOME or OPENCLAW_CONFIG if using a non-default installation.');
         process.exit(1);
     }
-    // Validate config exists
     if (!existsSync(configPath)) {
         console.error(`Error: OpenClaw config not found at ${configPath}`);
         console.error('Set OPENCLAW_CONFIG if using a non-default config location.');
         process.exit(1);
     }
-    // Validate package root has openclaw.plugin.json
     const pluginManifestPath = join(pkgRoot, 'openclaw.plugin.json');
     if (!existsSync(pluginManifestPath)) {
         console.error(`Error: openclaw.plugin.json not found at ${pluginManifestPath}`);
@@ -95,9 +160,7 @@ function install() {
         rmSync(extDir, { recursive: true, force: true });
     }
     mkdirSync(extDir, { recursive: true });
-    // Copy dist/, openclaw.plugin.json, package.json
-    const filesToCopy = ['dist', 'openclaw.plugin.json', 'package.json'];
-    for (const file of filesToCopy) {
+    for (const file of ['dist', 'openclaw.plugin.json', 'package.json']) {
         const src = join(pkgRoot, file);
         const dest = join(extDir, file);
         if (existsSync(src)) {
@@ -105,13 +168,12 @@ function install() {
             console.log(`  ✓ ${file}`);
         }
     }
-    // Copy node_modules if present (for runtime dependencies)
     const nodeModulesSrc = join(pkgRoot, 'node_modules');
     if (existsSync(nodeModulesSrc)) {
         cpSync(nodeModulesSrc, join(extDir, 'node_modules'), { recursive: true });
         console.log('  ✓ node_modules');
     }
-    // Patch OpenClaw config
+    // Patch config
     console.log();
     console.log('Patching OpenClaw config...');
     const config = readJson(configPath);
@@ -119,36 +181,8 @@ function install() {
         console.error(`Error: Could not parse ${configPath}`);
         process.exit(1);
     }
-    // Ensure plugins section exists
-    if (!config.plugins || typeof config.plugins !== 'object') {
-        config.plugins = {};
-    }
-    const plugins = config.plugins;
-    // If plugins.allow exists and is populated, add ourselves to it
-    if (Array.isArray(plugins.allow) && plugins.allow.length > 0) {
-        const allow = plugins.allow;
-        if (!allow.includes(PLUGIN_ID)) {
-            allow.push(PLUGIN_ID);
-            console.log(`  ✓ Added "${PLUGIN_ID}" to plugins.allow`);
-        }
-    }
-    // Add to plugins.entries
-    if (!plugins.entries || typeof plugins.entries !== 'object') {
-        plugins.entries = {};
-    }
-    const entries = plugins.entries;
-    if (!entries[PLUGIN_ID]) {
-        entries[PLUGIN_ID] = { enabled: true };
-        console.log(`  ✓ Added "${PLUGIN_ID}" to plugins.entries`);
-    }
-    // If tools.allow exists and is populated, add ourselves to it
-    const tools = (config.tools ?? {});
-    if (Array.isArray(tools.allow) && tools.allow.length > 0) {
-        const toolsAllow = tools.allow;
-        if (!toolsAllow.includes(PLUGIN_ID)) {
-            toolsAllow.push(PLUGIN_ID);
-            console.log(`  ✓ Added "${PLUGIN_ID}" to tools.allow`);
-        }
+    for (const msg of patchConfig(config, 'add')) {
+        console.log(`  ✓ ${msg}`);
     }
     writeJson(configPath, config);
     console.log();
@@ -164,7 +198,6 @@ function uninstall() {
     console.log(`Config:         ${configPath}`);
     console.log(`Extensions dir: ${extDir}`);
     console.log();
-    // Remove extensions directory
     if (existsSync(extDir)) {
         rmSync(extDir, { recursive: true, force: true });
         console.log(`✓ Removed ${extDir}`);
@@ -172,30 +205,12 @@ function uninstall() {
     else {
         console.log(`  (extensions directory not found, skipping)`);
     }
-    // Patch OpenClaw config
     if (existsSync(configPath)) {
         console.log('Patching OpenClaw config...');
         const config = readJson(configPath);
         if (config) {
-            const plugins = (config.plugins ?? {});
-            // Remove from plugins.allow if it exists and is populated
-            if (Array.isArray(plugins.allow) && plugins.allow.length > 0) {
-                plugins.allow = plugins.allow.filter((id) => id !== PLUGIN_ID);
-                console.log(`  ✓ Removed "${PLUGIN_ID}" from plugins.allow`);
-            }
-            // Remove from plugins.entries
-            if (plugins.entries && typeof plugins.entries === 'object') {
-                const entries = plugins.entries;
-                if (PLUGIN_ID in entries) {
-                    Reflect.deleteProperty(entries, PLUGIN_ID);
-                    console.log(`  ✓ Removed "${PLUGIN_ID}" from plugins.entries`);
-                }
-            }
-            // Remove from tools.allow if it exists and is populated
-            const tools = (config.tools ?? {});
-            if (Array.isArray(tools.allow) && tools.allow.length > 0) {
-                tools.allow = tools.allow.filter((id) => id !== PLUGIN_ID);
-                console.log(`  ✓ Removed "${PLUGIN_ID}" from tools.allow`);
+            for (const msg of patchConfig(config, 'remove')) {
+                console.log(`  ✓ ${msg}`);
             }
             writeJson(configPath, config);
         }
@@ -234,3 +249,5 @@ switch (command) {
         }
         break;
 }
+
+export { patchConfig };

package/dist/index.js

@@ -1,8 +1,31 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+
 /**
  * @module plugin/helpers
  * Shared types and utility functions for the OpenClaw plugin tool registrations.
  */
 const DEFAULT_API_URL = 'http://127.0.0.1:3458';
+/** Source identifier for virtual rule registration. */
+const PLUGIN_SOURCE = 'jeeves-watcher-openclaw';
+/** Normalize a path to forward slashes and lowercase drive letter on Windows. */
+function normalizePath(p) {
+    let result = p.replace(/\\/g, '/');
+    if (/^[A-Z]:/.test(result)) {
+        result = result[0].toLowerCase() + result.slice(1);
+    }
+    return result;
+}
+/**
+ * Resolve the workspace path from gateway config.
+ * Priority: agent-specific > defaults > fallback (~/.openclaw/workspace).
+ */
+function getWorkspacePath(api) {
+    const agentWorkspace = api.config?.agents?.entries?.['main']?.workspace ??
+        api.config?.agents?.defaults?.workspace;
+    return agentWorkspace ?? join(homedir(), '.openclaw', 'workspace');
+}
 /** Resolve the watcher API base URL from plugin config. */
 function getApiUrl(api) {
     const url = api.config?.plugins?.entries?.['jeeves-watcher']?.config?.apiUrl;
@@ -54,238 +77,414 @@ async function fetchJson(url, init) {
     }
     return res.json();
 }
+/** POST JSON to a URL and return parsed response. */
+async function postJson(url, body) {
+    return fetchJson(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+}
 
 /**
- * @module plugin
- * OpenClaw plugin entry point. Registers all jeeves-watcher tools.
+ * @module plugin/memoryTools
+ * memory_search and memory_get tool implementations with lazy init.
+ *
+ * Lazy init registers virtual inference rules with the watcher on first
+ * memory_search call. Re-attempts on failure. memory_get reads files
+ * directly from the filesystem with path validation.
  */
-/** Register all jeeves-watcher tools with the OpenClaw plugin API. */
-function register(api) {
-    const baseUrl = getApiUrl(api);
-    api.registerTool({
-        name: 'watcher_status',
-        description: 'Get jeeves-watcher service health, uptime, and collection statistics.',
-        parameters: { type: 'object', properties: {} },
-        execute: async () => {
-            try {
-                return ok(await fetchJson(`${baseUrl}/status`));
-            }
-            catch (error) {
-                return connectionFail(error, baseUrl);
-            }
-        },
-    }, { optional: true });
-    api.registerTool({
-        name: 'watcher_search',
-        description: 'Semantic search over indexed documents. Supports Qdrant filters.',
-        parameters: {
-            type: 'object',
-            required: ['query'],
-            properties: {
-                query: { type: 'string', description: 'Search query text.' },
-                limit: {
-                    type: 'number',
-                    description: 'Max results (default 10).',
+/** Build virtual inference rules for a workspace path. */
+function buildVirtualRules(workspace) {
+    const ws = normalizePath(workspace);
+    return [
+        {
+            name: 'openclaw-memory-longterm',
+            description: 'OpenClaw long-term memory file',
+            match: {
+                type: 'object',
+                properties: {
+                    file: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string', pattern: `^${ws}/MEMORY\\.md$` },
+                        },
+                    },
                 },
-                offset: {
-                    type: 'number',
-                    description: 'Number of results to skip for pagination.',
-                },
-                filter: {
+            },
+            schema: [
+                {
                     type: 'object',
-                    description: 'Qdrant filter object.',
+                    properties: {
+                        domain: { type: 'string', set: 'memory' },
+                        kind: { type: 'string', set: 'long-term' },
+                    },
                 },
-            },
-        },
-        execute: async (_id, params) => {
-            try {
-                const body = { query: params.query };
-                if (params.limit !== undefined)
-                    body.limit = params.limit;
-                if (params.offset !== undefined)
-                    body.offset = params.offset;
-                if (params.filter !== undefined)
-                    body.filter = params.filter;
-                return ok(await fetchJson(`${baseUrl}/search`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body),
-                }));
-            }
-            catch (error) {
-                return connectionFail(error, baseUrl);
-            }
+            ],
         },
-    }, { optional: true });
-    api.registerTool({
-        name: 'watcher_enrich',
-        description: 'Set or update metadata on a document by file path.',
-        parameters: {
-            type: 'object',
-            required: ['path', 'metadata'],
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Relative file path of the document.',
+        {
+            name: 'openclaw-memory-daily',
+            description: 'OpenClaw daily memory logs',
+            match: {
+                type: 'object',
+                properties: {
+                    file: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string', pattern: `^${ws}/memory/.*\\.md$` },
+                        },
+                    },
                 },
-                metadata: {
+            },
+            schema: [
+                {
                     type: 'object',
-                    description: 'Key-value metadata to set on the document.',
+                    properties: {
+                        domain: { type: 'string', set: 'memory' },
+                        kind: { type: 'string', set: 'daily-log' },
+                    },
                 },
-            },
+            ],
         },
+    ];
+}
+/** Validate a path is within the memory scope. */
+function isAllowedMemoryPath(filePath, workspace) {
+    const norm = normalizePath(filePath).toLowerCase();
+    const ws = normalizePath(workspace).toLowerCase();
+    // Exact match: {workspace}/MEMORY.md
+    if (norm === `${ws}/memory.md`)
+        return true;
+    // Prefix match: {workspace}/memory/**/*.md
+    if (norm.startsWith(`${ws}/memory/`) && norm.endsWith('.md'))
+        return true;
+    return false;
+}
+/**
+ * Create memory tool registrations for the plugin.
+ * Returns register functions for memory_search and memory_get.
+ */
+function createMemoryTools(api, baseUrl) {
+    const workspace = getWorkspacePath(api);
+    const state = {
+        initialized: false,
+        workspace,
+        baseUrl,
+    };
+    /** Lazy init: register virtual rules with watcher. */
+    async function ensureInit() {
+        if (state.initialized)
+            return;
+        // Check watcher is reachable
+        await fetchJson(`${state.baseUrl}/status`);
+        // Clear any stale rules
+        await fetchJson(`${state.baseUrl}/rules/unregister`, {
+            method: 'DELETE',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ source: PLUGIN_SOURCE }),
+        });
+        // Register virtual rules
+        await postJson(`${state.baseUrl}/rules/register`, {
+            source: PLUGIN_SOURCE,
+            rules: buildVirtualRules(state.workspace),
+        });
+        state.initialized = true;
+    }
+    const memorySearch = async (_id, params) => {
+        try {
+            await ensureInit();
+            const body = {
+                query: params.query,
+                filter: {
+                    must: [{ key: 'domain', match: { value: 'memory' } }],
+                },
+            };
+            if (params.maxResults !== undefined)
+                body.limit = params.maxResults;
+            const raw = await postJson(`${state.baseUrl}/search`, body);
+            // Map results to system-prompt-compatible format
+            const results = raw.map((r) => {
+                const payload = r.payload;
+                const mapped = {
+                    path: payload.file_path,
+                    snippet: payload.chunk_text,
+                    score: r.score,
+                };
+                if (payload.line_start != null)
+                    mapped.from = payload.line_start;
+                if (payload.line_end != null)
+                    mapped.to = payload.line_end;
+                return mapped;
+            });
+            const minScore = typeof params.minScore === 'number' ? params.minScore : 0;
+            const filtered = results.filter((r) => typeof r.score === 'number' && r.score >= minScore);
+            return ok(filtered);
+        }
+        catch (error) {
+            state.initialized = false;
+            return connectionFail(error, state.baseUrl);
+        }
+    };
+    const memoryGet = async (_id, params) => {
+        try {
+            const filePath = String(params.path);
+            // Re-derive workspace on every call for immediate pickup of moves
+            const currentWorkspace = getWorkspacePath(api);
+            if (!isAllowedMemoryPath(filePath, currentWorkspace)) {
+                return fail(`Path not within memory scope. Allowed: ${currentWorkspace}/MEMORY.md and ${currentWorkspace}/memory/**/*.md`);
+            }
+            const content = await readFile(filePath, 'utf-8');
+            if (params.from !== undefined) {
+                const from = Number(params.from);
+                const lines = content.split('\n');
+                const startIdx = Math.max(0, from - 1); // 1-indexed to 0-indexed
+                const count = params.lines !== undefined
+                    ? Number(params.lines)
+                    : lines.length - startIdx;
+                const sliced = lines.slice(startIdx, startIdx + count);
+                return ok(sliced.join('\n'));
+            }
+            return ok(content);
+        }
+        catch (error) {
+            return fail(error);
+        }
+    };
+    return { memorySearch, memoryGet };
+}
+
+/**
+ * @module plugin/watcherTools
+ * Watcher tool registrations (watcher_* tools) for the OpenClaw plugin.
+ */
+/** Register a single API tool with standard try/catch + ok/connectionFail. */
+function registerApiTool(api, baseUrl, config) {
+    api.registerTool({
+        name: config.name,
+        description: config.description,
+        parameters: config.parameters,
         execute: async (_id, params) => {
             try {
-                return ok(await fetchJson(`${baseUrl}/metadata`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        path: params.path,
-                        metadata: params.metadata,
-                    }),
-                }));
+                const [endpoint, body] = config.buildRequest(params);
+                const url = `${baseUrl}${endpoint}`;
+                const data = body !== undefined
+                    ? await postJson(url, body)
+                    : await fetchJson(url);
+                return ok(data);
             }
             catch (error) {
                 return connectionFail(error, baseUrl);
             }
         },
     }, { optional: true });
-    api.registerTool({
-        name: 'watcher_query',
-        description: 'Query the merged virtual document via JSONPath.',
-        parameters: {
-            type: 'object',
-            required: ['path'],
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'JSONPath expression.',
+}
+/** Pick defined keys from params into a body object. */
+function pickDefined(params, keys) {
+    const body = {};
+    for (const key of keys) {
+        if (params[key] !== undefined)
+            body[key] = params[key];
+    }
+    return body;
+}
+/** Register all 8 watcher_* tools with the OpenClaw plugin API. */
+function registerWatcherTools(api, baseUrl) {
+    const tools = [
+        {
+            name: 'watcher_status',
+            description: 'Get jeeves-watcher service health, uptime, and collection statistics.',
+            parameters: { type: 'object', properties: {} },
+            buildRequest: () => ['/status'],
+        },
+        {
+            name: 'watcher_search',
+            description: 'Semantic search over indexed documents. Supports Qdrant filters.',
+            parameters: {
+                type: 'object',
+                required: ['query'],
+                properties: {
+                    query: { type: 'string', description: 'Search query text.' },
+                    limit: { type: 'number', description: 'Max results (default 10).' },
+                    offset: {
+                        type: 'number',
+                        description: 'Number of results to skip for pagination.',
+                    },
+                    filter: { type: 'object', description: 'Qdrant filter object.' },
                 },
-                resolve: {
-                    type: 'array',
-                    items: { type: 'string', enum: ['files', 'globals'] },
-                    description: 'Resolution scopes to include (e.g., ["files"], ["globals"], or both).',
+            },
+            buildRequest: (params) => {
+                const body = pickDefined(params, [
+                    'query',
+                    'limit',
+                    'offset',
+                    'filter',
+                ]);
+                return ['/search', body];
+            },
+        },
+        {
+            name: 'watcher_enrich',
+            description: 'Set or update metadata on a document by file path.',
+            parameters: {
+                type: 'object',
+                required: ['path', 'metadata'],
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative file path of the document.',
+                    },
+                    metadata: {
+                        type: 'object',
+                        description: 'Key-value metadata to set on the document.',
+                    },
                 },
             },
+            buildRequest: (params) => [
+                '/metadata',
+                { path: params.path, metadata: params.metadata },
+            ],
         },
-        execute: async (_id, params) => {
-            try {
-                const body = { path: params.path };
-                if (params.resolve !== undefined)
-                    body.resolve = params.resolve;
-                return ok(await fetchJson(`${baseUrl}/config/query`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body),
-                }));
-            }
-            catch (error) {
-                return connectionFail(error, baseUrl);
-            }
+        {
+            name: 'watcher_query',
+            description: 'Query the merged virtual document via JSONPath.',
+            parameters: {
+                type: 'object',
+                required: ['path'],
+                properties: {
+                    path: { type: 'string', description: 'JSONPath expression.' },
+                    resolve: {
+                        type: 'array',
+                        items: { type: 'string', enum: ['files', 'globals'] },
+                        description: 'Resolution scopes to include (e.g., ["files"], ["globals"], or both).',
+                    },
+                },
+            },
+            buildRequest: (params) => {
+                const body = pickDefined(params, ['path', 'resolve']);
+                return ['/config/query', body];
+            },
         },
-    }, { optional: true });
-    api.registerTool({
-        name: 'watcher_validate',
-        description: 'Validate a candidate config (or current config if omitted). Optionally test file paths against the config to preview rule matching and metadata output.',
-        parameters: {
-            type: 'object',
-            properties: {
-                config: {
-                    type: 'object',
-                    description: 'Candidate config (partial or full). Omit to validate current config.',
+        {
+            name: 'watcher_validate',
+            description: 'Validate a candidate config (or current config if omitted). Optionally test file paths against the config to preview rule matching and metadata output.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    config: {
+                        type: 'object',
+                        description: 'Candidate config (partial or full). Omit to validate current config.',
+                    },
+                    testPaths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'File paths to test against the config for dry-run preview.',
+                    },
+                },
+            },
+            buildRequest: (params) => {
+                const body = pickDefined(params, ['config', 'testPaths']);
+                return ['/config/validate', body];
+            },
+        },
+        {
+            name: 'watcher_config_apply',
+            description: 'Apply a full or partial config. Validates, writes to disk, and triggers configured reindex behavior.',
+            parameters: {
+                type: 'object',
+                required: ['config'],
+                properties: {
+                    config: {
+                        type: 'object',
+                        description: 'Full or partial config to apply.',
+                    },
                 },
-                testPaths: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'File paths to test against the config for dry-run preview.',
+            },
+            buildRequest: (params) => ['/config/apply', { config: params.config }],
+        },
+        {
+            name: 'watcher_reindex',
+            description: 'Trigger a reindex of the watched files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    scope: {
+                        type: 'string',
+                        enum: ['rules', 'full'],
+                        description: 'Reindex scope: "rules" (default) re-applies inference rules; "full" re-embeds everything.',
+                    },
                 },
             },
+            buildRequest: (params) => [
+                '/config-reindex',
+                { scope: params.scope ?? 'rules' },
+            ],
         },
-        execute: async (_id, params) => {
-            try {
-                const body = {};
-                if (params.config !== undefined)
-                    body.config = params.config;
-                if (params.testPaths !== undefined)
-                    body.testPaths = params.testPaths;
-                return ok(await fetchJson(`${baseUrl}/config/validate`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body),
-                }));
-            }
-            catch (error) {
-                return connectionFail(error, baseUrl);
-            }
+        {
+            name: 'watcher_issues',
+            description: 'Get runtime embedding failures. Shows files that failed processing and why.',
+            parameters: { type: 'object', properties: {} },
+            buildRequest: () => ['/issues'],
         },
-    }, { optional: true });
+    ];
+    for (const tool of tools) {
+        registerApiTool(api, baseUrl, tool);
+    }
+}
+
+/**
+ * @module plugin
+ * OpenClaw plugin entry point. Registers all jeeves-watcher tools.
+ */
+/** Register all jeeves-watcher tools with the OpenClaw plugin API. */
+function register(api) {
+    const baseUrl = getApiUrl(api);
+    // Register 8 watcher_* tools
+    registerWatcherTools(api, baseUrl);
+    // Register memory slot tools (memory_search + memory_get)
+    const { memorySearch, memoryGet } = createMemoryTools(api, baseUrl);
     api.registerTool({
-        name: 'watcher_config_apply',
-        description: 'Apply a full or partial config. Validates, writes to disk, and triggers configured reindex behavior.',
+        name: 'memory_search',
+        description: 'Semantically search MEMORY.md and memory/*.md files. Returns top snippets with path and line numbers.',
         parameters: {
             type: 'object',
-            required: ['config'],
+            required: ['query'],
             properties: {
-                config: {
-                    type: 'object',
-                    description: 'Full or partial config to apply.',
+                query: { type: 'string', description: 'Search query text.' },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum results to return.',
+                },
+                minScore: {
+                    type: 'number',
+                    description: 'Minimum similarity score threshold.',
                 },
             },
         },
-        execute: async (_id, params) => {
-            try {
-                return ok(await fetchJson(`${baseUrl}/config/apply`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ config: params.config }),
-                }));
-            }
-            catch (error) {
-                return connectionFail(error, baseUrl);
-            }
-        },
-    }, { optional: true });
+        execute: memorySearch,
+    });
     api.registerTool({
-        name: 'watcher_reindex',
-        description: 'Trigger a reindex of the watched files.',
+        name: 'memory_get',
+        description: 'Read content from MEMORY.md or memory/*.md files with optional line range.',
         parameters: {
             type: 'object',
+            required: ['path'],
             properties: {
-                scope: {
+                path: {
                     type: 'string',
-                    enum: ['rules', 'full'],
-                    description: 'Reindex scope: "rules" (default) re-applies inference rules; "full" re-embeds everything.',
+                    description: 'Path to the memory file to read.',
+                },
+                from: {
+                    type: 'number',
+                    description: 'Line number to start reading from (1-indexed).',
+                },
+                lines: {
+                    type: 'number',
+                    description: 'Number of lines to read.',
                 },
             },
         },
-        execute: async (_id, params) => {
-            try {
-                return ok(await fetchJson(`${baseUrl}/config-reindex`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        scope: params.scope ?? 'rules',
-                    }),
-                }));
-            }
-            catch (error) {
-                return connectionFail(error, baseUrl);
-            }
-        },
-    }, { optional: true });
-    api.registerTool({
-        name: 'watcher_issues',
-        description: 'Get runtime embedding failures. Shows files that failed processing and why.',
-        parameters: { type: 'object', properties: {} },
-        execute: async () => {
-            try {
-                return ok(await fetchJson(`${baseUrl}/issues`));
-            }
-            catch (error) {
-                return connectionFail(error, baseUrl);
-            }
-        },
-    }, { optional: true });
+        execute: memoryGet,
+    });
 }
 
 export { register as default };

package/dist/skills/jeeves-watcher/SKILL.md

@@ -46,6 +46,9 @@ curl -X POST http://127.0.0.1:<PORT>/config/query \
 | `/config-reindex` | POST | Trigger reindex |
 | `/metadata` | POST | Enrich document metadata |
 | `/issues` | GET | Runtime embedding failures |
+| `/rules/register` | POST | Register virtual inference rules |
+| `/rules/unregister` | DELETE | Remove virtual rules by source |
+| `/points/delete` | POST | Delete points matching a Qdrant filter |
 
 **If the watcher is unreachable:** Check the service status (`nssm status jeeves-watcher` on Windows), check the configured port in the watcher config file, and check logs for startup errors.
 
@@ -83,6 +86,22 @@ You don't need to know the rules in advance. The config is introspectable at run
 
 ## Tools
 
+### `memory_search`
+Semantically search MEMORY.md and memory/*.md files. Powered by the watcher's vector store with Gemini 3072-dim embeddings.
+- `query` (string, required) — search query text
+- `maxResults` (number, optional) — maximum results to return
+- `minScore` (number, optional) — minimum similarity score threshold
+
+Returns: `[{ path, from, to, snippet, score }]` where `from`/`to` are 1-indexed line numbers.
+
+### `memory_get`
+Read content from MEMORY.md or memory/*.md files with optional line range.
+- `path` (string, required) — path to the memory file
+- `from` (number, optional) — line number to start reading from (1-indexed)
+- `lines` (number, optional) — number of lines to read
+
+Path validation: only files within the workspace's MEMORY.md and memory/**/*.md are accessible.
+
 ### `watcher_search`
 Semantic search over indexed documents.
 - `query` (string, required) — natural language search query
@@ -411,9 +430,9 @@ Or check if a specific path would match:
 ### Rule Structure
 Each inference rule has:
 - `name` (required) — unique identifier
-- `description` (optional) — human-readable purpose
+- `description` (required) — human-readable purpose
 - `match` — JSON Schema with picomatch glob for path matching
-- `set` — metadata fields to set on match
+- `schema` — array of named schema references and/or inline schema objects with `set` templates
 - `map` (optional) — named JsonMap transform
 - `template` (optional) — named Handlebars template
 

package/dist/src/cli.d.ts

@@ -13,4 +13,5 @@
  *   - OPENCLAW_HOME env var (path to .openclaw directory)
  *   - Default: ~/.openclaw/openclaw.json
  */
-export {};
+/** Patch OpenClaw config for install or uninstall. Returns log messages. */
+export declare function patchConfig(config: Record<string, unknown>, mode: 'add' | 'remove'): string[];

package/dist/src/cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/helpers.d.ts

@@ -10,6 +10,14 @@ export interface PluginApi {
                 config?: Record<string, unknown>;
             }>;
         };
+        agents?: {
+            entries?: Record<string, {
+                workspace?: string;
+            }>;
+            defaults?: {
+                workspace?: string;
+            };
+        };
     };
     registerTool(tool: {
         name: string;
@@ -28,6 +36,15 @@ export interface ToolResult {
     }>;
     isError?: boolean;
 }
+/** Source identifier for virtual rule registration. */
+export declare const PLUGIN_SOURCE = "jeeves-watcher-openclaw";
+/** Normalize a path to forward slashes and lowercase drive letter on Windows. */
+export declare function normalizePath(p: string): string;
+/**
+ * Resolve the workspace path from gateway config.
+ * Priority: agent-specific > defaults > fallback (~/.openclaw/workspace).
+ */
+export declare function getWorkspacePath(api: PluginApi): string;
 /** Resolve the watcher API base URL from plugin config. */
 export declare function getApiUrl(api: PluginApi): string;
 /** Format a successful tool result. */
@@ -38,3 +55,5 @@ export declare function fail(error: unknown): ToolResult;
 export declare function connectionFail(error: unknown, baseUrl: string): ToolResult;
 /** Fetch JSON from a URL, throwing on non-OK responses. */
 export declare function fetchJson(url: string, init?: RequestInit): Promise<unknown>;
+/** POST JSON to a URL and return parsed response. */
+export declare function postJson(url: string, body: unknown): Promise<unknown>;

package/dist/src/helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/memoryTools.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module plugin/memoryTools
+ * memory_search and memory_get tool implementations with lazy init.
+ *
+ * Lazy init registers virtual inference rules with the watcher on first
+ * memory_search call. Re-attempts on failure. memory_get reads files
+ * directly from the filesystem with path validation.
+ */
+import { type PluginApi, type ToolResult } from './helpers.js';
+/**
+ * Create memory tool registrations for the plugin.
+ * Returns register functions for memory_search and memory_get.
+ */
+export declare function createMemoryTools(api: PluginApi, baseUrl: string): {
+    memorySearch: (_id: string, params: Record<string, unknown>) => Promise<ToolResult>;
+    memoryGet: (_id: string, params: Record<string, unknown>) => Promise<ToolResult>;
+};

package/dist/src/memoryTools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/watcherTools.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module plugin/watcherTools
+ * Watcher tool registrations (watcher_* tools) for the OpenClaw plugin.
+ */
+import { type PluginApi } from './helpers.js';
+/** Register all 8 watcher_* tools with the OpenClaw plugin API. */
+export declare function registerWatcherTools(api: PluginApi, baseUrl: string): void;

package/dist/src/watcherTools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/openclaw.plugin.json

@@ -2,7 +2,8 @@
   "id": "jeeves-watcher-openclaw",
   "name": "Jeeves Watcher",
   "description": "Semantic search, metadata enrichment, and instance administration for a jeeves-watcher deployment.",
-  "version": "0.2.0",
+  "version": "0.3.1",
+  "kind": "memory",
   "skills": [
     "dist/skills/jeeves-watcher"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karmaniverous/jeeves-watcher-openclaw",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "author": "Jason Williscroft",
   "description": "OpenClaw plugin for jeeves-watcher — semantic search and metadata enrichment tools",
   "license": "BSD-3-Clause",
@@ -59,9 +59,11 @@
     "@rollup/plugin-typescript": "^12.3.0",
     "auto-changelog": "^2.5.0",
     "cross-env": "^10.1.0",
+    "knip": "^5.85.0",
     "release-it": "^19.2.4",
     "rollup": "^4.59.0",
-    "tslib": "^2.8.1"
+    "tslib": "^2.8.1",
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "build:plugin": "rimraf dist && cross-env NO_COLOR=1 rollup --config rollup.config.ts --configPlugin @rollup/plugin-typescript",
@@ -72,6 +74,8 @@
     "lint:fix": "eslint --fix .",
     "release": "dotenvx run -f .env.local -- release-it",
     "release:pre": "dotenvx run -f .env.local -- release-it --no-git.requireBranch --github.prerelease --preRelease",
+    "knip": "knip",
+    "test": "vitest run",
     "typecheck": "tsc"
   },
   "release-it": {
@@ -91,6 +95,7 @@
       "after:init": [
         "npm run lint",
         "npm run typecheck",
+        "npm run test",
         "npm run build"
       ],
       "before:npm:release": [