@karmaniverous/jeeves-meta-openclaw 0.1.5 → 0.2.0

package/dist/index.js

@@ -1,4 +1,3 @@
-import { HttpWatcherClient, listMetas, normalizePath, findNode, computeEffectiveStaleness, selectCandidate, paginatedScan, filterInScope, computeStructureHash, readLatestArchive, hasSteerChanged, isArchitectTriggered, actualStaleness, loadSynthConfig } from '@karmaniverous/jeeves-meta';
 import { readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 
@@ -8,26 +7,27 @@ import { resolve } from 'node:path';
  * @module helpers
  */
 const PLUGIN_NAME = 'jeeves-meta-openclaw';
+const DEFAULT_SERVICE_URL = 'http://127.0.0.1:1938';
 /** Get plugin config. */
 function getPluginConfig(api) {
     return api.config?.plugins?.entries?.[PLUGIN_NAME]?.config;
 }
 /**
- * Resolve the config file path.
+ * Resolve the service URL.
  *
  * Resolution order:
- * 1. Plugin config `configPath` setting
- * 2. `JEEVES_META_CONFIG` environment variable
- * 3. Error — no default path
+ * 1. Plugin config `serviceUrl` setting
+ * 2. `JEEVES_META_URL` environment variable
+ * 3. Default: http://127.0.0.1:1938
  */
-function getConfigPath(api) {
-    const fromPlugin = getPluginConfig(api)?.configPath;
+function getServiceUrl(api) {
+    const fromPlugin = getPluginConfig(api)?.serviceUrl;
     if (typeof fromPlugin === 'string')
         return fromPlugin;
-    const fromEnv = process.env['JEEVES_META_CONFIG'];
+    const fromEnv = process.env['JEEVES_META_URL'];
     if (fromEnv)
         return fromEnv;
-    throw new Error('jeeves-meta config path not found. Set configPath in plugin config or JEEVES_META_CONFIG env var.');
+    return DEFAULT_SERVICE_URL;
 }
 /** Format a successful tool result. */
 function ok(data) {
@@ -45,229 +45,108 @@ function fail(error) {
 }
 
 /**
- * Virtual rule definitions and registration for jeeves-meta.
+ * Thin HTTP client for the jeeves-meta service.
  *
- * Registers three inference rules with the watcher at plugin startup:
- * 1. synth-meta-live — indexes live .meta/meta.json files
- * 2. synth-meta-archive — indexes archived snapshots
- * 3. synth-config — indexes the synth config file
+ * Plugin delegates all operations to the running service via HTTP.
  *
- * @module rules
+ * @module serviceClient
  */
-const SOURCE = 'jeeves-meta';
-/**
- * Convert a `Record<string, unknown>` config property into watcher
- * schema `set` directives: `{ key: { set: value } }` per entry.
- */
-function toSchemaSetDirectives(props) {
-    return Object.fromEntries(Object.entries(props).map(([k, v]) => [k, { set: v }]));
-}
-/**
- * Build virtual rule definitions using configured domain tags.
- *
- * @param config - Synth config with metaProperty/metaArchiveProperty.
- * @returns Array of inference rule specs.
- */
-function buildSynthRules(config) {
-    return [
-        {
-            name: 'synth-meta-live',
-            description: 'Live jeeves-meta .meta/meta.json files',
-            match: {
-                properties: {
-                    file: {
-                        properties: {
-                            path: { type: 'string', glob: '**/.meta/meta.json' },
-                        },
-                    },
-                },
-            },
-            schema: [
-                'base',
-                {
-                    properties: {
-                        ...toSchemaSetDirectives(config.metaProperty),
-                        synth_id: { type: 'string', set: '{{json._id}}' },
-                        synth_steer: { type: 'string', set: '{{json._steer}}' },
-                        synth_depth: { type: 'number', set: '{{json._depth}}' },
-                        synth_emphasis: { type: 'number', set: '{{json._emphasis}}' },
-                        synth_synthesis_count: {
-                            type: 'integer',
-                            set: '{{json._synthesisCount}}',
-                        },
-                        synth_structure_hash: {
-                            type: 'string',
-                            set: '{{json._structureHash}}',
-                        },
-                        synth_architect_tokens: {
-                            type: 'integer',
-                            set: '{{json._architectTokens}}',
-                        },
-                        synth_builder_tokens: {
-                            type: 'integer',
-                            set: '{{json._builderTokens}}',
-                        },
-                        synth_critic_tokens: {
-                            type: 'integer',
-                            set: '{{json._criticTokens}}',
-                        },
-                        synth_error_step: {
-                            type: 'string',
-                            set: '{{json._error.step}}',
-                        },
-                        generated_at_unix: {
-                            type: 'integer',
-                            set: '{{toUnix json._generatedAt}}',
-                            description: 'Synthesis timestamp as Unix seconds for range queries',
-                        },
-                        has_error: {
-                            type: 'boolean',
-                            set: '{{#if json._error}}true{{else}}false{{/if}}',
-                        },
-                    },
-                },
-            ],
-            render: {
-                frontmatter: [
-                    'synth_id',
-                    'synth_steer',
-                    'generated_at_unix',
-                    'synth_depth',
-                    'synth_emphasis',
-                    'synth_architect_tokens',
-                    'synth_builder_tokens',
-                    'synth_critic_tokens',
-                ],
-                body: [
-                    {
-                        path: 'json._content',
-                        heading: 1,
-                        label: 'Synthesis',
-                    },
-                ],
-            },
-            renderAs: 'md',
-        },
-        {
-            name: 'synth-meta-archive',
-            description: 'Archived jeeves-meta .meta/archive snapshots',
-            match: {
-                properties: {
-                    file: {
-                        properties: {
-                            path: { type: 'string', glob: '**/.meta/archive/*.json' },
-                        },
-                    },
-                },
-            },
-            schema: [
-                'base',
-                {
-                    properties: {
-                        ...toSchemaSetDirectives(config.metaArchiveProperty),
-                        synth_id: { type: 'string', set: '{{json._id}}' },
-                        archived: { type: 'boolean', set: 'true' },
-                        archived_at: { type: 'string', set: '{{json._archivedAt}}' },
-                    },
-                },
-            ],
-            render: {
-                frontmatter: ['synth_id', 'archived', 'archived_at'],
-                body: [
-                    {
-                        path: 'json._content',
-                        heading: 1,
-                        label: 'Synthesis (archived)',
-                    },
-                ],
-            },
-            renderAs: 'md',
-        },
-        {
-            name: 'synth-config',
-            description: 'jeeves-meta configuration file',
-            match: {
-                properties: {
-                    file: {
-                        properties: {
-                            path: { type: 'string', glob: '**/jeeves-meta.config.json' },
-                        },
-                    },
-                },
-            },
-            schema: [
-                'base',
-                {
-                    properties: {
-                        domains: { set: ['synth-config'] },
-                    },
-                },
-            ],
-            render: {
-                frontmatter: [
-                    'watchPaths',
-                    'watcherUrl',
-                    'gatewayUrl',
-                    'architectEvery',
-                    'depthWeight',
-                    'maxArchive',
-                    'maxLines',
-                    'batchSize',
-                ],
-                body: [
-                    {
-                        path: 'json.defaultArchitect',
-                        heading: 2,
-                        label: 'Default Architect Prompt',
-                    },
-                    {
-                        path: 'json.defaultCritic',
-                        heading: 2,
-                        label: 'Default Critic Prompt',
-                    },
-                ],
-            },
-            renderAs: 'md',
-        },
-    ];
-}
-/**
- * Register jeeves-meta virtual rules with the watcher.
- *
- * Called at plugin startup. Rules are additive — the watcher appends
- * them after config-file rules (last-match-wins).
- *
- * @param watcherUrl - Base URL for the watcher service.
- */
-async function registerSynthRules(watcherUrl, config) {
-    const client = new HttpWatcherClient({ baseUrl: watcherUrl });
-    await client.registerRules(SOURCE, buildSynthRules(config));
+class MetaServiceClient {
+    baseUrl;
+    constructor(config) {
+        this.baseUrl = config.serviceUrl.replace(/\/$/, '');
+    }
+    /** GET helper — returns parsed JSON. */
+    async get(path) {
+        const res = await fetch(this.baseUrl + path);
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`META ${path} ${String(res.status)} ${res.statusText}: ${text}`);
+        }
+        return res.json();
+    }
+    /** POST helper — returns parsed JSON. */
+    async post(path, body) {
+        const res = await fetch(this.baseUrl + path, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`META ${path} ${String(res.status)} ${res.statusText}: ${text}`);
+        }
+        return res.json();
+    }
+    /** GET /status — service health + queue state. */
+    async status() {
+        return this.get('/status');
+    }
+    /** GET /metas — list all meta entities with summary. */
+    async listMetas(params) {
+        const qs = new URLSearchParams();
+        if (params?.pathPrefix)
+            qs.set('pathPrefix', params.pathPrefix);
+        if (params?.hasError !== undefined)
+            qs.set('hasError', String(params.hasError));
+        if (params?.staleHours !== undefined)
+            qs.set('staleHours', String(params.staleHours));
+        if (params?.neverSynthesized !== undefined)
+            qs.set('neverSynthesized', String(params.neverSynthesized));
+        if (params?.locked !== undefined)
+            qs.set('locked', String(params.locked));
+        if (params?.fields?.length)
+            qs.set('fields', params.fields.join(','));
+        const query = qs.toString();
+        return this.get('/metas' + (query ? '?' + query : ''));
+    }
+    /** GET /metas/:path — detail for a single meta. */
+    async detail(metaPath, options) {
+        const encoded = encodeURIComponent(metaPath);
+        const qs = new URLSearchParams();
+        if (options?.includeArchive !== undefined)
+            qs.set('includeArchive', String(options.includeArchive));
+        if (options?.fields?.length)
+            qs.set('fields', options.fields.join(','));
+        const query = qs.toString();
+        return this.get(`/metas/${encoded}` + (query ? '?' + query : ''));
+    }
+    /** GET /preview — dry-run next synthesis candidate. */
+    async preview(path) {
+        const qs = path ? '?path=' + encodeURIComponent(path) : '';
+        return this.get('/preview' + qs);
+    }
+    /** POST /synthesize — enqueue synthesis. */
+    async synthesize(path) {
+        return this.post('/synthesize', path ? { path } : {});
+    }
+    /** POST /seed — create .meta/ for a path. */
+    async seed(path) {
+        return this.post('/seed', { path });
+    }
+    /** POST /unlock — remove .lock from a meta entity. */
+    async unlock(path) {
+        return this.post('/unlock', { path });
+    }
+    /** GET /config/validate — validate current config. */
+    async validate() {
+        return this.get('/config/validate');
+    }
 }
 
 /**
- * Synth tool registrations for OpenClaw.
+ * Meta tool registrations for OpenClaw.
+ *
+ * All tools delegate to the jeeves-meta HTTP service.
  *
  * @module tools
  */
-/** Register all synth_* tools. */
-function registerSynthTools(api) {
-    const configPath = getConfigPath(api);
-    // Lazy-load config (resolved once on first use)
-    let _config = null;
-    const getConfig = () => {
-        if (!_config) {
-            _config = loadSynthConfig(configPath);
-        }
-        return _config;
-    };
-    /** Derive watcherUrl from loaded config. */
-    const getWatcherUrl = () => getConfig().watcherUrl;
-    /** Create a watcher client. */
-    const getWatcher = () => new HttpWatcherClient({ baseUrl: getWatcherUrl() });
-    // ─── synth_list ──────────────────────────────────────────────
+/** Register all meta_* tools. */
+function registerMetaTools(api, client) {
+    // ─── meta_list ──────────────────────────────────────────────
     api.registerTool({
-        name: 'synth_list',
-        description: 'List metas with summary stats and per-meta projection. Replaces synth_status + synth_entities.',
+        name: 'meta_list',
+        description: 'List metas with summary stats and per-meta projection. Replaces meta_status + meta_entities.',
         parameters: {
             type: 'object',
             properties: {
@@ -294,134 +173,25 @@ function registerSynthTools(api) {
         },
         execute: async (_id, params) => {
             try {
-                const pathPrefix = params.pathPrefix;
-                const config = getConfig();
-                const result = await listMetas(config, getWatcher());
-                // Apply path prefix filter
-                let entries = result.entries;
-                if (pathPrefix) {
-                    entries = entries.filter((e) => e.path.includes(pathPrefix));
-                }
-                // Apply structured filter
                 const filter = params.filter;
-                if (filter) {
-                    entries = entries.filter((e) => {
-                        if (filter.hasError !== undefined && e.hasError !== filter.hasError)
-                            return false;
-                        if (filter.neverSynthesized !== undefined &&
-                            (e.stalenessSeconds === Infinity) !== filter.neverSynthesized)
-                            return false;
-                        if (filter.locked !== undefined && e.locked !== filter.locked)
-                            return false;
-                        if (typeof filter.staleHours === 'number' &&
-                            e.stalenessSeconds < filter.staleHours * 3600)
-                            return false;
-                        return true;
-                    });
-                }
-                // Recompute summary for filtered entries
-                let staleCount = 0;
-                let errorCount = 0;
-                let lockedCount = 0;
-                let neverSynthesizedCount = 0;
-                let totalArchTokens = 0;
-                let totalBuilderTokens = 0;
-                let totalCriticTokens = 0;
-                let lastSynthPath = null;
-                let lastSynthAt = null;
-                let stalestPath = null;
-                let stalestEffective = -1;
-                for (const e of entries) {
-                    if (e.stalenessSeconds > 0)
-                        staleCount++;
-                    if (e.hasError)
-                        errorCount++;
-                    if (e.locked)
-                        lockedCount++;
-                    if (e.stalenessSeconds === Infinity)
-                        neverSynthesizedCount++;
-                    if (e.architectTokens)
-                        totalArchTokens += e.architectTokens;
-                    if (e.builderTokens)
-                        totalBuilderTokens += e.builderTokens;
-                    if (e.criticTokens)
-                        totalCriticTokens += e.criticTokens;
-                    if (e.lastSynthesized &&
-                        (!lastSynthAt || e.lastSynthesized > lastSynthAt)) {
-                        lastSynthAt = e.lastSynthesized;
-                        lastSynthPath = e.path;
-                    }
-                    const depthFactor = Math.pow(1 + config.depthWeight, e.depth);
-                    const effectiveStaleness = (e.stalenessSeconds === Infinity
-                        ? Number.MAX_SAFE_INTEGER
-                        : e.stalenessSeconds) *
-                        depthFactor *
-                        e.emphasis;
-                    if (effectiveStaleness > stalestEffective) {
-                        stalestEffective = effectiveStaleness;
-                        stalestPath = e.path;
-                    }
-                }
-                // Project fields
-                const fields = params.fields;
-                const items = entries.map((e) => {
-                    const stalenessDisplay = e.stalenessSeconds === Infinity
-                        ? 'never-synthesized'
-                        : Math.round(e.stalenessSeconds);
-                    const display = {
-                        path: e.path,
-                        depth: e.depth,
-                        emphasis: e.emphasis,
-                        stalenessSeconds: stalenessDisplay,
-                        lastSynthesized: e.lastSynthesized,
-                        hasError: e.hasError,
-                        locked: e.locked,
-                        architectTokens: e.architectTokens,
-                        builderTokens: e.builderTokens,
-                        criticTokens: e.criticTokens,
-                        children: e.children,
-                    };
-                    if (fields) {
-                        const projected = {};
-                        for (const f of fields) {
-                            if (f in display)
-                                projected[f] = display[f];
-                        }
-                        return projected;
-                    }
-                    return display;
-                });
-                return ok({
-                    summary: {
-                        total: entries.length,
-                        stale: staleCount,
-                        errors: errorCount,
-                        locked: lockedCount,
-                        neverSynthesized: neverSynthesizedCount,
-                        tokens: {
-                            architect: totalArchTokens,
-                            builder: totalBuilderTokens,
-                            critic: totalCriticTokens,
-                        },
-                        stalestPath,
-                        lastSynthesizedPath: lastSynthPath,
-                        lastSynthesizedAt: lastSynthAt,
-                    },
-                    items: items.sort((a, b) => {
-                        const ap = typeof a.path === 'string' ? a.path : '';
-                        const bp = typeof b.path === 'string' ? b.path : '';
-                        return ap.localeCompare(bp);
-                    }),
+                const data = await client.listMetas({
+                    pathPrefix: params.pathPrefix,
+                    hasError: filter?.hasError,
+                    staleHours: filter?.staleHours,
+                    neverSynthesized: filter?.neverSynthesized,
+                    locked: filter?.locked,
+                    fields: params.fields,
                 });
+                return ok(data);
             }
             catch (error) {
                 return fail(error);
             }
         },
     });
-    // ─── synth_detail ────────────────────────────────────────────
+    // ─── meta_detail ────────────────────────────────────────────
     api.registerTool({
-        name: 'synth_detail',
+        name: 'meta_detail',
         description: 'Full detail for a single meta, with optional archive history.',
         parameters: {
             type: 'object',
@@ -444,69 +214,20 @@ function registerSynthTools(api) {
         },
         execute: async (_id, params) => {
             try {
-                const targetPath = normalizePath(params.path);
-                const includeArchive = params.includeArchive;
-                const defaultExclude = new Set([
-                    '_architect',
-                    '_builder',
-                    '_critic',
-                    '_content',
-                    '_feedback',
-                ]);
-                const fields = params.fields;
-                const result = await listMetas(getConfig(), getWatcher());
-                const targetNode = findNode(result.tree, targetPath);
-                if (!targetNode) {
-                    return fail('Meta path not found: ' + targetPath);
-                }
-                const { readFileSync } = await import('node:fs');
-                const { join } = await import('node:path');
-                const meta = JSON.parse(readFileSync(join(targetNode.metaPath, 'meta.json'), 'utf8'));
-                // Apply field projection
-                const projectMeta = (m) => {
-                    if (fields) {
-                        const result = {};
-                        for (const f of fields)
-                            result[f] = m[f];
-                        return result;
-                    }
-                    const result = {};
-                    for (const [k, v] of Object.entries(m)) {
-                        if (!defaultExclude.has(k))
-                            result[k] = v;
-                    }
-                    return result;
-                };
-                const response = {
-                    meta: projectMeta(meta),
-                };
-                // Archive history
-                if (includeArchive) {
-                    const { readFileSync } = await import('node:fs');
-                    const { join } = await import('node:path');
-                    const { listArchiveFiles } = await import('@karmaniverous/jeeves-meta');
-                    const archiveFiles = listArchiveFiles(targetNode.metaPath);
-                    const limit = typeof includeArchive === 'number'
-                        ? includeArchive
-                        : archiveFiles.length;
-                    const selected = archiveFiles.slice(-limit).reverse();
-                    const archives = selected.map((af) => {
-                        const raw = readFileSync(join(targetNode.metaPath, 'archive', af), 'utf8');
-                        const parsed = JSON.parse(raw);
-                        return projectMeta(parsed);
-                    });
-                    response.archive = archives;
-                }
-                return ok(response);
+                const data = await client.detail(params.path, {
+                    includeArchive: params.includeArchive,
+                    fields: params.fields,
+                });
+                return ok(data);
             }
             catch (error) {
                 return fail(error);
             }
         },
     });
-    // ─── synth_preview ────────────────────────────────────────────
+    // ─── meta_preview ────────────────────────────────────────────
     api.registerTool({
-        name: 'synth_preview',
+        name: 'meta_preview',
         description: 'Dry-run: show what inputs would be gathered for the next synthesis cycle without running LLM.',
         parameters: {
             type: 'object',
@@ -519,102 +240,17 @@ function registerSynthTools(api) {
         },
         execute: async (_id, params) => {
             try {
-                const targetPath = params.path;
-                const config = getConfig();
-                const watcher = getWatcher();
-                const result = await listMetas(config, watcher);
-                let targetNode;
-                if (targetPath) {
-                    const normalized = normalizePath(targetPath);
-                    targetNode = findNode(result.tree, normalized);
-                    if (!targetNode) {
-                        return fail('Meta path not found: ' + targetPath);
-                    }
-                }
-                else {
-                    // Select stalest candidate
-                    const candidates = result.entries
-                        .filter((e) => e.stalenessSeconds > 0)
-                        .map((e) => ({
-                        node: e.node,
-                        meta: e.meta,
-                        actualStaleness: e.stalenessSeconds,
-                    }));
-                    const weighted = computeEffectiveStaleness(candidates, config.depthWeight);
-                    const winner = selectCandidate(weighted);
-                    if (!winner) {
-                        return ok({
-                            message: 'No stale metas found. Nothing to synthesize.',
-                        });
-                    }
-                    targetNode = winner.node;
-                }
-                const { readFileSync: readMeta } = await import('node:fs');
-                const { join: joinMeta } = await import('node:path');
-                const meta = JSON.parse(readMeta(joinMeta(targetNode.metaPath, 'meta.json'), 'utf8'));
-                // Scope files
-                const allScanFiles = await paginatedScan(watcher, {
-                    pathPrefix: targetNode.ownerPath,
-                });
-                const allFiles = allScanFiles.map((f) => f.file_path);
-                const scopeFiles = filterInScope(targetNode, allFiles);
-                const structureHash = computeStructureHash(scopeFiles);
-                const structureChanged = structureHash !== meta._structureHash;
-                const latestArchive = readLatestArchive(targetNode.metaPath);
-                const steerChanged = hasSteerChanged(meta._steer, latestArchive?._steer, Boolean(latestArchive));
-                const architectTriggered = isArchitectTriggered(meta, structureChanged, steerChanged, config.architectEvery);
-                let deltaFiles = [];
-                if (meta._generatedAt) {
-                    const modifiedAfter = Math.floor(new Date(meta._generatedAt).getTime() / 1000);
-                    const deltaScanFiles = await paginatedScan(watcher, {
-                        pathPrefix: targetNode.ownerPath,
-                        modifiedAfter,
-                    });
-                    deltaFiles = filterInScope(targetNode, deltaScanFiles.map((f) => f.file_path));
-                }
-                else {
-                    deltaFiles = scopeFiles;
-                }
-                return ok({
-                    target: targetNode.metaPath,
-                    ownerPath: targetNode.ownerPath,
-                    depth: meta._depth ?? targetNode.treeDepth,
-                    staleness: actualStaleness(meta) === Infinity
-                        ? 'never-synthesized'
-                        : Math.round(actualStaleness(meta)).toString() + 's',
-                    scopeFiles: {
-                        count: scopeFiles.length,
-                        sample: scopeFiles.slice(0, 20),
-                    },
-                    deltaFiles: {
-                        count: deltaFiles.length,
-                        sample: deltaFiles.slice(0, 20),
-                    },
-                    structureChanged,
-                    steerChanged,
-                    architectTriggered,
-                    architectTriggerReasons: [
-                        ...(!meta._builder ? ['no cached builder (first run)'] : []),
-                        ...(structureChanged ? ['structure changed'] : []),
-                        ...(steerChanged ? ['steer changed'] : []),
-                        ...((meta._synthesisCount ?? 0) >= config.architectEvery
-                            ? ['periodic refresh (architectEvery)']
-                            : []),
-                    ],
-                    currentSteer: meta._steer ?? null,
-                    hasExistingContent: Boolean(meta._content),
-                    hasExistingFeedback: Boolean(meta._feedback),
-                    children: targetNode.children.map((c) => c.metaPath),
-                });
+                const data = await client.preview(params.path);
+                return ok(data);
             }
             catch (error) {
                 return fail(error);
             }
         },
     });
-    // ─── synth_trigger ────────────────────────────────────────────
+    // ─── meta_trigger ────────────────────────────────────────────
     api.registerTool({
-        name: 'synth_trigger',
+        name: 'meta_trigger',
         description: 'Manually trigger synthesis for a specific meta or the next-stalest candidate. Runs the full 3-step cycle (architect, builder, critic).',
         parameters: {
             type: 'object',
@@ -627,34 +263,8 @@ function registerSynthTools(api) {
         },
         execute: async (_id, params) => {
             try {
-                const { orchestrate } = await import('@karmaniverous/jeeves-meta');
-                const { GatewayExecutor } = await import('@karmaniverous/jeeves-meta');
-                const config = getConfig();
-                const executor = new GatewayExecutor({
-                    gatewayUrl: config.gatewayUrl,
-                    apiKey: config.gatewayApiKey,
-                });
-                const watcher = getWatcher();
-                const targetPath = params.path;
-                const results = await orchestrate(config, executor, watcher, targetPath);
-                const synthesized = results.filter((r) => r.synthesized);
-                if (synthesized.length === 0) {
-                    return ok({
-                        message: 'No synthesis performed — no stale metas found or all locked.',
-                    });
-                }
-                return ok({
-                    synthesizedCount: synthesized.length,
-                    results: synthesized.map((r) => ({
-                        metaPath: r.metaPath,
-                        error: r.error ?? null,
-                    })),
-                    message: synthesized.length.toString() +
-                        ' meta(s) synthesized.' +
-                        (synthesized.some((r) => r.error)
-                            ? ' Some completed with errors.'
-                            : ''),
-                });
+                const data = await client.synthesize(params.path);
+                return ok(data);
             }
             catch (error) {
                 return fail(error);
@@ -666,7 +276,7 @@ function registerSynthTools(api) {
 /**
  * Generate the Meta menu content for TOOLS.md injection.
  *
- * Queries the watcher API for synthesis entity stats and produces
+ * Queries the jeeves-meta service for entity stats and produces
  * a Markdown section suitable for agent system prompt injection.
  *
  * @module promptInjection
@@ -674,43 +284,39 @@ function registerSynthTools(api) {
 /**
  * Generate the Meta menu Markdown for TOOLS.md.
  *
- * Three output modes:
- * 1. Watcher unreachable - ACTION REQUIRED with diagnostic
- * 2. No entities found - ACTION REQUIRED with setup guidance
- * 3. Healthy - entity stats + tool listing + skill reference
- *
- * @param config - Full synth config (for listMetas and watcherUrl).
+ * @param client - MetaServiceClient instance.
  * @returns Markdown string for the Meta section.
  */
-async function generateMetaMenu(config) {
-    let result;
+async function generateMetaMenu(client) {
+    let status;
+    let metas;
     try {
-        const watcher = new HttpWatcherClient({ baseUrl: config.watcherUrl });
-        result = await listMetas(config, watcher);
+        status = (await client.status());
+        metas = (await client.listMetas());
     }
     catch {
         return [
-            '> **ACTION REQUIRED: jeeves-watcher is unreachable.**',
-            '> The jeeves-meta synthesis engine requires a running jeeves-watcher service.',
-            '> The watcher API at ' +
-                config.watcherUrl +
-                ' is down or not configured.',
+            '> **ACTION REQUIRED: jeeves-meta service is unreachable.**',
+            '> The service API is down or not configured.',
+            '>',
+            '> **Troubleshooting:**',
+            '> - Verify the service is installed: `npm list -g @karmaniverous/jeeves-meta`',
+            '> - Check if running: `curl http://localhost:1938/status`',
+            '> - Verify `serviceUrl` in plugin config if using a non-default port',
             '>',
-            "> **Read the `jeeves-meta` skill's Bootstrap section immediately**",
-            '> for setup instructions. Do not attempt synthesis until watcher is available.',
+            "> **Read the `jeeves-meta` skill's Bootstrapping section** for full setup guidance.",
         ].join('\n');
     }
-    if (result.entries.length === 0) {
+    if (metas.summary.total === 0) {
         return [
             '> **ACTION REQUIRED: No synthesis entities found.**',
-            '> The watcher is running but no `.meta/` directories were discovered',
-            '> in the configured watch paths.',
+            '> The service is running but no `.meta/` directories were discovered.',
             '>',
-            "> **Read the `jeeves-meta` skill's Bootstrap section** for guidance",
-            '> on creating `.meta/` directories and configuring watch paths.',
+            "> **Read the `jeeves-meta` skill's Bootstrapping section** for guidance",
+            '> on creating `.meta/` directories.',
         ].join('\n');
     }
-    const { summary, entries } = result;
+    const { summary } = metas;
     const formatAge = (seconds) => {
         if (!isFinite(seconds))
             return 'never synthesized';
@@ -720,11 +326,12 @@ async function generateMetaMenu(config) {
             return Math.round(seconds / 3600).toString() + 'h';
         return Math.round(seconds / 86400).toString() + 'd';
     };
-    // Find stalest age for display
+    // Find stalest age
     let stalestAge = 0;
-    for (const e of entries) {
-        if (e.stalenessSeconds > stalestAge)
-            stalestAge = e.stalenessSeconds;
+    for (const item of metas.metas) {
+        const s = item.stalenessSeconds !== null ? item.stalenessSeconds : Infinity;
+        if (s > stalestAge)
+            stalestAge = s;
     }
     const stalestDisplay = summary.stalestPath
         ? summary.stalestPath + ' (' + formatAge(stalestAge) + ')'
@@ -735,9 +342,17 @@ async function generateMetaMenu(config) {
             summary.lastSynthesizedAt +
             ')'
         : 'n/a';
-    const lines = [
+    // Service status + dependency health
+    const depLines = [];
+    if (status.dependencies.watcher.status !== 'ok') {
+        depLines.push('> ⚠️ **Watcher**: ' + status.dependencies.watcher.status);
+    }
+    if (status.dependencies.gateway.status !== 'ok') {
+        depLines.push('> ⚠️ **Gateway**: ' + status.dependencies.gateway.status);
+    }
+    return [
         'The jeeves-meta synthesis engine manages ' +
-            entries.length.toString() +
+            summary.total.toString() +
             ' meta entities.',
         '',
         '### Entity Summary',
@@ -749,6 +364,7 @@ async function generateMetaMenu(config) {
         '| Never synthesized | ' + summary.neverSynthesized.toString() + ' |',
         '| Stalest | ' + stalestDisplay + ' |',
         '| Last synthesized | ' + lastSynthDisplay + ' |',
+        ...(depLines.length > 0 ? ['', '### Dependencies', ...depLines] : []),
         '',
         '### Token Usage (cumulative)',
         '| Step | Tokens |',
@@ -760,14 +376,13 @@ async function generateMetaMenu(config) {
         '### Tools',
         '| Tool | Description |',
         '|------|-------------|',
-        '| `synth_list` | List metas with summary stats and per-meta projection |',
-        '| `synth_detail` | Full detail for a single meta with optional archive history |',
-        '| `synth_trigger` | Manually trigger synthesis for a specific meta or next-stalest |',
-        '| `synth_preview` | Dry-run: show what inputs would be gathered without running LLM |',
+        '| `meta_list` | List metas with summary stats and per-meta projection |',
+        '| `meta_detail` | Full detail for a single meta with optional archive history |',
+        '| `meta_trigger` | Manually trigger synthesis for a specific meta or next-stalest |',
+        '| `meta_preview` | Dry-run: show what inputs would be gathered without running LLM |',
         '',
         'Read the `jeeves-meta` skill for usage guidance, configuration, and troubleshooting.',
-    ];
-    return lines.join('\n');
+    ].join('\n');
 }
 
 /**
@@ -805,9 +420,12 @@ function resolveToolsPath(api) {
 function upsertMetaSection(existing, metaMenu) {
     const section = '## Meta\n\n' + metaMenu;
     // Replace existing Meta section (match from ## Meta to next ## or # or EOF)
-    const re = /^## Meta\n[\s\S]*?(?=\n## |\n# |$(?![\s\S]))/m;
-    if (re.test(existing)) {
-        return existing.replace(re, section);
+    // Remove ALL existing ## Meta sections (handles duplicates from prior bugs)
+    const re = /^## Meta\n[\s\S]*?(?=\n## |\n# |$(?![\s\S]))/gm;
+    const cleaned = existing.replace(re, '').replace(/\n{3,}/g, '\n\n');
+    if (cleaned !== existing) {
+        // Had at least one section — re-insert at correct position
+        return upsertMetaSection(cleaned.trim() + '\n', metaMenu);
     }
     // No existing section. Insert in correct order.
     const platformH1 = '# Jeeves Platform Tools';
@@ -841,11 +459,11 @@ function upsertMetaSection(existing, metaMenu) {
  * Fetch the current meta menu and write it to TOOLS.md if changed.
  *
  * @param api - Plugin API.
- * @param watcherUrl - Watcher API base URL.
+ * @param client - MetaServiceClient instance.
  * @returns True if the file was updated.
  */
-async function refreshToolsMd(api, config) {
-    const menu = await generateMetaMenu(config);
+async function refreshToolsMd(api, client) {
+    const menu = await generateMetaMenu(client);
     if (menu === lastWrittenMenu) {
         return false;
     }
@@ -871,12 +489,12 @@ async function refreshToolsMd(api, config) {
  * Defers first write by 5s, then refreshes every 60s.
  *
  * @param api - Plugin API.
- * @param watcherUrl - Watcher API base URL.
+ * @param client - MetaServiceClient instance.
  */
-function startToolsWriter(api, config) {
+function startToolsWriter(api, client) {
     // Deferred initial write
     setTimeout(() => {
-        refreshToolsMd(api, config).catch((err) => {
+        refreshToolsMd(api, client).catch((err) => {
             console.error('[jeeves-meta] Failed to write TOOLS.md:', err);
         });
     }, INITIAL_DELAY_MS);
@@ -885,7 +503,7 @@ function startToolsWriter(api, config) {
         clearInterval(intervalHandle);
     }
     intervalHandle = setInterval(() => {
-        refreshToolsMd(api, config).catch((err) => {
+        refreshToolsMd(api, client).catch((err) => {
             console.error('[jeeves-meta] Failed to refresh TOOLS.md:', err);
         });
     }, REFRESH_INTERVAL_MS);
@@ -897,23 +515,18 @@ function startToolsWriter(api, config) {
 /**
  * OpenClaw plugin for jeeves-meta.
  *
- * Registers synthesis tools, virtual inference rules, and starts
- * the periodic TOOLS.md writer at gateway startup.
+ * Thin HTTP client — all operations delegate to the jeeves-meta service.
+ * The plugin registers tools and starts the periodic TOOLS.md writer.
  *
  * @packageDocumentation
  */
-/** Register all jeeves-meta tools and rules with the OpenClaw plugin API. */
+/** Register all jeeves-meta tools with the OpenClaw plugin API. */
 function register(api) {
-    registerSynthTools(api);
-    // Load config for rule registration and tools writer
-    const config = loadSynthConfig(getConfigPath(api));
-    // Register virtual rules with watcher (fire-and-forget at startup)
-    registerSynthRules(config.watcherUrl, config).catch((err) => {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error('[jeeves-meta] Failed to register virtual rules:', message);
-    });
-    // Start periodic TOOLS.md writer
-    startToolsWriter(api, config);
+    const serviceUrl = getServiceUrl(api);
+    const client = new MetaServiceClient({ serviceUrl });
+    registerMetaTools(api, client);
+    // Start periodic TOOLS.md writer (fire-and-forget)
+    startToolsWriter(api, client);
 }
 
 export { register as default };