@karmaniverous/jeeves-meta-openclaw 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,4 +1,4 @@
-import { HttpWatcherClient, paginatedScan, isLocked, normalizePath, globMetas, buildOwnershipTree, findNode, ensureMetaJson, actualStaleness, computeEffectiveStaleness, selectCandidate, filterInScope, computeStructureHash, readLatestArchive, hasSteerChanged, isArchitectTriggered, loadSynthConfig } from '@karmaniverous/jeeves-meta';
+import { HttpWatcherClient, paginatedScan, buildMetaFilter, isLocked, normalizePath, discoverMetas, buildOwnershipTree, findNode, actualStaleness, computeEffectiveStaleness, selectCandidate, filterInScope, computeStructureHash, readLatestArchive, hasSteerChanged, isArchitectTriggered, loadSynthConfig } from '@karmaniverous/jeeves-meta';
 import { readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 
@@ -55,168 +55,175 @@ function fail(error) {
  * @module rules
  */
 const SOURCE = 'jeeves-meta';
-/** Virtual rule definitions per spec Section 15. */
-const SYNTH_RULES = [
-    {
-        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',
-            {
+/**
+ * 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: {
-                    domains: { set: ['synth-meta'] },
-                    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}}',
+                    file: {
+                        properties: {
+                            path: { type: 'string', glob: '**/.meta/meta.json' },
+                        },
                     },
                 },
             },
-        ],
-        render: {
-            frontmatter: [
-                'synth_id',
-                'synth_steer',
-                'generated_at_unix',
-                'synth_depth',
-                'synth_emphasis',
-                'synth_architect_tokens',
-                'synth_builder_tokens',
-                'synth_critic_tokens',
-            ],
-            body: [
+            schema: [
+                'base',
                 {
-                    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' },
+                        domains: { set: config.metaProperty.domains },
+                        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',
         },
-        schema: [
-            'base',
-            {
+        {
+            name: 'synth-meta-archive',
+            description: 'Archived jeeves-meta .meta/archive snapshots',
+            match: {
                 properties: {
-                    domains: { set: ['synth-archive'] },
-                    synth_id: { type: 'string', set: '{{json._id}}' },
-                    archived: { type: 'boolean', set: 'true' },
-                    archived_at: { type: 'string', set: '{{json._archivedAt}}' },
+                    file: {
+                        properties: {
+                            path: { type: 'string', glob: '**/.meta/archive/*.json' },
+                        },
+                    },
                 },
             },
-        ],
-        render: {
-            frontmatter: ['synth_id', 'archived', 'archived_at'],
-            body: [
+            schema: [
+                'base',
                 {
-                    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' },
+                        domains: { set: config.metaArchiveProperty.domains },
+                        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',
         },
-        schema: [
-            'base',
-            {
+        {
+            name: 'synth-config',
+            description: 'jeeves-meta configuration file',
+            match: {
                 properties: {
-                    domains: { set: ['synth-config'] },
+                    file: {
+                        properties: {
+                            path: { type: 'string', glob: '**/jeeves-meta.config.json' },
+                        },
+                    },
                 },
             },
-        ],
-        render: {
-            frontmatter: [
-                'watchPaths',
-                'watcherUrl',
-                'gatewayUrl',
-                'architectEvery',
-                'depthWeight',
-                'maxArchive',
-                'maxLines',
-                'batchSize',
-            ],
-            body: [
+            schema: [
+                'base',
                 {
-                    path: 'json.defaultArchitect',
-                    heading: 2,
-                    label: 'Default Architect Prompt',
-                },
-                {
-                    path: 'json.defaultCritic',
-                    heading: 2,
-                    label: 'Default Critic Prompt',
+                    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',
         },
-        renderAs: 'md',
-    },
-];
+    ];
+}
 /**
  * Register jeeves-meta virtual rules with the watcher.
  *
@@ -225,9 +232,9 @@ const SYNTH_RULES = [
  *
  * @param watcherUrl - Base URL for the watcher service.
  */
-async function registerSynthRules(watcherUrl) {
+async function registerSynthRules(watcherUrl, config) {
     const client = new HttpWatcherClient({ baseUrl: watcherUrl });
-    await client.registerRules(SOURCE, SYNTH_RULES);
+    await client.registerRules(SOURCE, buildSynthRules(config));
 }
 
 /**
@@ -248,8 +255,6 @@ function registerSynthTools(api) {
     };
     /** Derive watcherUrl from loaded config. */
     const getWatcherUrl = () => getConfig().watcherUrl;
-    /** Derive watchPaths from loaded config. */
-    const getWatchPaths = () => getConfig().watchPaths;
     // ─── synth_list ──────────────────────────────────────────────
     api.registerTool({
         name: 'synth_list',
@@ -282,12 +287,11 @@ function registerSynthTools(api) {
             try {
                 const pathPrefix = params.pathPrefix;
                 const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
-                // Query watcher for synth-meta domain points
+                const config = getConfig();
+                // Query watcher for synth entity points using configured filter
                 const scanFiles = await paginatedScan(watcher, {
                     ...(pathPrefix ? { pathPrefix } : {}),
-                    filter: {
-                        must: [{ key: 'domains', match: { value: 'synth-meta' } }],
-                    },
+                    filter: buildMetaFilter(config),
                     fields: [
                         'file_path',
                         'synth_depth',
@@ -300,6 +304,15 @@ function registerSynthTools(api) {
                         'synth_error_step',
                     ],
                 });
+                // Deduplicate by file_path (watcher chunks files into multiple points)
+                const seenPaths = new Set();
+                const dedupedFiles = scanFiles.filter((sf) => {
+                    const fp = sf.file_path;
+                    if (seenPaths.has(fp))
+                        return false;
+                    seenPaths.add(fp);
+                    return true;
+                });
                 const entities = [];
                 let staleCount = 0;
                 let errorCount = 0;
@@ -312,8 +325,7 @@ function registerSynthTools(api) {
                 let lastSynthAt = null;
                 let stalestPath = null;
                 let stalestEffective = -1;
-                const config = getConfig();
-                for (const sf of scanFiles) {
+                for (const sf of dedupedFiles) {
                     const filePath = sf.file_path;
                     const depth = typeof sf['synth_depth'] === 'number' ? sf['synth_depth'] : 0;
                     const emphasis = typeof sf['synth_emphasis'] === 'number' ? sf['synth_emphasis'] : 1;
@@ -475,13 +487,16 @@ function registerSynthTools(api) {
                     '_feedback',
                 ]);
                 const fields = params.fields;
-                const metaPaths = globMetas(getWatchPaths());
+                const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
+                const metaPaths = await discoverMetas(getConfig(), watcher);
                 const tree = buildOwnershipTree(metaPaths);
                 const targetNode = findNode(tree, targetPath);
                 if (!targetNode) {
                     return fail('Meta path not found: ' + targetPath);
                 }
-                const meta = ensureMetaJson(targetNode.metaPath);
+                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) {
@@ -542,7 +557,8 @@ function registerSynthTools(api) {
         execute: async (_id, params) => {
             try {
                 const targetPath = params.path;
-                const metaPaths = globMetas(getWatchPaths());
+                const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
+                const metaPaths = await discoverMetas(getConfig(), watcher);
                 const tree = buildOwnershipTree(metaPaths);
                 let targetNode;
                 if (targetPath) {
@@ -554,12 +570,19 @@ function registerSynthTools(api) {
                 }
                 else {
                     // Select stalest
+                    const { readFileSync: readFs } = await import('node:fs');
+                    const { join: joinPath } = await import('node:path');
                     const candidates = [];
                     for (const node of tree.nodes.values()) {
-                        const meta = ensureMetaJson(node.metaPath);
-                        const staleness = actualStaleness(meta);
-                        if (staleness > 0) {
-                            candidates.push({ node, meta, actualStaleness: staleness });
+                        try {
+                            const meta = JSON.parse(readFs(joinPath(node.metaPath, 'meta.json'), 'utf8'));
+                            const staleness = actualStaleness(meta);
+                            if (staleness > 0) {
+                                candidates.push({ node, meta, actualStaleness: staleness });
+                            }
+                        }
+                        catch {
+                            // skip unreadable
                         }
                     }
                     const weighted = computeEffectiveStaleness(candidates, getConfig().depthWeight);
@@ -571,8 +594,9 @@ function registerSynthTools(api) {
                     }
                     targetNode = winner.node;
                 }
-                const meta = ensureMetaJson(targetNode.metaPath);
-                const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
+                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 (paginated for completeness)
                 const allScanFiles = await paginatedScan(watcher, {
                     pathPrefix: targetNode.ownerPath,
@@ -661,15 +685,8 @@ function registerSynthTools(api) {
                     apiKey: config.gatewayApiKey,
                 });
                 const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
-                // If path specified, temporarily override watchPaths to target it
                 const targetPath = params.path;
-                const effectiveConfig = targetPath
-                    ? {
-                        ...config,
-                        watchPaths: [targetPath.replace(/[/\\]\.meta[/\\]?$/, '')],
-                    }
-                    : config;
-                const results = await orchestrate(effectiveConfig, executor, watcher);
+                const results = await orchestrate(config, executor, watcher, targetPath);
                 const synthesized = results.filter((r) => r.synthesized);
                 if (synthesized.length === 0) {
                     return ok({
@@ -715,19 +732,12 @@ function registerSynthTools(api) {
  * @param watcherUrl - Watcher API base URL.
  * @returns Markdown string for the Meta section.
  */
-async function generateMetaMenu(watcherUrl) {
+async function generateMetaMenu(watcherUrl, metaFilter) {
     let entities = [];
     try {
         const watcher = new HttpWatcherClient({ baseUrl: watcherUrl });
         entities = await paginatedScan(watcher, {
-            filter: {
-                must: [
-                    {
-                        key: 'domains',
-                        match: { value: 'synth-meta' },
-                    },
-                ],
-            },
+            filter: metaFilter,
             fields: [
                 'synth_depth',
                 'synth_emphasis',
@@ -751,6 +761,15 @@ async function generateMetaMenu(watcherUrl) {
             '> for setup instructions. Do not attempt synthesis until watcher is available.',
         ].join('\n');
     }
+    // Deduplicate by file_path (watcher chunks files into multiple points)
+    const seenPaths = new Set();
+    entities = entities.filter((e) => {
+        const fp = e.file_path;
+        if (seenPaths.has(fp))
+            return false;
+        seenPaths.add(fp);
+        return true;
+    });
     if (entities.length === 0) {
         return [
             '> **ACTION REQUIRED: No synthesis entities found.**',
@@ -926,8 +945,8 @@ function upsertMetaSection(existing, metaMenu) {
  * @param watcherUrl - Watcher API base URL.
  * @returns True if the file was updated.
  */
-async function refreshToolsMd(api, watcherUrl) {
-    const menu = await generateMetaMenu(watcherUrl);
+async function refreshToolsMd(api, config) {
+    const menu = await generateMetaMenu(config.watcherUrl, buildMetaFilter(config));
     if (menu === lastWrittenMenu) {
         return false;
     }
@@ -955,10 +974,10 @@ async function refreshToolsMd(api, watcherUrl) {
  * @param api - Plugin API.
  * @param watcherUrl - Watcher API base URL.
  */
-function startToolsWriter(api, watcherUrl) {
+function startToolsWriter(api, config) {
     // Deferred initial write
     setTimeout(() => {
-        refreshToolsMd(api, watcherUrl).catch((err) => {
+        refreshToolsMd(api, config).catch((err) => {
             console.error('[jeeves-meta] Failed to write TOOLS.md:', err);
         });
     }, INITIAL_DELAY_MS);
@@ -967,7 +986,7 @@ function startToolsWriter(api, watcherUrl) {
         clearInterval(intervalHandle);
     }
     intervalHandle = setInterval(() => {
-        refreshToolsMd(api, watcherUrl).catch((err) => {
+        refreshToolsMd(api, config).catch((err) => {
             console.error('[jeeves-meta] Failed to refresh TOOLS.md:', err);
         });
     }, REFRESH_INTERVAL_MS);
@@ -990,12 +1009,12 @@ function register(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).catch((err) => {
+    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.watcherUrl);
+    startToolsWriter(api, config);
 }
 
 export { register as default };

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

@@ -136,11 +136,38 @@ Before the synthesis engine can operate:
 
 ### Installation
 
+1. Install the core library globally (provides the CLI and the dependency for the plugin):
+
+```bash
+npm install -g @karmaniverous/jeeves-meta
+```
+
+2. Install the OpenClaw plugin:
+
 ```bash
 npx @karmaniverous/jeeves-meta-openclaw install
 ```
 
-Then restart the OpenClaw gateway to load the plugin.
+3. Configure the plugin in `openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "jeeves-meta-openclaw": {
+        "enabled": true,
+        "config": {
+          "configPath": "/path/to/jeeves-meta.config.json"
+        }
+      }
+    }
+  }
+}
+```
+
+Alternatively, set the `JEEVES_META_CONFIG` environment variable instead of using plugin config.
+
+4. Restart the OpenClaw gateway to load the plugin.
 
 ### First Synthesis
 

package/dist/src/promptInjection.d.ts

@@ -17,4 +17,4 @@
  * @param watcherUrl - Watcher API base URL.
  * @returns Markdown string for the Meta section.
  */
-export declare function generateMetaMenu(watcherUrl: string): Promise<string>;
+export declare function generateMetaMenu(watcherUrl: string, metaFilter: Record<string, unknown>): Promise<string>;

package/dist/src/rules.d.ts

@@ -8,6 +8,7 @@
  *
  * @module rules
  */
+import type { SynthConfig } from '@karmaniverous/jeeves-meta';
 /**
  * Register jeeves-meta virtual rules with the watcher.
  *
@@ -16,4 +17,4 @@
  *
  * @param watcherUrl - Base URL for the watcher service.
  */
-export declare function registerSynthRules(watcherUrl: string): Promise<void>;
+export declare function registerSynthRules(watcherUrl: string, config: SynthConfig): Promise<void>;

package/dist/src/toolsWriter.d.ts

@@ -6,6 +6,7 @@
  *
  * @module toolsWriter
  */
+import { type SynthConfig } from '@karmaniverous/jeeves-meta';
 import type { PluginApi } from './helpers.js';
 /**
  * Upsert the Meta section in TOOLS.md content.
@@ -23,4 +24,4 @@ export declare function upsertMetaSection(existing: string, metaMenu: string): s
  * @param api - Plugin API.
  * @param watcherUrl - Watcher API base URL.
  */
-export declare function startToolsWriter(api: PluginApi, watcherUrl: string): void;
+export declare function startToolsWriter(api: PluginApi, config: SynthConfig): void;

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "jeeves-meta-openclaw",
   "name": "Jeeves Meta",
   "description": "Knowledge synthesis tools — trigger synthesis, view status, manage entities.",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "skills": [
     "dist/skills/jeeves-meta"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karmaniverous/jeeves-meta-openclaw",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "author": "Jason Williscroft",
   "description": "OpenClaw plugin for jeeves-meta — synthesis tools and virtual rule registration",
   "license": "BSD-3-Clause",