@karmaniverous/jeeves-meta-openclaw 0.1.1 → 0.1.3

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, 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';
 
@@ -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,8 @@ function registerSynthTools(api) {
     };
     /** Derive watcherUrl from loaded config. */
     const getWatcherUrl = () => getConfig().watcherUrl;
-    /** Derive watchPaths from loaded config. */
-    const getWatchPaths = () => getConfig().watchPaths;
+    /** Create a watcher client. */
+    const getWatcher = () => new HttpWatcherClient({ baseUrl: getWatcherUrl() });
     // ─── synth_list ──────────────────────────────────────────────
     api.registerTool({
         name: 'synth_list',
@@ -281,26 +288,31 @@ function registerSynthTools(api) {
         execute: async (_id, params) => {
             try {
                 const pathPrefix = params.pathPrefix;
-                const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
-                // Query watcher for synth-meta domain points
-                const scanFiles = await paginatedScan(watcher, {
-                    ...(pathPrefix ? { pathPrefix } : {}),
-                    filter: {
-                        must: [{ key: 'domains', match: { value: 'synth-meta' } }],
-                    },
-                    fields: [
-                        'file_path',
-                        'synth_depth',
-                        'synth_emphasis',
-                        'synth_architect_tokens',
-                        'synth_builder_tokens',
-                        'synth_critic_tokens',
-                        'has_error',
-                        'generated_at_unix',
-                        'synth_error_step',
-                    ],
-                });
-                const entities = [];
+                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;
@@ -312,113 +324,69 @@ function registerSynthTools(api) {
                 let lastSynthAt = null;
                 let stalestPath = null;
                 let stalestEffective = -1;
-                const config = getConfig();
-                for (const sf of scanFiles) {
-                    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;
-                    const hasError = sf['has_error'] === true || sf['has_error'] === 'true';
-                    const archTokens = typeof sf['synth_architect_tokens'] === 'number'
-                        ? sf['synth_architect_tokens']
-                        : 0;
-                    const buildTokens = typeof sf['synth_builder_tokens'] === 'number'
-                        ? sf['synth_builder_tokens']
-                        : 0;
-                    const critTokens = typeof sf['synth_critic_tokens'] === 'number'
-                        ? sf['synth_critic_tokens']
-                        : 0;
-                    const genAtUnix = typeof sf['generated_at_unix'] === 'number'
-                        ? sf['generated_at_unix']
-                        : 0;
-                    const locked = isLocked(normalizePath(filePath));
-                    const neverSynth = genAtUnix === 0;
-                    // Compute staleness from generated_at_unix
-                    let stalenessSeconds;
-                    if (neverSynth) {
-                        stalenessSeconds = Infinity;
-                    }
-                    else {
-                        stalenessSeconds = Math.floor(Date.now() / 1000) - genAtUnix;
-                        if (stalenessSeconds < 0)
-                            stalenessSeconds = 0;
-                    }
-                    // Apply structured filter
-                    const filter = params.filter;
-                    if (filter) {
-                        if (filter.hasError !== undefined && hasError !== filter.hasError)
-                            continue;
-                        if (filter.neverSynthesized !== undefined &&
-                            neverSynth !== filter.neverSynthesized)
-                            continue;
-                        if (filter.locked !== undefined && locked !== filter.locked)
-                            continue;
-                        if (typeof filter.staleHours === 'number' &&
-                            stalenessSeconds < filter.staleHours * 3600)
-                            continue;
-                    }
-                    if (stalenessSeconds > 0)
+                for (const e of entries) {
+                    if (e.stalenessSeconds > 0)
                         staleCount++;
-                    if (hasError)
+                    if (e.hasError)
                         errorCount++;
-                    if (locked)
+                    if (e.locked)
                         lockedCount++;
-                    if (neverSynth)
+                    if (e.stalenessSeconds === Infinity)
                         neverSynthesizedCount++;
-                    if (archTokens > 0)
-                        totalArchTokens += archTokens;
-                    if (buildTokens > 0)
-                        totalBuilderTokens += buildTokens;
-                    if (critTokens > 0)
-                        totalCriticTokens += critTokens;
-                    const genAtIso = genAtUnix > 0 ? new Date(genAtUnix * 1000).toISOString() : null;
-                    if (genAtIso && (!lastSynthAt || genAtIso > lastSynthAt)) {
-                        lastSynthAt = genAtIso;
-                        lastSynthPath = filePath;
+                    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;
                     }
-                    // Effective staleness for stalest computation
-                    const depthFactor = Math.pow(1 + config.depthWeight, depth);
-                    const effectiveStaleness = (stalenessSeconds === Infinity
+                    const depthFactor = Math.pow(1 + config.depthWeight, e.depth);
+                    const effectiveStaleness = (e.stalenessSeconds === Infinity
                         ? Number.MAX_SAFE_INTEGER
-                        : stalenessSeconds) *
+                        : e.stalenessSeconds) *
                         depthFactor *
-                        emphasis;
+                        e.emphasis;
                     if (effectiveStaleness > stalestEffective) {
                         stalestEffective = effectiveStaleness;
-                        stalestPath = filePath;
+                        stalestPath = e.path;
                     }
-                    // Derive meta path from file_path (strip /meta.json)
-                    const metaPath = filePath.replace(/\/meta\.json$/, '');
-                    const fields = params.fields;
-                    const raw = {
-                        path: metaPath,
-                        depth,
-                        emphasis,
-                        stalenessSeconds: stalenessSeconds === Infinity
-                            ? 'never-synthesized'
-                            : Math.round(stalenessSeconds),
-                        lastSynthesized: genAtIso,
-                        hasError,
-                        locked,
-                        architectTokens: archTokens > 0 ? archTokens : null,
-                        builderTokens: buildTokens > 0 ? buildTokens : null,
-                        criticTokens: critTokens > 0 ? critTokens : null,
-                        children: 0,
+                }
+                // 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 raw)
-                                projected[f] = raw[f];
+                            if (f in display)
+                                projected[f] = display[f];
                         }
-                        entities.push(projected);
+                        return projected;
                     }
-                    else {
-                        entities.push(raw);
-                    }
-                }
+                    return display;
+                });
                 return ok({
                     summary: {
-                        total: entities.length,
+                        total: entries.length,
                         stale: staleCount,
                         errors: errorCount,
                         locked: lockedCount,
@@ -432,7 +400,11 @@ function registerSynthTools(api) {
                         lastSynthesizedPath: lastSynthPath,
                         lastSynthesizedAt: lastSynthAt,
                     },
-                    items: entities.sort((a, b) => String(a.path ?? '').localeCompare(String(b.path ?? ''))),
+                    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);
+                    }),
                 });
             }
             catch (error) {
@@ -475,13 +447,14 @@ function registerSynthTools(api) {
                     '_feedback',
                 ]);
                 const fields = params.fields;
-                const metaPaths = globMetas(getWatchPaths());
-                const tree = buildOwnershipTree(metaPaths);
-                const targetNode = findNode(tree, targetPath);
+                const result = await listMetas(getConfig(), getWatcher());
+                const targetNode = findNode(result.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) {
@@ -490,7 +463,6 @@ function registerSynthTools(api) {
                             result[f] = m[f];
                         return result;
                     }
-                    // Default: exclude big text blobs
                     const result = {};
                     for (const [k, v] of Object.entries(m)) {
                         if (!defaultExclude.has(k))
@@ -510,7 +482,6 @@ function registerSynthTools(api) {
                     const limit = typeof includeArchive === 'number'
                         ? includeArchive
                         : archiveFiles.length;
-                    // Most recent first (files are sorted by timestamp)
                     const selected = archiveFiles.slice(-limit).reverse();
                     const archives = selected.map((af) => {
                         const raw = readFileSync(join(targetNode.metaPath, 'archive', af), 'utf8');
@@ -542,27 +513,27 @@ function registerSynthTools(api) {
         execute: async (_id, params) => {
             try {
                 const targetPath = params.path;
-                const metaPaths = globMetas(getWatchPaths());
-                const tree = buildOwnershipTree(metaPaths);
+                const config = getConfig();
+                const watcher = getWatcher();
+                const result = await listMetas(config, watcher);
                 let targetNode;
                 if (targetPath) {
                     const normalized = normalizePath(targetPath);
-                    targetNode = findNode(tree, normalized);
+                    targetNode = findNode(result.tree, normalized);
                     if (!targetNode) {
                         return fail('Meta path not found: ' + targetPath);
                     }
                 }
                 else {
-                    // Select stalest
-                    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 });
-                        }
-                    }
-                    const weighted = computeEffectiveStaleness(candidates, getConfig().depthWeight);
+                    // 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({
@@ -571,23 +542,20 @@ function registerSynthTools(api) {
                     }
                     targetNode = winner.node;
                 }
-                const meta = ensureMetaJson(targetNode.metaPath);
-                const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
-                // Scope files (paginated for completeness)
+                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);
-                // Structure hash on scope-filtered files (matches orchestrator)
                 const structureHash = computeStructureHash(scopeFiles);
                 const structureChanged = structureHash !== meta._structureHash;
-                // Steer change
                 const latestArchive = readLatestArchive(targetNode.metaPath);
                 const steerChanged = hasSteerChanged(meta._steer, latestArchive?._steer, Boolean(latestArchive));
-                // Architect trigger check
-                const architectTriggered = isArchitectTriggered(meta, structureChanged, steerChanged, getConfig().architectEvery);
-                // Delta files
+                const architectTriggered = isArchitectTriggered(meta, structureChanged, steerChanged, config.architectEvery);
                 let deltaFiles = [];
                 if (meta._generatedAt) {
                     const modifiedAfter = Math.floor(new Date(meta._generatedAt).getTime() / 1000);
@@ -622,7 +590,7 @@ function registerSynthTools(api) {
                         ...(!meta._builder ? ['no cached builder (first run)'] : []),
                         ...(structureChanged ? ['structure changed'] : []),
                         ...(steerChanged ? ['steer changed'] : []),
-                        ...((meta._synthesisCount ?? 0) >= getConfig().architectEvery
+                        ...((meta._synthesisCount ?? 0) >= config.architectEvery
                             ? ['periodic refresh (architectEvery)']
                             : []),
                     ],
@@ -654,22 +622,14 @@ function registerSynthTools(api) {
             try {
                 const { orchestrate } = await import('@karmaniverous/jeeves-meta');
                 const { GatewayExecutor } = await import('@karmaniverous/jeeves-meta');
-                // Load config from canonical config file
                 const config = getConfig();
                 const executor = new GatewayExecutor({
                     gatewayUrl: config.gatewayUrl,
                     apiKey: config.gatewayApiKey,
                 });
-                const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
-                // If path specified, temporarily override watchPaths to target it
+                const watcher = getWatcher();
                 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({
@@ -712,46 +672,28 @@ function registerSynthTools(api) {
  * 2. No entities found - ACTION REQUIRED with setup guidance
  * 3. Healthy - entity stats + tool listing + skill reference
  *
- * @param watcherUrl - Watcher API base URL.
+ * @param config - Full synth config (for listMetas and watcherUrl).
  * @returns Markdown string for the Meta section.
  */
-async function generateMetaMenu(watcherUrl) {
-    let entities = [];
+async function generateMetaMenu(config) {
+    let result;
     try {
-        const watcher = new HttpWatcherClient({ baseUrl: watcherUrl });
-        entities = await paginatedScan(watcher, {
-            filter: {
-                must: [
-                    {
-                        key: 'domains',
-                        match: { value: 'synth-meta' },
-                    },
-                ],
-            },
-            fields: [
-                'synth_depth',
-                'synth_emphasis',
-                'synth_synthesis_count',
-                'synth_architect_tokens',
-                'synth_builder_tokens',
-                'synth_critic_tokens',
-                'synth_error_step',
-                'generated_at_unix',
-                'has_error',
-            ],
-        });
+        const watcher = new HttpWatcherClient({ baseUrl: config.watcherUrl });
+        result = await listMetas(config, watcher);
     }
     catch {
         return [
             '> **ACTION REQUIRED: jeeves-watcher is unreachable.**',
             '> The jeeves-meta synthesis engine requires a running jeeves-watcher service.',
-            `> The watcher API at ${watcherUrl} is down or not configured.`,
+            '> The watcher API at ' +
+                config.watcherUrl +
+                ' is down or not configured.',
             '>',
             "> **Read the `jeeves-meta` skill's Bootstrap section immediately**",
             '> for setup instructions. Do not attempt synthesis until watcher is available.',
         ].join('\n');
     }
-    if (entities.length === 0) {
+    if (result.entries.length === 0) {
         return [
             '> **ACTION REQUIRED: No synthesis entities found.**',
             '> The watcher is running but no `.meta/` directories were discovered',
@@ -761,55 +703,7 @@ async function generateMetaMenu(watcherUrl) {
             '> on creating `.meta/` directories and configuring watch paths.',
         ].join('\n');
     }
-    // Compute stats
-    const now = Math.floor(Date.now() / 1000);
-    let staleCount = 0;
-    let errorCount = 0;
-    let neverSynthesized = 0;
-    let totalArchTokens = 0;
-    let totalBuilderTokens = 0;
-    let totalCriticTokens = 0;
-    let stalestPath = '';
-    let stalestAge = 0;
-    let lastSynthPath = '';
-    let lastSynthUnix = 0;
-    for (const e of entities) {
-        const generatedAt = e['generated_at_unix'];
-        const hasError = e['has_error'];
-        const archTokens = e['synth_architect_tokens'];
-        const builderTokens = e['synth_builder_tokens'];
-        const criticTokens = e['synth_critic_tokens'];
-        if (!generatedAt) {
-            neverSynthesized++;
-            staleCount++;
-            if (!isFinite(stalestAge)) ;
-            else {
-                stalestAge = Infinity;
-                stalestPath = e.file_path;
-            }
-        }
-        else {
-            const age = now - generatedAt;
-            if (age > 0)
-                staleCount++;
-            if (age > stalestAge && isFinite(age)) {
-                stalestAge = age;
-                stalestPath = e.file_path;
-            }
-            if (generatedAt > lastSynthUnix) {
-                lastSynthUnix = generatedAt;
-                lastSynthPath = e.file_path;
-            }
-        }
-        if (hasError)
-            errorCount++;
-        if (archTokens)
-            totalArchTokens += archTokens;
-        if (builderTokens)
-            totalBuilderTokens += builderTokens;
-        if (criticTokens)
-            totalCriticTokens += criticTokens;
-    }
+    const { summary, entries } = result;
     const formatAge = (seconds) => {
         if (!isFinite(seconds))
             return 'never synthesized';
@@ -819,25 +713,42 @@ async function generateMetaMenu(watcherUrl) {
             return Math.round(seconds / 3600).toString() + 'h';
         return Math.round(seconds / 86400).toString() + 'd';
     };
+    // Find stalest age for display
+    let stalestAge = 0;
+    for (const e of entries) {
+        if (e.stalenessSeconds > stalestAge)
+            stalestAge = e.stalenessSeconds;
+    }
+    const stalestDisplay = summary.stalestPath
+        ? summary.stalestPath + ' (' + formatAge(stalestAge) + ')'
+        : 'n/a';
+    const lastSynthDisplay = summary.lastSynthesizedAt
+        ? (summary.lastSynthesizedPath ?? '') +
+            ' (' +
+            summary.lastSynthesizedAt +
+            ')'
+        : 'n/a';
     const lines = [
-        `The jeeves-meta synthesis engine manages ${entities.length.toString()} meta entities.`,
+        'The jeeves-meta synthesis engine manages ' +
+            entries.length.toString() +
+            ' meta entities.',
         '',
         '### Entity Summary',
         '| Metric | Value |',
         '|--------|-------|',
-        `| Total | ${entities.length.toString()} |`,
-        `| Stale | ${staleCount.toString()} |`,
-        `| Errors | ${errorCount.toString()} |`,
-        `| Never synthesized | ${neverSynthesized.toString()} |`,
-        `| Stalest | ${stalestPath ? stalestPath + ' (' + formatAge(stalestAge) + ')' : 'n/a'} |`,
-        `| Last synthesized | ${lastSynthPath ? lastSynthPath + ' (' + new Date(lastSynthUnix * 1000).toISOString() + ')' : 'n/a'} |`,
+        '| Total | ' + summary.total.toString() + ' |',
+        '| Stale | ' + summary.stale.toString() + ' |',
+        '| Errors | ' + summary.errors.toString() + ' |',
+        '| Never synthesized | ' + summary.neverSynthesized.toString() + ' |',
+        '| Stalest | ' + stalestDisplay + ' |',
+        '| Last synthesized | ' + lastSynthDisplay + ' |',
         '',
         '### Token Usage (cumulative)',
         '| Step | Tokens |',
         '|------|--------|',
-        `| Architect | ${totalArchTokens.toLocaleString()} |`,
-        `| Builder | ${totalBuilderTokens.toLocaleString()} |`,
-        `| Critic | ${totalCriticTokens.toLocaleString()} |`,
+        '| Architect | ' + summary.tokens.architect.toLocaleString() + ' |',
+        '| Builder | ' + summary.tokens.builder.toLocaleString() + ' |',
+        '| Critic | ' + summary.tokens.critic.toLocaleString() + ' |',
         '',
         '### Tools',
         '| Tool | Description |',
@@ -926,8 +837,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);
     if (menu === lastWrittenMenu) {
         return false;
     }
@@ -955,10 +866,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 +878,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 +901,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/src/promptInjection.d.ts

@@ -6,6 +6,7 @@
  *
  * @module promptInjection
  */
+import { type SynthConfig } from '@karmaniverous/jeeves-meta';
 /**
  * Generate the Meta menu Markdown for TOOLS.md.
  *
@@ -14,7 +15,7 @@
  * 2. No entities found - ACTION REQUIRED with setup guidance
  * 3. Healthy - entity stats + tool listing + skill reference
  *
- * @param watcherUrl - Watcher API base URL.
+ * @param config - Full synth config (for listMetas and watcherUrl).
  * @returns Markdown string for the Meta section.
  */
-export declare function generateMetaMenu(watcherUrl: string): Promise<string>;
+export declare function generateMetaMenu(config: SynthConfig): 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.1",
+  "version": "0.1.3",
   "skills": [
     "dist/skills/jeeves-meta"
   ],

package/package.json

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