@karmaniverous/jeeves-meta 0.12.0 → 0.12.2

package/dist/index.js

@@ -13,9 +13,9 @@ import require$$2 from 'events';
 import vm from 'vm';
 import * as commander from 'commander';
 import { tmpdir } from 'node:os';
-import 'node:child_process';
 import { z } from 'zod';
-import { createHash, randomUUID } from 'node:crypto';
+import 'node:child_process';
+import { randomUUID, createHash } from 'node:crypto';
 import pino from 'pino';
 import Handlebars from 'handlebars';
 import { Cron } from 'croner';
@@ -7684,12 +7684,17 @@ const jeevesComponentDescriptorSchema = z.object({
         .optional(),
     /**
      * Returns command + args for launching the service process.
-     * Consumed by `start` CLI command and `service install`.
+     * Consumed by `service install`.
      */
     startCommand: z.function({
         input: [z.string()],
         output: z.array(z.string()),
     }),
+    /** In-process service entry point for the CLI `start` command. */
+    run: z.function({
+        input: [z.string()],
+        output: z.promise(z.void()),
+    }),
     /** TOOLS.md section name (e.g., 'Watcher'). */
     sectionId: z.string().min(1, 'sectionId must be a non-empty string'),
     /** Refresh interval in seconds (must be a prime number). */
@@ -8265,49 +8270,6 @@ function loadServiceConfig(configPath) {
     return serviceConfigSchema.parse(raw);
 }
 
-/**
- * Jeeves component descriptor for jeeves-meta.
- *
- * Single source of truth consumed by the service CLI, plugin writer, and
- * config-apply pipeline.
- *
- * @module descriptor
- */
-/**
- * Parsed jeeves-meta component descriptor.
- */
-const metaDescriptor = jeevesComponentDescriptorSchema.parse({
-    name: 'meta',
-    version: SERVICE_VERSION,
-    servicePackage: '@karmaniverous/jeeves-meta',
-    pluginPackage: '@karmaniverous/jeeves-meta-openclaw',
-    defaultPort: 1938,
-    // The runtime Zod custom validator only checks for a .parse() method.
-    // Use unknown cast to bridge the Zod v4 (service) → v3 (core SDK) type gap.
-    configSchema: serviceConfigSchema,
-    configFileName: 'config.json',
-    initTemplate: () => serviceConfigSchema.parse({
-        watcherUrl: 'http://127.0.0.1:1936',
-    }),
-    onConfigApply: (merged) => {
-        const parsed = serviceConfigSchema.parse(merged);
-        applyHotReloadedConfig(parsed);
-        return Promise.resolve();
-    },
-    startCommand: (configPath) => [
-        'node',
-        'dist/cli.js',
-        'start',
-        '-c',
-        configPath,
-    ],
-    sectionId: 'Meta',
-    refreshIntervalSeconds: 73,
-    generateToolsContent: () => '',
-    dependencies: { hard: ['watcher'], soft: [] },
-    customCliCommands: registerCustomCliCommands,
-});
-
 /**
  * Compute summary statistics from an array of MetaEntry objects.
  *
@@ -8862,67 +8824,6 @@ function getDeltaFiles(generatedAt, scopeFiles) {
     return filterModifiedAfter(scopeFiles, new Date(generatedAt).getTime());
 }
 
-/**
- * Exponential moving average helper for token tracking.
- *
- * @module ema
- */
-const DEFAULT_DECAY = 0.3;
-/**
- * Compute exponential moving average.
- *
- * @param current - New observation.
- * @param previous - Previous EMA value, or undefined for first observation.
- * @param decay - Decay factor (0-1). Higher = more weight on new value. Default 0.3.
- * @returns Updated EMA.
- */
-function computeEma(current, previous, decay = DEFAULT_DECAY) {
-    if (previous === undefined)
-        return current;
-    return decay * current + (1 - decay) * previous;
-}
-
-/**
- * Shared error utilities.
- *
- * @module errors
- */
-/**
- * Wrap an unknown caught value into a MetaError.
- *
- * @param step - Which synthesis step failed.
- * @param err - The caught error value.
- * @param code - Error classification code.
- * @returns A structured MetaError.
- */
-function toMetaError(step, err, code = 'FAILED') {
-    return {
-        step,
-        code,
-        message: err instanceof Error ? err.message : String(err),
-    };
-}
-
-/**
- * Compute a structure hash from a sorted file listing.
- *
- * Used to detect when directory structure changes, triggering
- * an architect re-run.
- *
- * @module structureHash
- */
-/**
- * Compute a SHA-256 hash of a sorted file listing.
- *
- * @param filePaths - Array of file paths in scope.
- * @returns Hex-encoded SHA-256 hash of the sorted, newline-joined paths.
- */
-function computeStructureHash(filePaths) {
-    const sorted = [...filePaths].sort();
-    const content = sorted.join('\n');
-    return createHash('sha256').update(content).digest('hex');
-}
-
 /** Sleep for a given number of milliseconds. */
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -9460,6 +9361,26 @@ function buildCriticTask(ctx, meta, config) {
     return compileTemplate(sections.join('\n'), buildTemplateContext(ctx, meta, config));
 }
 
+/**
+ * Exponential moving average helper for token tracking.
+ *
+ * @module ema
+ */
+const DEFAULT_DECAY = 0.3;
+/**
+ * Compute exponential moving average.
+ *
+ * @param current - New observation.
+ * @param previous - Previous EMA value, or undefined for first observation.
+ * @param decay - Decay factor (0-1). Higher = more weight on new value. Default 0.3.
+ * @returns Updated EMA.
+ */
+function computeEma(current, previous, decay = DEFAULT_DECAY) {
+    if (previous === undefined)
+        return current;
+    return decay * current + (1 - decay) * previous;
+}
+
 /**
  * Structured error from a synthesis step failure.
  *
@@ -9890,6 +9811,47 @@ function computeStalenessScore(stalenessSeconds, depth, emphasis, depthWeight) {
     return Math.min(1, (stalenessSeconds * depthFactor * emphasis) / (30 * 86400));
 }
 
+/**
+ * Shared error utilities.
+ *
+ * @module errors
+ */
+/**
+ * Wrap an unknown caught value into a MetaError.
+ *
+ * @param step - Which synthesis step failed.
+ * @param err - The caught error value.
+ * @param code - Error classification code.
+ * @returns A structured MetaError.
+ */
+function toMetaError(step, err, code = 'FAILED') {
+    return {
+        step,
+        code,
+        message: err instanceof Error ? err.message : String(err),
+    };
+}
+
+/**
+ * Compute a structure hash from a sorted file listing.
+ *
+ * Used to detect when directory structure changes, triggering
+ * an architect re-run.
+ *
+ * @module structureHash
+ */
+/**
+ * Compute a SHA-256 hash of a sorted file listing.
+ *
+ * @param filePaths - Array of file paths in scope.
+ * @returns Hex-encoded SHA-256 hash of the sorted, newline-joined paths.
+ */
+function computeStructureHash(filePaths) {
+    const sorted = [...filePaths].sort();
+    const content = sorted.join('\n');
+    return createHash('sha256').update(content).digest('hex');
+}
+
 /**
  * Lock-staged cycle finalization: write to .lock, copy to meta.json, archive, prune.
  *
@@ -10516,309 +10478,35 @@ class ProgressReporter {
 }
 
 /**
- * Core seed logic — create a .meta/ directory with initial meta.json.
- *
- * Shared between the POST /seed route handler and the auto-seed pass.
- *
- * @module seed/createMeta
- */
-/**
- * Create a .meta/ directory with an initial meta.json.
- *
- * Does NOT check for existing .meta/ — caller is responsible for that guard.
- *
- * @param ownerPath - The owner directory path.
- * @param options - Optional cross-refs and steering prompt.
- * @returns The meta directory path and generated ID.
- */
-async function createMeta(ownerPath, options) {
-    const metaDir = resolveMetaDir(ownerPath);
-    await mkdir(metaDir, { recursive: true });
-    const _id = randomUUID();
-    const metaJson = { _id };
-    if (options?.crossRefs !== undefined)
-        metaJson._crossRefs = options.crossRefs;
-    if (options?.steer !== undefined)
-        metaJson._steer = options.steer;
-    const metaJsonPath = join(metaDir, 'meta.json');
-    await writeFile(metaJsonPath, JSON.stringify(metaJson, null, 2) + '\n');
-    return { metaDir, _id };
-}
-/**
- * Check if a .meta/ directory already exists for an owner path.
- *
- * @param ownerPath - The owner directory path.
- * @returns True if .meta/ already exists.
- */
-function metaExists(ownerPath) {
-    return existsSync(resolveMetaDir(ownerPath));
-}
-
-/**
- * Auto-seed pass — scan for directories matching policy rules and seed them.
- *
- * Runs before discovery in each scheduler tick. For each auto-seed rule,
- * walks matching directories via the watcher and creates .meta/ directories
- * for those that don't already have one.
+ * Single-threaded synthesis queue with priority support and deduplication.
  *
- * Rules are processed in array order; last match wins for steer/crossRefs.
+ * The scheduler enqueues the stalest candidate each tick. HTTP-triggered
+ * synthesis requests get priority (inserted at front). A path appears at
+ * most once in the queue; re-triggering returns the current position.
  *
- * @module seed/autoSeed
+ * @module queue
  */
+const DEPTH_WARNING_THRESHOLD = 3;
 /**
- * Extract parent directory paths from watcher walk results.
+ * Single-threaded synthesis queue.
  *
- * Walk returns file paths; we need the unique set of immediate parent
- * directories that could be owners.
+ * Only one synthesis runs at a time. Priority items are inserted at the
+ * front of the queue. Duplicate paths are rejected with their current
+ * position returned.
  */
-function extractDirectories(filePaths) {
-    const dirs = new Set();
-    for (const fp of filePaths) {
-        const dir = posix.dirname(fp);
-        if (dir !== '.' && dir !== '/') {
-            dirs.add(dir);
-        }
-    }
-    return [...dirs];
-}
-/**
- * Run the auto-seed pass: apply policy rules and create missing metas.
- *
- * @param rules - Auto-seed policy rules from config.
- * @param watcher - Watcher client for filesystem enumeration.
- * @param logger - Logger for reporting seed actions.
- * @returns Summary of what was seeded.
- */
-async function autoSeedPass(rules, watcher, logger) {
-    if (rules.length === 0)
-        return { seeded: 0, paths: [] };
-    // Build a map of ownerPath → effective options (last match wins)
-    const candidates = new Map();
-    for (const rule of rules) {
-        const files = await watcher.walk([rule.match]);
-        const dirs = extractDirectories(files);
-        for (const dir of dirs) {
-            candidates.set(dir, {
-                steer: rule.steer,
-                crossRefs: rule.crossRefs,
-            });
-        }
-    }
-    // Filter out paths that already have .meta/meta.json
-    const toSeed = [];
-    for (const [path, opts] of candidates) {
-        if (!metaExists(path)) {
-            toSeed.push({ path, ...opts });
-        }
-    }
-    // Seed remaining
-    const seededPaths = [];
-    for (const candidate of toSeed) {
-        try {
-            await createMeta(candidate.path, {
-                steer: candidate.steer,
-                crossRefs: candidate.crossRefs,
-            });
-            seededPaths.push(candidate.path);
-            logger?.info({ path: candidate.path }, 'auto-seeded meta');
-        }
-        catch (err) {
-            logger?.warn({
-                path: candidate.path,
-                err: err instanceof Error ? err.message : String(err),
-            }, 'auto-seed failed for path');
-        }
-    }
-    return { seeded: seededPaths.length, paths: seededPaths };
-}
-
-/**
- * Croner-based scheduler that discovers the stalest meta candidate each tick
- * and enqueues it for synthesis.
- *
- * @module scheduler
- */
-const MAX_BACKOFF_MULTIPLIER = 4;
-/**
- * Periodic scheduler that discovers stale meta candidates and enqueues them.
- *
- * Supports adaptive backoff when no candidates are found and hot-reloadable
- * cron expressions via {@link Scheduler.updateSchedule}.
- */
-class Scheduler {
-    job = null;
-    backoffMultiplier = 1;
-    tickCount = 0;
-    config;
-    queue;
-    logger;
-    watcher;
-    registrar = null;
-    currentExpression;
-    constructor(config, queue, logger, watcher) {
-        this.config = config;
-        this.queue = queue;
-        this.logger = logger;
-        this.watcher = watcher;
-        this.currentExpression = config.schedule;
-    }
-    /** Set the rule registrar for watcher restart detection. */
-    setRegistrar(registrar) {
-        this.registrar = registrar;
-    }
-    /** Start the cron job. */
-    start() {
-        if (this.job)
-            return;
-        this.job = new Cron(this.currentExpression, () => {
-            void this.tick();
-        });
-        this.logger.info({ schedule: this.currentExpression }, 'Scheduler started');
-    }
-    /** Stop the cron job. */
-    stop() {
-        if (!this.job)
-            return;
-        this.job.stop();
-        this.job = null;
-        this.backoffMultiplier = 1;
-        this.logger.info('Scheduler stopped');
-    }
-    /** Hot-reload the cron schedule expression. */
-    updateSchedule(expression) {
-        this.currentExpression = expression;
-        if (this.job) {
-            this.job.stop();
-            this.job = new Cron(expression, () => {
-                void this.tick();
-            });
-            this.logger.info({ schedule: expression }, 'Schedule updated');
-        }
-    }
-    /** Reset backoff multiplier (call after successful synthesis). */
-    resetBackoff() {
-        if (this.backoffMultiplier > 1) {
-            this.logger.debug('Backoff reset after successful synthesis');
-        }
-        this.backoffMultiplier = 1;
-    }
-    /** Whether the scheduler is currently running. */
-    get isRunning() {
-        return this.job !== null;
-    }
-    /** Next scheduled tick time, or null if not running. */
-    get nextRunAt() {
-        if (!this.job)
-            return null;
-        return this.job.nextRun() ?? null;
-    }
-    /**
-     * Single tick: discover stalest candidate and enqueue it.
-     *
-     * Skips if the queue is currently processing. Applies adaptive backoff
-     * when no candidates are found.
-     */
-    async tick() {
-        this.tickCount++;
-        // Apply backoff: skip ticks when backing off
-        if (this.backoffMultiplier > 1 &&
-            this.tickCount % this.backoffMultiplier !== 0) {
-            this.logger.trace({
-                backoffMultiplier: this.backoffMultiplier,
-                tickCount: this.tickCount,
-            }, 'Skipping tick (backoff)');
-            return;
-        }
-        // Auto-seed pass: create .meta/ for matching directories
-        if (this.config.autoSeed.length > 0) {
-            try {
-                const result = await autoSeedPass(this.config.autoSeed, this.watcher, this.logger);
-                if (result.seeded > 0) {
-                    this.logger.info({ seeded: result.seeded }, 'Auto-seed pass completed');
-                }
-            }
-            catch (err) {
-                this.logger.warn({ err }, 'Auto-seed pass failed');
-            }
-        }
-        const candidate = await this.discoverStalest();
-        if (!candidate) {
-            this.backoffMultiplier = Math.min(this.backoffMultiplier * 2, MAX_BACKOFF_MULTIPLIER);
-            this.logger.debug({ backoffMultiplier: this.backoffMultiplier }, 'No stale candidates found, increasing backoff');
-            return;
-        }
-        this.queue.enqueue(candidate);
-        this.logger.info({ path: candidate }, 'Enqueued stale candidate');
-        // Opportunistic watcher restart detection
-        if (this.registrar) {
-            try {
-                const statusRes = await fetch(new URL('/status', this.config.watcherUrl), {
-                    signal: AbortSignal.timeout(3000),
-                });
-                if (statusRes.ok) {
-                    const status = (await statusRes.json());
-                    if (typeof status.uptime === 'number') {
-                        await this.registrar.checkAndReregister(status.uptime);
-                    }
-                }
-            }
-            catch {
-                // Watcher unreachable — skip uptime check
-            }
-        }
-    }
-    /**
-     * Discover the stalest meta candidate via watcher.
-     */
-    async discoverStalest() {
-        try {
-            const result = await listMetas(this.config, this.watcher);
-            const stale = result.entries
-                .filter((e) => e.stalenessSeconds > 0)
-                .map((e) => ({
-                node: e.node,
-                meta: e.meta,
-                actualStaleness: e.stalenessSeconds,
-            }));
-            return discoverStalestPath(stale, this.config.depthWeight);
-        }
-        catch (err) {
-            this.logger.warn({ err }, 'Failed to discover stalest candidate');
-            return null;
-        }
-    }
-}
-
-/**
- * Single-threaded synthesis queue with priority support and deduplication.
- *
- * The scheduler enqueues the stalest candidate each tick. HTTP-triggered
- * synthesis requests get priority (inserted at front). A path appears at
- * most once in the queue; re-triggering returns the current position.
- *
- * @module queue
- */
-const DEPTH_WARNING_THRESHOLD = 3;
-/**
- * Single-threaded synthesis queue.
- *
- * Only one synthesis runs at a time. Priority items are inserted at the
- * front of the queue. Duplicate paths are rejected with their current
- * position returned.
- */
-class SynthesisQueue {
-    queue = [];
-    currentItem = null;
-    processing = false;
-    logger;
-    onEnqueueCallback = null;
-    /**
-     * Create a new SynthesisQueue.
-     *
-     * @param logger - Pino logger instance.
-     */
-    constructor(logger) {
-        this.logger = logger;
+class SynthesisQueue {
+    queue = [];
+    currentItem = null;
+    processing = false;
+    logger;
+    onEnqueueCallback = null;
+    /**
+     * Create a new SynthesisQueue.
+     *
+     * @param logger - Pino logger instance.
+     */
+    constructor(logger) {
+        this.logger = logger;
     }
     /**
      * Set a callback to invoke when a new (non-duplicate) item is enqueued.
@@ -10973,242 +10661,856 @@ class SynthesisQueue {
 }
 
 /**
- * GET /config — query service configuration with optional JSONPath.
+ * Periodic watcher health check for rule registration resilience.
  *
- * Replaces the old GET /config/validate endpoint with the core SDK's
- * `createConfigQueryHandler()` for JSONPath support.
+ * Pings watcher `/status` on a configurable interval, detects restarts
+ * (uptime decrease), and re-registers virtual rules automatically.
+ * Independent of the synthesis scheduler.
  *
- * @module routes/config
+ * @module rules/healthCheck
  */
-/** Return a sanitized copy of the config (redact gatewayApiKey). */
-function sanitizeConfig(config) {
-    return {
-        ...config,
-        gatewayApiKey: config.gatewayApiKey ? '[REDACTED]' : undefined,
-    };
-}
-function registerConfigRoute(app, deps) {
-    const configHandler = createConfigQueryHandler(() => sanitizeConfig(deps.config));
-    app.get('/config', async (request, reply) => {
-        const { path } = request.query;
-        const result = await configHandler({ path });
-        return reply.status(result.status).send(result.body);
-    });
-}
-
-/**
- * POST /config/apply — apply a config patch via the core SDK handler.
- *
- * @module routes/configApply
- */
-/** Register the POST /config/apply route. */
-function registerConfigApplyRoute(app) {
-    const handler = createConfigApplyHandler(metaDescriptor);
-    app.post('/config/apply', async (request, reply) => {
-        const result = await handler(request.body);
-        return reply.status(result.status).send(result.body);
-    });
-}
-
 /**
- * GET /metas — list metas with optional filters.
- * GET /metas/:path — single meta detail.
+ * Manages the periodic watcher health check loop.
  *
- * @module routes/metas
+ * Starts a `setInterval` that pings the watcher and delegates
+ * restart detection to `RuleRegistrar.checkAndReregister()`.
  */
-const metasQuerySchema = z.object({
-    pathPrefix: z.string().optional(),
-    hasError: z
-        .enum(['true', 'false'])
-        .transform((v) => v === 'true')
-        .optional(),
-    staleHours: z
-        .string()
-        .transform(Number)
-        .pipe(z.number().positive())
-        .optional(),
-    neverSynthesized: z
-        .enum(['true', 'false'])
-        .transform((v) => v === 'true')
-        .optional(),
-    locked: z
-        .enum(['true', 'false'])
-        .transform((v) => v === 'true')
-        .optional(),
-    fields: z.string().optional(),
-});
-const metaDetailQuerySchema = z.object({
-    fields: z.string().optional(),
-    includeArchive: z
-        .union([
-        z.enum(['true', 'false']).transform((v) => v === 'true'),
-        z.string().transform(Number).pipe(z.number().int().nonnegative()),
-    ])
-        .optional(),
-});
-function registerMetasRoutes(app, deps) {
-    app.get('/metas', async (request) => {
-        const query = metasQuerySchema.parse(request.query);
-        const { config, watcher } = deps;
-        const result = await listMetas(config, watcher);
-        let entries = result.entries;
-        // Apply filters
-        if (query.pathPrefix) {
-            entries = entries.filter((e) => e.path.includes(query.pathPrefix));
-        }
-        if (query.hasError !== undefined) {
-            entries = entries.filter((e) => e.hasError === query.hasError);
-        }
-        if (query.neverSynthesized !== undefined) {
-            entries = entries.filter((e) => (e.lastSynthesized === null) === query.neverSynthesized);
+class WatcherHealthCheck {
+    watcherUrl;
+    intervalMs;
+    registrar;
+    logger;
+    handle = null;
+    constructor(opts) {
+        this.watcherUrl = opts.watcherUrl.replace(/\/+$/, '');
+        this.intervalMs = opts.intervalMs;
+        this.registrar = opts.registrar;
+        this.logger = opts.logger;
+    }
+    /** Start the periodic health check. No-op if intervalMs is 0. */
+    start() {
+        if (this.intervalMs <= 0) {
+            this.logger.info('Watcher health check disabled (interval = 0)');
+            return;
         }
-        if (query.locked !== undefined) {
-            entries = entries.filter((e) => e.locked === query.locked);
+        this.handle = setInterval(() => {
+            void this.check();
+        }, this.intervalMs);
+        // Don't prevent process exit
+        if (typeof this.handle === 'object' && 'unref' in this.handle) {
+            this.handle.unref();
         }
-        if (typeof query.staleHours === 'number') {
-            entries = entries.filter((e) => e.stalenessSeconds >= query.staleHours * 3600);
+        this.logger.info({ intervalMs: this.intervalMs }, 'Watcher health check started');
+    }
+    /** Stop the periodic health check. */
+    stop() {
+        if (this.handle) {
+            clearInterval(this.handle);
+            this.handle = null;
         }
-        // Summary (computed from filtered entries)
-        const summary = computeSummary(entries, config.depthWeight);
-        // Field projection
-        const fieldList = query.fields?.split(',');
-        const defaultFields = [
-            'path',
-            'depth',
-            'emphasis',
-            'stalenessSeconds',
-            'lastSynthesized',
-            'hasError',
-            'locked',
-            'architectTokens',
-            'builderTokens',
-            'criticTokens',
-        ];
-        const projectedFields = fieldList ?? defaultFields;
-        const metas = entries.map((e) => {
-            const full = {
-                path: e.path,
-                depth: e.depth,
-                emphasis: e.emphasis,
-                stalenessSeconds: e.stalenessSeconds === Infinity
-                    ? null
-                    : Math.round(e.stalenessSeconds),
-                lastSynthesized: e.lastSynthesized,
-                hasError: e.hasError,
-                locked: e.locked,
-                architectTokens: e.architectTokens,
-                builderTokens: e.builderTokens,
-                criticTokens: e.criticTokens,
-            };
-            const projected = {};
-            for (const f of projectedFields) {
-                if (f in full)
-                    projected[f] = full[f];
-            }
-            return projected;
-        });
-        return { summary, metas };
-    });
-    app.get('/metas/:path', async (request, reply) => {
-        const query = metaDetailQuerySchema.parse(request.query);
-        const { config, watcher } = deps;
-        const targetPath = normalizePath(decodeURIComponent(request.params.path));
-        const result = await listMetas(config, watcher);
-        const targetNode = findNode(result.tree, targetPath);
-        if (!targetNode) {
-            return reply.status(404).send({
-                error: 'NOT_FOUND',
-                message: 'Meta path not found: ' + targetPath,
+    }
+    /** Single health check iteration. */
+    async check() {
+        try {
+            const res = await fetch(this.watcherUrl + '/status', {
+                signal: AbortSignal.timeout(5000),
             });
-        }
-        const meta = JSON.parse(await readFile(join(targetNode.metaPath, 'meta.json'), 'utf8'));
-        // Field projection
-        const defaultExclude = new Set([
-            '_architect',
-            '_builder',
-            '_critic',
-            '_content',
-            '_feedback',
-        ]);
-        const fieldList = query.fields?.split(',');
-        const projectMeta = (m) => {
-            if (fieldList) {
-                const r = {};
-                for (const f of fieldList)
-                    r[f] = m[f];
-                return r;
+            if (!res.ok) {
+                this.logger.warn({ status: res.status }, 'Watcher health check: non-OK response');
+                return;
             }
-            const r = {};
-            for (const [k, v] of Object.entries(m)) {
-                if (!defaultExclude.has(k))
-                    r[k] = v;
+            const data = (await res.json());
+            // If rules were never successfully registered (startup failure),
+            // attempt registration now that the watcher is reachable.
+            if (!this.registrar.isRegistered) {
+                this.logger.info('Rules not registered — attempting registration');
+                await this.registrar.register();
             }
-            return r;
-        };
-        // Compute scope
-        const { scopeFiles, allFiles } = await getScopeFiles(targetNode, watcher);
-        // Compute staleness
-        const metaTyped = meta;
-        const staleSeconds = metaTyped._generatedAt
-            ? Math.round((Date.now() - new Date(metaTyped._generatedAt).getTime()) / 1000)
-            : null;
-        const score = computeStalenessScore(staleSeconds, metaTyped._depth ?? 0, metaTyped._emphasis ?? 1, config.depthWeight);
-        const response = {
-            path: targetNode.metaPath,
-            meta: projectMeta(meta),
-            scope: {
-                ownedFiles: scopeFiles.length,
-                childMetas: targetNode.children.length,
-                totalFiles: allFiles.length,
-            },
-            staleness: {
-                seconds: staleSeconds,
-                score: Math.round(score * 100) / 100,
-            },
-        };
-        // Cross-refs status
-        const crossRefsRaw = meta._crossRefs;
-        if (Array.isArray(crossRefsRaw) && crossRefsRaw.length > 0) {
-            response.crossRefs = await Promise.all(crossRefsRaw.map(async (refPath) => {
-                const rp = String(refPath);
-                const refMetaFile = join(rp, '.meta', 'meta.json');
-                try {
-                    const refMeta = JSON.parse(await readFile(refMetaFile, 'utf8'));
-                    return {
-                        path: rp,
-                        status: 'resolved',
-                        hasContent: Boolean(refMeta._content),
-                    };
-                }
-                catch {
-                    return { path: rp, status: 'missing' };
-                }
-            }));
+            await this.registrar.checkAndReregister(data.uptime);
         }
-        // Archive
-        if (query.includeArchive) {
-            const limit = typeof query.includeArchive === 'number'
-                ? query.includeArchive
-                : undefined;
-            try {
-                response.archive = await readArchiveFromWatcher(watcher, targetNode.metaPath, config.metaArchiveProperty, limit, projectMeta);
-            }
-            catch {
-                response.archive = await readArchiveFromDisk(targetNode.metaPath, limit, projectMeta);
-            }
+        catch (err) {
+            this.logger.debug({ err }, 'Watcher health check: unreachable (expected during startup)');
         }
-        return response;
-    });
+    }
 }
 
 /**
- * GET /preview — dry-run synthesis preview.
+ * Virtual rule registration with jeeves-watcher.
  *
- * @module routes/preview
+ * Service registers inference rules at startup (with retry) and
+ * re-registers opportunistically when watcher restart is detected.
+ *
+ * @module rules
  */
-function registerPreviewRoute(app, deps) {
-    app.get('/preview', async (request, reply) => {
-        const { config, watcher } = deps;
+const SOURCE = 'jeeves-meta';
+const MAX_RETRIES = 10;
+const RETRY_BASE_MS = 2000;
+/**
+ * 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 the three virtual rule definitions. */
+function buildMetaRules(config) {
+    return [
+        {
+            name: 'meta-current',
+            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),
+                        meta_id: { type: 'string', set: '{{json._id}}' },
+                        meta_steer: { type: 'string', set: '{{json._steer}}' },
+                        meta_depth: { type: 'number', set: '{{json._depth}}' },
+                        meta_emphasis: { type: 'number', set: '{{json._emphasis}}' },
+                        meta_synthesis_count: {
+                            type: 'integer',
+                            set: '{{json._synthesisCount}}',
+                        },
+                        meta_structure_hash: {
+                            type: 'string',
+                            set: '{{json._structureHash}}',
+                        },
+                        meta_architect_tokens: {
+                            type: 'integer',
+                            set: '{{json._architectTokens}}',
+                        },
+                        meta_builder_tokens: {
+                            type: 'integer',
+                            set: '{{json._builderTokens}}',
+                        },
+                        meta_critic_tokens: {
+                            type: 'integer',
+                            set: '{{json._criticTokens}}',
+                        },
+                        meta_error_step: {
+                            type: 'string',
+                            set: '{{json._error.step}}',
+                        },
+                        generated_at: {
+                            type: 'string',
+                            set: '{{json._generatedAt}}',
+                        },
+                        generated_at_unix: {
+                            type: 'integer',
+                            set: '{{toUnix json._generatedAt}}',
+                        },
+                        has_error: {
+                            type: 'boolean',
+                            set: '{{#if json._error}}true{{else}}false{{/if}}',
+                        },
+                    },
+                },
+            ],
+            render: {
+                frontmatter: [
+                    'meta_id',
+                    'generated_at',
+                    '*',
+                    '!_*',
+                    '!json',
+                    '!file',
+                    '!has_error',
+                ],
+                body: [{ path: 'json._content', heading: 1, label: 'Synthesis' }],
+            },
+            renderAs: 'md',
+        },
+        {
+            name: '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),
+                        meta_id: { type: 'string', set: '{{json._id}}' },
+                        archived: { type: 'boolean', set: 'true' },
+                        archived_at: { type: 'string', set: '{{json._archivedAt}}' },
+                    },
+                },
+            ],
+            render: {
+                frontmatter: ['meta_id', 'archived', 'archived_at'],
+                body: [
+                    {
+                        path: 'json._content',
+                        heading: 1,
+                        label: 'Synthesis (archived)',
+                    },
+                ],
+            },
+            renderAs: 'md',
+        },
+        {
+            name: 'meta-config',
+            description: 'jeeves-meta configuration file',
+            match: {
+                properties: {
+                    file: {
+                        properties: {
+                            path: { type: 'string', glob: '**/jeeves-meta.config.json' },
+                        },
+                    },
+                },
+            },
+            schema: ['base', { properties: { domains: { set: ['meta-config'] } } }],
+            render: {
+                frontmatter: [
+                    'watcherUrl',
+                    'gatewayUrl',
+                    'architectEvery',
+                    'depthWeight',
+                    'maxArchive',
+                    'maxLines',
+                ],
+                body: [
+                    {
+                        path: 'json.defaultArchitect',
+                        heading: 2,
+                        label: 'Default Architect Prompt',
+                    },
+                    {
+                        path: 'json.defaultCritic',
+                        heading: 2,
+                        label: 'Default Critic Prompt',
+                    },
+                ],
+            },
+            renderAs: 'md',
+        },
+    ];
+}
+/**
+ * Manages virtual rule registration with watcher.
+ *
+ * - Registers at startup with exponential retry
+ * - Tracks watcher uptime for restart detection
+ * - Re-registers opportunistically when uptime decreases
+ */
+class RuleRegistrar {
+    config;
+    logger;
+    watcherClient;
+    lastWatcherUptime = null;
+    registered = false;
+    constructor(config, logger, watcher) {
+        this.config = config;
+        this.logger = logger;
+        this.watcherClient = watcher;
+    }
+    /** Whether rules have been successfully registered. */
+    get isRegistered() {
+        return this.registered;
+    }
+    /**
+     * Register rules with watcher. Retries with exponential backoff.
+     * Non-blocking — logs errors but never throws.
+     */
+    async register() {
+        const rules = buildMetaRules(this.config);
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            try {
+                await this.watcherClient.registerRules(SOURCE, rules);
+                this.registered = true;
+                this.logger.info('Virtual rules registered with watcher');
+                return;
+            }
+            catch (err) {
+                const delayMs = RETRY_BASE_MS * Math.pow(2, attempt);
+                this.logger.warn({ attempt: attempt + 1, delayMs, err }, 'Rule registration failed, retrying');
+                await new Promise((r) => setTimeout(r, delayMs));
+            }
+        }
+        this.logger.error('Rule registration failed after max retries — service degraded');
+    }
+    /**
+     * Check watcher uptime and re-register if it decreased (restart detected).
+     *
+     * @param currentUptime - Current watcher uptime in seconds.
+     */
+    async checkAndReregister(currentUptime) {
+        if (this.lastWatcherUptime !== null &&
+            currentUptime < this.lastWatcherUptime) {
+            this.logger.info({ previous: this.lastWatcherUptime, current: currentUptime }, 'Watcher restart detected — re-registering rules');
+            this.registered = false;
+            await this.register();
+        }
+        this.lastWatcherUptime = currentUptime;
+    }
+}
+
+/**
+ * Post-registration verification of virtual rule application.
+ *
+ * After rules are registered with the watcher, verifies that .meta/meta.json
+ * files are discoverable via watcher walk (which depends on virtual rules
+ * being applied). Logs a warning if expected metas are not found.
+ *
+ * @module rules/verify
+ */
+/**
+ * Verify that virtual rules are applied to indexed .meta/meta.json files.
+ *
+ * Runs a discovery pass and logs the result. If no metas are found but
+ * the filesystem likely has some, logs a warning suggesting reindex.
+ *
+ * @param watcher - WatcherClient for discovery.
+ * @param logger - Logger for reporting results.
+ * @returns Number of metas discovered.
+ */
+async function verifyRuleApplication(watcher, logger) {
+    try {
+        const metaPaths = await discoverMetas(watcher);
+        if (metaPaths.length === 0) {
+            logger.warn({ count: 0 }, 'Post-registration verification: no .meta/meta.json files found via watcher walk. ' +
+                'Virtual rules may not be applied to indexed files. ' +
+                'If metas exist, a path-scoped reindex may be needed.');
+        }
+        else {
+            logger.info({ count: metaPaths.length }, 'Post-registration verification: metas discoverable');
+        }
+        return metaPaths.length;
+    }
+    catch (err) {
+        logger.warn({ err: err instanceof Error ? err.message : String(err) }, 'Post-registration verification failed (watcher may be unavailable)');
+        return 0;
+    }
+}
+
+/**
+ * Core seed logic — create a .meta/ directory with initial meta.json.
+ *
+ * Shared between the POST /seed route handler and the auto-seed pass.
+ *
+ * @module seed/createMeta
+ */
+/**
+ * Create a .meta/ directory with an initial meta.json.
+ *
+ * Does NOT check for existing .meta/ — caller is responsible for that guard.
+ *
+ * @param ownerPath - The owner directory path.
+ * @param options - Optional cross-refs and steering prompt.
+ * @returns The meta directory path and generated ID.
+ */
+async function createMeta(ownerPath, options) {
+    const metaDir = resolveMetaDir(ownerPath);
+    await mkdir(metaDir, { recursive: true });
+    const _id = randomUUID();
+    const metaJson = { _id };
+    if (options?.crossRefs !== undefined)
+        metaJson._crossRefs = options.crossRefs;
+    if (options?.steer !== undefined)
+        metaJson._steer = options.steer;
+    const metaJsonPath = join(metaDir, 'meta.json');
+    await writeFile(metaJsonPath, JSON.stringify(metaJson, null, 2) + '\n');
+    return { metaDir, _id };
+}
+/**
+ * Check if a .meta/ directory already exists for an owner path.
+ *
+ * @param ownerPath - The owner directory path.
+ * @returns True if .meta/ already exists.
+ */
+function metaExists(ownerPath) {
+    return existsSync(resolveMetaDir(ownerPath));
+}
+
+/**
+ * Auto-seed pass — scan for directories matching policy rules and seed them.
+ *
+ * Runs before discovery in each scheduler tick. For each auto-seed rule,
+ * walks matching directories via the watcher and creates .meta/ directories
+ * for those that don't already have one.
+ *
+ * Rules are processed in array order; last match wins for steer/crossRefs.
+ *
+ * @module seed/autoSeed
+ */
+/**
+ * Extract parent directory paths from watcher walk results.
+ *
+ * Walk returns file paths; we need the unique set of immediate parent
+ * directories that could be owners.
+ */
+function extractDirectories(filePaths) {
+    const dirs = new Set();
+    for (const fp of filePaths) {
+        const dir = posix.dirname(fp);
+        if (dir !== '.' && dir !== '/') {
+            dirs.add(dir);
+        }
+    }
+    return [...dirs];
+}
+/**
+ * Run the auto-seed pass: apply policy rules and create missing metas.
+ *
+ * @param rules - Auto-seed policy rules from config.
+ * @param watcher - Watcher client for filesystem enumeration.
+ * @param logger - Logger for reporting seed actions.
+ * @returns Summary of what was seeded.
+ */
+async function autoSeedPass(rules, watcher, logger) {
+    if (rules.length === 0)
+        return { seeded: 0, paths: [] };
+    // Build a map of ownerPath → effective options (last match wins)
+    const candidates = new Map();
+    for (const rule of rules) {
+        const files = await watcher.walk([rule.match]);
+        const dirs = extractDirectories(files);
+        for (const dir of dirs) {
+            candidates.set(dir, {
+                steer: rule.steer,
+                crossRefs: rule.crossRefs,
+            });
+        }
+    }
+    // Filter out paths that already have .meta/meta.json
+    const toSeed = [];
+    for (const [path, opts] of candidates) {
+        if (!metaExists(path)) {
+            toSeed.push({ path, ...opts });
+        }
+    }
+    // Seed remaining
+    const seededPaths = [];
+    for (const candidate of toSeed) {
+        try {
+            await createMeta(candidate.path, {
+                steer: candidate.steer,
+                crossRefs: candidate.crossRefs,
+            });
+            seededPaths.push(candidate.path);
+            logger?.info({ path: candidate.path }, 'auto-seeded meta');
+        }
+        catch (err) {
+            logger?.warn({
+                path: candidate.path,
+                err: err instanceof Error ? err.message : String(err),
+            }, 'auto-seed failed for path');
+        }
+    }
+    return { seeded: seededPaths.length, paths: seededPaths };
+}
+
+/**
+ * Croner-based scheduler that discovers the stalest meta candidate each tick
+ * and enqueues it for synthesis.
+ *
+ * @module scheduler
+ */
+const MAX_BACKOFF_MULTIPLIER = 4;
+/**
+ * Periodic scheduler that discovers stale meta candidates and enqueues them.
+ *
+ * Supports adaptive backoff when no candidates are found and hot-reloadable
+ * cron expressions via {@link Scheduler.updateSchedule}.
+ */
+class Scheduler {
+    job = null;
+    backoffMultiplier = 1;
+    tickCount = 0;
+    config;
+    queue;
+    logger;
+    watcher;
+    registrar = null;
+    currentExpression;
+    constructor(config, queue, logger, watcher) {
+        this.config = config;
+        this.queue = queue;
+        this.logger = logger;
+        this.watcher = watcher;
+        this.currentExpression = config.schedule;
+    }
+    /** Set the rule registrar for watcher restart detection. */
+    setRegistrar(registrar) {
+        this.registrar = registrar;
+    }
+    /** Start the cron job. */
+    start() {
+        if (this.job)
+            return;
+        this.job = new Cron(this.currentExpression, () => {
+            void this.tick();
+        });
+        this.logger.info({ schedule: this.currentExpression }, 'Scheduler started');
+    }
+    /** Stop the cron job. */
+    stop() {
+        if (!this.job)
+            return;
+        this.job.stop();
+        this.job = null;
+        this.backoffMultiplier = 1;
+        this.logger.info('Scheduler stopped');
+    }
+    /** Hot-reload the cron schedule expression. */
+    updateSchedule(expression) {
+        this.currentExpression = expression;
+        if (this.job) {
+            this.job.stop();
+            this.job = new Cron(expression, () => {
+                void this.tick();
+            });
+            this.logger.info({ schedule: expression }, 'Schedule updated');
+        }
+    }
+    /** Reset backoff multiplier (call after successful synthesis). */
+    resetBackoff() {
+        if (this.backoffMultiplier > 1) {
+            this.logger.debug('Backoff reset after successful synthesis');
+        }
+        this.backoffMultiplier = 1;
+    }
+    /** Whether the scheduler is currently running. */
+    get isRunning() {
+        return this.job !== null;
+    }
+    /** Next scheduled tick time, or null if not running. */
+    get nextRunAt() {
+        if (!this.job)
+            return null;
+        return this.job.nextRun() ?? null;
+    }
+    /**
+     * Single tick: discover stalest candidate and enqueue it.
+     *
+     * Skips if the queue is currently processing. Applies adaptive backoff
+     * when no candidates are found.
+     */
+    async tick() {
+        this.tickCount++;
+        // Apply backoff: skip ticks when backing off
+        if (this.backoffMultiplier > 1 &&
+            this.tickCount % this.backoffMultiplier !== 0) {
+            this.logger.trace({
+                backoffMultiplier: this.backoffMultiplier,
+                tickCount: this.tickCount,
+            }, 'Skipping tick (backoff)');
+            return;
+        }
+        // Auto-seed pass: create .meta/ for matching directories
+        if (this.config.autoSeed.length > 0) {
+            try {
+                const result = await autoSeedPass(this.config.autoSeed, this.watcher, this.logger);
+                if (result.seeded > 0) {
+                    this.logger.info({ seeded: result.seeded }, 'Auto-seed pass completed');
+                }
+            }
+            catch (err) {
+                this.logger.warn({ err }, 'Auto-seed pass failed');
+            }
+        }
+        const candidate = await this.discoverStalest();
+        if (!candidate) {
+            this.backoffMultiplier = Math.min(this.backoffMultiplier * 2, MAX_BACKOFF_MULTIPLIER);
+            this.logger.debug({ backoffMultiplier: this.backoffMultiplier }, 'No stale candidates found, increasing backoff');
+            return;
+        }
+        this.queue.enqueue(candidate);
+        this.logger.info({ path: candidate }, 'Enqueued stale candidate');
+        // Opportunistic watcher restart detection
+        if (this.registrar) {
+            try {
+                const statusRes = await fetch(new URL('/status', this.config.watcherUrl), {
+                    signal: AbortSignal.timeout(3000),
+                });
+                if (statusRes.ok) {
+                    const status = (await statusRes.json());
+                    if (typeof status.uptime === 'number') {
+                        await this.registrar.checkAndReregister(status.uptime);
+                    }
+                }
+            }
+            catch {
+                // Watcher unreachable — skip uptime check
+            }
+        }
+    }
+    /**
+     * Discover the stalest meta candidate via watcher.
+     */
+    async discoverStalest() {
+        try {
+            const result = await listMetas(this.config, this.watcher);
+            const stale = result.entries
+                .filter((e) => e.stalenessSeconds > 0)
+                .map((e) => ({
+                node: e.node,
+                meta: e.meta,
+                actualStaleness: e.stalenessSeconds,
+            }));
+            return discoverStalestPath(stale, this.config.depthWeight);
+        }
+        catch (err) {
+            this.logger.warn({ err }, 'Failed to discover stalest candidate');
+            return null;
+        }
+    }
+}
+
+/**
+ * GET /config — query service configuration with optional JSONPath.
+ *
+ * Replaces the old GET /config/validate endpoint with the core SDK's
+ * `createConfigQueryHandler()` for JSONPath support.
+ *
+ * @module routes/config
+ */
+/** Return a sanitized copy of the config (redact gatewayApiKey). */
+function sanitizeConfig(config) {
+    return {
+        ...config,
+        gatewayApiKey: config.gatewayApiKey ? '[REDACTED]' : undefined,
+    };
+}
+function registerConfigRoute(app, deps) {
+    const configHandler = createConfigQueryHandler(() => sanitizeConfig(deps.config));
+    app.get('/config', async (request, reply) => {
+        const { path } = request.query;
+        const result = await configHandler({ path });
+        return reply.status(result.status).send(result.body);
+    });
+}
+
+/**
+ * POST /config/apply — apply a config patch via the core SDK handler.
+ *
+ * @module routes/configApply
+ */
+/** Register the POST /config/apply route. */
+function registerConfigApplyRoute(app) {
+    const handler = createConfigApplyHandler(metaDescriptor);
+    app.post('/config/apply', async (request, reply) => {
+        const result = await handler(request.body);
+        return reply.status(result.status).send(result.body);
+    });
+}
+
+/**
+ * GET /metas — list metas with optional filters.
+ * GET /metas/:path — single meta detail.
+ *
+ * @module routes/metas
+ */
+const metasQuerySchema = z.object({
+    pathPrefix: z.string().optional(),
+    hasError: z
+        .enum(['true', 'false'])
+        .transform((v) => v === 'true')
+        .optional(),
+    staleHours: z
+        .string()
+        .transform(Number)
+        .pipe(z.number().positive())
+        .optional(),
+    neverSynthesized: z
+        .enum(['true', 'false'])
+        .transform((v) => v === 'true')
+        .optional(),
+    locked: z
+        .enum(['true', 'false'])
+        .transform((v) => v === 'true')
+        .optional(),
+    fields: z.string().optional(),
+});
+const metaDetailQuerySchema = z.object({
+    fields: z.string().optional(),
+    includeArchive: z
+        .union([
+        z.enum(['true', 'false']).transform((v) => v === 'true'),
+        z.string().transform(Number).pipe(z.number().int().nonnegative()),
+    ])
+        .optional(),
+});
+function registerMetasRoutes(app, deps) {
+    app.get('/metas', async (request) => {
+        const query = metasQuerySchema.parse(request.query);
+        const { config, watcher } = deps;
+        const result = await listMetas(config, watcher);
+        let entries = result.entries;
+        // Apply filters
+        if (query.pathPrefix) {
+            entries = entries.filter((e) => e.path.includes(query.pathPrefix));
+        }
+        if (query.hasError !== undefined) {
+            entries = entries.filter((e) => e.hasError === query.hasError);
+        }
+        if (query.neverSynthesized !== undefined) {
+            entries = entries.filter((e) => (e.lastSynthesized === null) === query.neverSynthesized);
+        }
+        if (query.locked !== undefined) {
+            entries = entries.filter((e) => e.locked === query.locked);
+        }
+        if (typeof query.staleHours === 'number') {
+            entries = entries.filter((e) => e.stalenessSeconds >= query.staleHours * 3600);
+        }
+        // Summary (computed from filtered entries)
+        const summary = computeSummary(entries, config.depthWeight);
+        // Field projection
+        const fieldList = query.fields?.split(',');
+        const defaultFields = [
+            'path',
+            'depth',
+            'emphasis',
+            'stalenessSeconds',
+            'lastSynthesized',
+            'hasError',
+            'locked',
+            'architectTokens',
+            'builderTokens',
+            'criticTokens',
+        ];
+        const projectedFields = fieldList ?? defaultFields;
+        const metas = entries.map((e) => {
+            const full = {
+                path: e.path,
+                depth: e.depth,
+                emphasis: e.emphasis,
+                stalenessSeconds: e.stalenessSeconds === Infinity
+                    ? null
+                    : Math.round(e.stalenessSeconds),
+                lastSynthesized: e.lastSynthesized,
+                hasError: e.hasError,
+                locked: e.locked,
+                architectTokens: e.architectTokens,
+                builderTokens: e.builderTokens,
+                criticTokens: e.criticTokens,
+            };
+            const projected = {};
+            for (const f of projectedFields) {
+                if (f in full)
+                    projected[f] = full[f];
+            }
+            return projected;
+        });
+        return { summary, metas };
+    });
+    app.get('/metas/:path', async (request, reply) => {
+        const query = metaDetailQuerySchema.parse(request.query);
+        const { config, watcher } = deps;
+        const targetPath = normalizePath(decodeURIComponent(request.params.path));
+        const result = await listMetas(config, watcher);
+        const targetNode = findNode(result.tree, targetPath);
+        if (!targetNode) {
+            return reply.status(404).send({
+                error: 'NOT_FOUND',
+                message: 'Meta path not found: ' + targetPath,
+            });
+        }
+        const meta = JSON.parse(await readFile(join(targetNode.metaPath, 'meta.json'), 'utf8'));
+        // Field projection
+        const defaultExclude = new Set([
+            '_architect',
+            '_builder',
+            '_critic',
+            '_content',
+            '_feedback',
+        ]);
+        const fieldList = query.fields?.split(',');
+        const projectMeta = (m) => {
+            if (fieldList) {
+                const r = {};
+                for (const f of fieldList)
+                    r[f] = m[f];
+                return r;
+            }
+            const r = {};
+            for (const [k, v] of Object.entries(m)) {
+                if (!defaultExclude.has(k))
+                    r[k] = v;
+            }
+            return r;
+        };
+        // Compute scope
+        const { scopeFiles, allFiles } = await getScopeFiles(targetNode, watcher);
+        // Compute staleness
+        const metaTyped = meta;
+        const staleSeconds = metaTyped._generatedAt
+            ? Math.round((Date.now() - new Date(metaTyped._generatedAt).getTime()) / 1000)
+            : null;
+        const score = computeStalenessScore(staleSeconds, metaTyped._depth ?? 0, metaTyped._emphasis ?? 1, config.depthWeight);
+        const response = {
+            path: targetNode.metaPath,
+            meta: projectMeta(meta),
+            scope: {
+                ownedFiles: scopeFiles.length,
+                childMetas: targetNode.children.length,
+                totalFiles: allFiles.length,
+            },
+            staleness: {
+                seconds: staleSeconds,
+                score: Math.round(score * 100) / 100,
+            },
+        };
+        // Cross-refs status
+        const crossRefsRaw = meta._crossRefs;
+        if (Array.isArray(crossRefsRaw) && crossRefsRaw.length > 0) {
+            response.crossRefs = await Promise.all(crossRefsRaw.map(async (refPath) => {
+                const rp = String(refPath);
+                const refMetaFile = join(rp, '.meta', 'meta.json');
+                try {
+                    const refMeta = JSON.parse(await readFile(refMetaFile, 'utf8'));
+                    return {
+                        path: rp,
+                        status: 'resolved',
+                        hasContent: Boolean(refMeta._content),
+                    };
+                }
+                catch {
+                    return { path: rp, status: 'missing' };
+                }
+            }));
+        }
+        // Archive
+        if (query.includeArchive) {
+            const limit = typeof query.includeArchive === 'number'
+                ? query.includeArchive
+                : undefined;
+            try {
+                response.archive = await readArchiveFromWatcher(watcher, targetNode.metaPath, config.metaArchiveProperty, limit, projectMeta);
+            }
+            catch {
+                response.archive = await readArchiveFromDisk(targetNode.metaPath, limit, projectMeta);
+            }
+        }
+        return response;
+    });
+}
+
+/**
+ * GET /preview — dry-run synthesis preview.
+ *
+ * @module routes/preview
+ */
+function registerPreviewRoute(app, deps) {
+    app.get('/preview', async (request, reply) => {
+        const { config, watcher } = deps;
         const query = request.query;
         let result;
         try {
@@ -11374,467 +11676,201 @@ function registerSeedRoute(app, deps) {
  * GET /status — service health and status overview.
  *
  * Uses the core SDK's `createStatusHandler` factory with a custom
- * `getHealth` callback that preserves all existing health details.
- *
- * @module routes/status
- */
-async function checkDependency(url, path) {
-    const checkedAt = new Date().toISOString();
-    try {
-        const res = await fetch(new URL(path, url), {
-            signal: AbortSignal.timeout(3000),
-        });
-        return { url, status: res.ok ? 'ok' : 'error', checkedAt };
-    }
-    catch {
-        return { url, status: 'unreachable', checkedAt };
-    }
-}
-/** Check watcher, surfacing initialScan.active as indexing state. */
-async function checkWatcher(url) {
-    const checkedAt = new Date().toISOString();
-    try {
-        const res = await fetch(new URL('/status', url), {
-            signal: AbortSignal.timeout(3000),
-        });
-        if (!res.ok)
-            return { url, status: 'error', checkedAt };
-        const data = (await res.json());
-        const indexing = data.initialScan?.active === true;
-        return {
-            url,
-            status: indexing ? 'indexing' : 'ok',
-            checkedAt,
-            indexing,
-        };
-    }
-    catch {
-        return { url, status: 'unreachable', checkedAt };
-    }
-}
-function registerStatusRoute(app, deps) {
-    const statusHandler = createStatusHandler({
-        name: SERVICE_NAME,
-        version: SERVICE_VERSION,
-        getHealth: async () => {
-            const { config, queue, scheduler, stats } = deps;
-            // On-demand dependency checks
-            const [watcherHealth, gatewayHealth] = await Promise.all([
-                checkWatcher(config.watcherUrl),
-                checkDependency(config.gatewayUrl, '/status'),
-            ]);
-            return {
-                currentTarget: queue.current?.path ?? null,
-                queue: queue.getState(),
-                stats: {
-                    totalSyntheses: stats.totalSyntheses,
-                    totalTokens: stats.totalTokens,
-                    totalErrors: stats.totalErrors,
-                    lastCycleDurationMs: stats.lastCycleDurationMs,
-                    lastCycleAt: stats.lastCycleAt,
-                },
-                schedule: {
-                    expression: config.schedule,
-                    nextAt: scheduler?.nextRunAt?.toISOString() ?? null,
-                },
-                dependencies: {
-                    watcher: {
-                        ...watcherHealth,
-                        rulesRegistered: deps.registrar?.isRegistered ?? false,
-                    },
-                    gateway: gatewayHealth,
-                },
-            };
-        },
-    });
-    app.get('/status', async (_request, reply) => {
-        const result = await statusHandler();
-        return reply.status(result.status).send(result.body);
-    });
-}
-
-/**
- * POST /synthesize route handler.
- *
- * @module routes/synthesize
- */
-const synthesizeBodySchema = z.object({
-    path: z.string().optional(),
-});
-/** Register the POST /synthesize route. */
-function registerSynthesizeRoute(app, deps) {
-    app.post('/synthesize', async (request, reply) => {
-        const body = synthesizeBodySchema.parse(request.body);
-        const { config, watcher, queue } = deps;
-        let targetPath;
-        if (body.path) {
-            targetPath = body.path;
-        }
-        else {
-            // Discover stalest candidate
-            let result;
-            try {
-                result = await listMetas(config, watcher);
-            }
-            catch {
-                return reply.status(503).send({
-                    error: 'SERVICE_UNAVAILABLE',
-                    message: 'Watcher unreachable — cannot discover candidates',
-                });
-            }
-            const stale = result.entries
-                .filter((e) => e.stalenessSeconds > 0)
-                .map((e) => ({
-                node: e.node,
-                meta: e.meta,
-                actualStaleness: e.stalenessSeconds,
-            }));
-            const stalest = discoverStalestPath(stale, config.depthWeight);
-            if (!stalest) {
-                return reply.code(200).send({
-                    status: 'skipped',
-                    message: 'No stale metas found. Nothing to synthesize.',
-                });
-            }
-            targetPath = stalest;
-        }
-        const result = queue.enqueue(targetPath, body.path !== undefined);
-        return reply.code(202).send({
-            status: 'accepted',
-            path: targetPath,
-            queuePosition: result.position,
-            alreadyQueued: result.alreadyQueued,
-        });
-    });
-}
-
-/**
- * POST /unlock — remove .lock from a .meta/ directory.
- *
- * @module routes/unlock
- */
-const unlockBodySchema = z.object({
-    path: z.string().min(1),
-});
-function registerUnlockRoute(app, deps) {
-    app.post('/unlock', (request, reply) => {
-        const body = unlockBodySchema.parse(request.body);
-        const metaDir = resolveMetaDir(body.path);
-        const lockPath = join(metaDir, '.lock');
-        if (!existsSync(lockPath)) {
-            return reply.status(409).send({
-                error: 'ALREADY_UNLOCKED',
-                message: `No lock file at ${body.path} (already unlocked)`,
-            });
-        }
-        deps.logger.info({ lockPath }, 'removing lock file');
-        unlinkSync(lockPath);
-        return reply.status(200).send({
-            status: 'unlocked',
-            path: body.path,
-        });
-    });
-}
-
-/**
- * Route registration for jeeves-meta service.
- *
- * @module routes
- */
-/** Register all HTTP routes on the Fastify instance. */
-function registerRoutes(app, deps) {
-    // Global error handler for validation + watcher errors
-    app.setErrorHandler((error, _request, reply) => {
-        if (error.validation) {
-            return reply
-                .status(400)
-                .send({ error: 'BAD_REQUEST', message: error.message });
-        }
-        if (error.statusCode === 404) {
-            return reply
-                .status(404)
-                .send({ error: 'NOT_FOUND', message: error.message });
-        }
-        deps.logger.error(error, 'Unhandled route error');
-        return reply
-            .status(500)
-            .send({ error: 'INTERNAL_ERROR', message: error.message });
-    });
-    registerStatusRoute(app, deps);
-    registerMetasRoutes(app, deps);
-    registerSynthesizeRoute(app, deps);
-    registerPreviewRoute(app, deps);
-    registerSeedRoute(app, deps);
-    registerUnlockRoute(app, deps);
-    registerConfigRoute(app, deps);
-    registerConfigApplyRoute(app);
-    registerQueueRoutes(app, deps);
-}
-
-/**
- * Virtual rule registration with jeeves-watcher.
- *
- * Service registers inference rules at startup (with retry) and
- * re-registers opportunistically when watcher restart is detected.
- *
- * @module rules
- */
-const SOURCE = 'jeeves-meta';
-const MAX_RETRIES = 10;
-const RETRY_BASE_MS = 2000;
-/**
- * Convert a `Record<string, unknown>` config property into watcher
- * schema `set` directives: `{ key: { set: value } }` per entry.
+ * `getHealth` callback that preserves all existing health details.
+ *
+ * @module routes/status
  */
-function toSchemaSetDirectives(props) {
-    return Object.fromEntries(Object.entries(props).map(([k, v]) => [k, { set: v }]));
+async function checkDependency(url, path) {
+    const checkedAt = new Date().toISOString();
+    try {
+        const res = await fetch(new URL(path, url), {
+            signal: AbortSignal.timeout(3000),
+        });
+        return { url, status: res.ok ? 'ok' : 'error', checkedAt };
+    }
+    catch {
+        return { url, status: 'unreachable', checkedAt };
+    }
 }
-/** Build the three virtual rule definitions. */
-function buildMetaRules(config) {
-    return [
-        {
-            name: 'meta-current',
-            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),
-                        meta_id: { type: 'string', set: '{{json._id}}' },
-                        meta_steer: { type: 'string', set: '{{json._steer}}' },
-                        meta_depth: { type: 'number', set: '{{json._depth}}' },
-                        meta_emphasis: { type: 'number', set: '{{json._emphasis}}' },
-                        meta_synthesis_count: {
-                            type: 'integer',
-                            set: '{{json._synthesisCount}}',
-                        },
-                        meta_structure_hash: {
-                            type: 'string',
-                            set: '{{json._structureHash}}',
-                        },
-                        meta_architect_tokens: {
-                            type: 'integer',
-                            set: '{{json._architectTokens}}',
-                        },
-                        meta_builder_tokens: {
-                            type: 'integer',
-                            set: '{{json._builderTokens}}',
-                        },
-                        meta_critic_tokens: {
-                            type: 'integer',
-                            set: '{{json._criticTokens}}',
-                        },
-                        meta_error_step: {
-                            type: 'string',
-                            set: '{{json._error.step}}',
-                        },
-                        generated_at: {
-                            type: 'string',
-                            set: '{{json._generatedAt}}',
-                        },
-                        generated_at_unix: {
-                            type: 'integer',
-                            set: '{{toUnix json._generatedAt}}',
-                        },
-                        has_error: {
-                            type: 'boolean',
-                            set: '{{#if json._error}}true{{else}}false{{/if}}',
-                        },
-                    },
-                },
-            ],
-            render: {
-                frontmatter: [
-                    'meta_id',
-                    'generated_at',
-                    '*',
-                    '!_*',
-                    '!json',
-                    '!file',
-                    '!has_error',
-                ],
-                body: [{ path: 'json._content', heading: 1, label: 'Synthesis' }],
-            },
-            renderAs: 'md',
-        },
-        {
-            name: 'meta-archive',
-            description: 'Archived jeeves-meta .meta/archive snapshots',
-            match: {
-                properties: {
-                    file: {
-                        properties: {
-                            path: { type: 'string', glob: '**/.meta/archive/*.json' },
-                        },
-                    },
+/** Check watcher, surfacing initialScan.active as indexing state. */
+async function checkWatcher(url) {
+    const checkedAt = new Date().toISOString();
+    try {
+        const res = await fetch(new URL('/status', url), {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok)
+            return { url, status: 'error', checkedAt };
+        const data = (await res.json());
+        const indexing = data.initialScan?.active === true;
+        return {
+            url,
+            status: indexing ? 'indexing' : 'ok',
+            checkedAt,
+            indexing,
+        };
+    }
+    catch {
+        return { url, status: 'unreachable', checkedAt };
+    }
+}
+function registerStatusRoute(app, deps) {
+    const statusHandler = createStatusHandler({
+        name: SERVICE_NAME,
+        version: SERVICE_VERSION,
+        getHealth: async () => {
+            const { config, queue, scheduler, stats } = deps;
+            // On-demand dependency checks
+            const [watcherHealth, gatewayHealth] = await Promise.all([
+                checkWatcher(config.watcherUrl),
+                checkDependency(config.gatewayUrl, '/status'),
+            ]);
+            return {
+                currentTarget: queue.current?.path ?? null,
+                queue: queue.getState(),
+                stats: {
+                    totalSyntheses: stats.totalSyntheses,
+                    totalTokens: stats.totalTokens,
+                    totalErrors: stats.totalErrors,
+                    lastCycleDurationMs: stats.lastCycleDurationMs,
+                    lastCycleAt: stats.lastCycleAt,
                 },
-            },
-            schema: [
-                'base',
-                {
-                    properties: {
-                        ...toSchemaSetDirectives(config.metaArchiveProperty),
-                        meta_id: { type: 'string', set: '{{json._id}}' },
-                        archived: { type: 'boolean', set: 'true' },
-                        archived_at: { type: 'string', set: '{{json._archivedAt}}' },
-                    },
+                schedule: {
+                    expression: config.schedule,
+                    nextAt: scheduler?.nextRunAt?.toISOString() ?? null,
                 },
-            ],
-            render: {
-                frontmatter: ['meta_id', 'archived', 'archived_at'],
-                body: [
-                    {
-                        path: 'json._content',
-                        heading: 1,
-                        label: 'Synthesis (archived)',
-                    },
-                ],
-            },
-            renderAs: 'md',
-        },
-        {
-            name: 'meta-config',
-            description: 'jeeves-meta configuration file',
-            match: {
-                properties: {
-                    file: {
-                        properties: {
-                            path: { type: 'string', glob: '**/jeeves-meta.config.json' },
-                        },
+                dependencies: {
+                    watcher: {
+                        ...watcherHealth,
+                        rulesRegistered: deps.registrar?.isRegistered ?? false,
                     },
+                    gateway: gatewayHealth,
                 },
-            },
-            schema: ['base', { properties: { domains: { set: ['meta-config'] } } }],
-            render: {
-                frontmatter: [
-                    'watcherUrl',
-                    'gatewayUrl',
-                    'architectEvery',
-                    'depthWeight',
-                    'maxArchive',
-                    'maxLines',
-                ],
-                body: [
-                    {
-                        path: 'json.defaultArchitect',
-                        heading: 2,
-                        label: 'Default Architect Prompt',
-                    },
-                    {
-                        path: 'json.defaultCritic',
-                        heading: 2,
-                        label: 'Default Critic Prompt',
-                    },
-                ],
-            },
-            renderAs: 'md',
+            };
         },
-    ];
+    });
+    app.get('/status', async (_request, reply) => {
+        const result = await statusHandler();
+        return reply.status(result.status).send(result.body);
+    });
 }
+
 /**
- * Manages virtual rule registration with watcher.
+ * POST /synthesize route handler.
  *
- * - Registers at startup with exponential retry
- * - Tracks watcher uptime for restart detection
- * - Re-registers opportunistically when uptime decreases
+ * @module routes/synthesize
  */
-class RuleRegistrar {
-    config;
-    logger;
-    watcherClient;
-    lastWatcherUptime = null;
-    registered = false;
-    constructor(config, logger, watcher) {
-        this.config = config;
-        this.logger = logger;
-        this.watcherClient = watcher;
-    }
-    /** Whether rules have been successfully registered. */
-    get isRegistered() {
-        return this.registered;
-    }
-    /**
-     * Register rules with watcher. Retries with exponential backoff.
-     * Non-blocking — logs errors but never throws.
-     */
-    async register() {
-        const rules = buildMetaRules(this.config);
-        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+const synthesizeBodySchema = z.object({
+    path: z.string().optional(),
+});
+/** Register the POST /synthesize route. */
+function registerSynthesizeRoute(app, deps) {
+    app.post('/synthesize', async (request, reply) => {
+        const body = synthesizeBodySchema.parse(request.body);
+        const { config, watcher, queue } = deps;
+        let targetPath;
+        if (body.path) {
+            targetPath = body.path;
+        }
+        else {
+            // Discover stalest candidate
+            let result;
             try {
-                await this.watcherClient.registerRules(SOURCE, rules);
-                this.registered = true;
-                this.logger.info('Virtual rules registered with watcher');
-                return;
+                result = await listMetas(config, watcher);
             }
-            catch (err) {
-                const delayMs = RETRY_BASE_MS * Math.pow(2, attempt);
-                this.logger.warn({ attempt: attempt + 1, delayMs, err }, 'Rule registration failed, retrying');
-                await new Promise((r) => setTimeout(r, delayMs));
+            catch {
+                return reply.status(503).send({
+                    error: 'SERVICE_UNAVAILABLE',
+                    message: 'Watcher unreachable — cannot discover candidates',
+                });
             }
+            const stale = result.entries
+                .filter((e) => e.stalenessSeconds > 0)
+                .map((e) => ({
+                node: e.node,
+                meta: e.meta,
+                actualStaleness: e.stalenessSeconds,
+            }));
+            const stalest = discoverStalestPath(stale, config.depthWeight);
+            if (!stalest) {
+                return reply.code(200).send({
+                    status: 'skipped',
+                    message: 'No stale metas found. Nothing to synthesize.',
+                });
+            }
+            targetPath = stalest;
         }
-        this.logger.error('Rule registration failed after max retries — service degraded');
-    }
-    /**
-     * Check watcher uptime and re-register if it decreased (restart detected).
-     *
-     * @param currentUptime - Current watcher uptime in seconds.
-     */
-    async checkAndReregister(currentUptime) {
-        if (this.lastWatcherUptime !== null &&
-            currentUptime < this.lastWatcherUptime) {
-            this.logger.info({ previous: this.lastWatcherUptime, current: currentUptime }, 'Watcher restart detected — re-registering rules');
-            this.registered = false;
-            await this.register();
-        }
-        this.lastWatcherUptime = currentUptime;
-    }
+        const result = queue.enqueue(targetPath, body.path !== undefined);
+        return reply.code(202).send({
+            status: 'accepted',
+            path: targetPath,
+            queuePosition: result.position,
+            alreadyQueued: result.alreadyQueued,
+        });
+    });
 }
 
 /**
- * Post-registration verification of virtual rule application.
- *
- * After rules are registered with the watcher, verifies that .meta/meta.json
- * files are discoverable via watcher walk (which depends on virtual rules
- * being applied). Logs a warning if expected metas are not found.
+ * POST /unlock — remove .lock from a .meta/ directory.
  *
- * @module rules/verify
+ * @module routes/unlock
  */
+const unlockBodySchema = z.object({
+    path: z.string().min(1),
+});
+function registerUnlockRoute(app, deps) {
+    app.post('/unlock', (request, reply) => {
+        const body = unlockBodySchema.parse(request.body);
+        const metaDir = resolveMetaDir(body.path);
+        const lockPath = join(metaDir, '.lock');
+        if (!existsSync(lockPath)) {
+            return reply.status(409).send({
+                error: 'ALREADY_UNLOCKED',
+                message: `No lock file at ${body.path} (already unlocked)`,
+            });
+        }
+        deps.logger.info({ lockPath }, 'removing lock file');
+        unlinkSync(lockPath);
+        return reply.status(200).send({
+            status: 'unlocked',
+            path: body.path,
+        });
+    });
+}
+
 /**
- * Verify that virtual rules are applied to indexed .meta/meta.json files.
- *
- * Runs a discovery pass and logs the result. If no metas are found but
- * the filesystem likely has some, logs a warning suggesting reindex.
+ * Route registration for jeeves-meta service.
  *
- * @param watcher - WatcherClient for discovery.
- * @param logger - Logger for reporting results.
- * @returns Number of metas discovered.
+ * @module routes
  */
-async function verifyRuleApplication(watcher, logger) {
-    try {
-        const metaPaths = await discoverMetas(watcher);
-        if (metaPaths.length === 0) {
-            logger.warn({ count: 0 }, 'Post-registration verification: no .meta/meta.json files found via watcher walk. ' +
-                'Virtual rules may not be applied to indexed files. ' +
-                'If metas exist, a path-scoped reindex may be needed.');
+/** Register all HTTP routes on the Fastify instance. */
+function registerRoutes(app, deps) {
+    // Global error handler for validation + watcher errors
+    app.setErrorHandler((error, _request, reply) => {
+        if (error.validation) {
+            return reply
+                .status(400)
+                .send({ error: 'BAD_REQUEST', message: error.message });
         }
-        else {
-            logger.info({ count: metaPaths.length }, 'Post-registration verification: metas discoverable');
+        if (error.statusCode === 404) {
+            return reply
+                .status(404)
+                .send({ error: 'NOT_FOUND', message: error.message });
         }
-        return metaPaths.length;
-    }
-    catch (err) {
-        logger.warn({ err: err instanceof Error ? err.message : String(err) }, 'Post-registration verification failed (watcher may be unavailable)');
-        return 0;
-    }
+        deps.logger.error(error, 'Unhandled route error');
+        return reply
+            .status(500)
+            .send({ error: 'INTERNAL_ERROR', message: error.message });
+    });
+    registerStatusRoute(app, deps);
+    registerMetasRoutes(app, deps);
+    registerSynthesizeRoute(app, deps);
+    registerPreviewRoute(app, deps);
+    registerSeedRoute(app, deps);
+    registerUnlockRoute(app, deps);
+    registerConfigRoute(app, deps);
+    registerConfigApplyRoute(app);
+    registerQueueRoutes(app, deps);
 }
 
 /**
@@ -11994,80 +12030,6 @@ class HttpWatcherClient {
     }
 }
 
-/**
- * Periodic watcher health check for rule registration resilience.
- *
- * Pings watcher `/status` on a configurable interval, detects restarts
- * (uptime decrease), and re-registers virtual rules automatically.
- * Independent of the synthesis scheduler.
- *
- * @module rules/healthCheck
- */
-/**
- * Manages the periodic watcher health check loop.
- *
- * Starts a `setInterval` that pings the watcher and delegates
- * restart detection to `RuleRegistrar.checkAndReregister()`.
- */
-class WatcherHealthCheck {
-    watcherUrl;
-    intervalMs;
-    registrar;
-    logger;
-    handle = null;
-    constructor(opts) {
-        this.watcherUrl = opts.watcherUrl.replace(/\/+$/, '');
-        this.intervalMs = opts.intervalMs;
-        this.registrar = opts.registrar;
-        this.logger = opts.logger;
-    }
-    /** Start the periodic health check. No-op if intervalMs is 0. */
-    start() {
-        if (this.intervalMs <= 0) {
-            this.logger.info('Watcher health check disabled (interval = 0)');
-            return;
-        }
-        this.handle = setInterval(() => {
-            void this.check();
-        }, this.intervalMs);
-        // Don't prevent process exit
-        if (typeof this.handle === 'object' && 'unref' in this.handle) {
-            this.handle.unref();
-        }
-        this.logger.info({ intervalMs: this.intervalMs }, 'Watcher health check started');
-    }
-    /** Stop the periodic health check. */
-    stop() {
-        if (this.handle) {
-            clearInterval(this.handle);
-            this.handle = null;
-        }
-    }
-    /** Single health check iteration. */
-    async check() {
-        try {
-            const res = await fetch(this.watcherUrl + '/status', {
-                signal: AbortSignal.timeout(5000),
-            });
-            if (!res.ok) {
-                this.logger.warn({ status: res.status }, 'Watcher health check: non-OK response');
-                return;
-            }
-            const data = (await res.json());
-            // If rules were never successfully registered (startup failure),
-            // attempt registration now that the watcher is reachable.
-            if (!this.registrar.isRegistered) {
-                this.logger.info('Rules not registered — attempting registration');
-                await this.registrar.register();
-            }
-            await this.registrar.checkAndReregister(data.uptime);
-        }
-        catch (err) {
-            this.logger.debug({ err }, 'Watcher health check: unreachable (expected during startup)');
-        }
-    }
-}
-
 /**
  * Service bootstrap — wire up all components and start listening.
  *
@@ -12251,4 +12213,51 @@ async function startService(config, configPath) {
     logger.info('Service fully initialized');
 }
 
+/**
+ * Jeeves component descriptor for jeeves-meta.
+ *
+ * Single source of truth consumed by the service CLI, plugin writer, and
+ * config-apply pipeline.
+ *
+ * @module descriptor
+ */
+/**
+ * Parsed jeeves-meta component descriptor.
+ */
+const metaDescriptor = jeevesComponentDescriptorSchema.parse({
+    name: 'meta',
+    version: SERVICE_VERSION,
+    servicePackage: '@karmaniverous/jeeves-meta',
+    pluginPackage: '@karmaniverous/jeeves-meta-openclaw',
+    defaultPort: 1938,
+    // The runtime Zod custom validator only checks for a .parse() method.
+    // Use unknown cast to bridge the Zod v4 (service) → v3 (core SDK) type gap.
+    configSchema: serviceConfigSchema,
+    configFileName: 'config.json',
+    initTemplate: () => serviceConfigSchema.parse({
+        watcherUrl: 'http://127.0.0.1:1936',
+    }),
+    onConfigApply: (merged) => {
+        const parsed = serviceConfigSchema.parse(merged);
+        applyHotReloadedConfig(parsed);
+        return Promise.resolve();
+    },
+    run: async (configPath) => {
+        const config = loadServiceConfig(configPath);
+        await startService(config, configPath);
+    },
+    startCommand: (configPath) => [
+        'node',
+        'dist/cli/jeeves-meta/index.js',
+        'start',
+        '-c',
+        configPath,
+    ],
+    sectionId: 'Meta',
+    refreshIntervalSeconds: 73,
+    generateToolsContent: () => '',
+    dependencies: { hard: ['watcher'], soft: [] },
+    customCliCommands: registerCustomCliCommands,
+});
+
 export { DEFAULT_PORT, DEFAULT_PORT_STR, GatewayExecutor, HttpWatcherClient, ProgressReporter, RESTART_REQUIRED_FIELDS, RuleRegistrar, SERVICE_NAME, SERVICE_VERSION, Scheduler, SynthesisQueue, acquireLock, actualStaleness, buildArchitectTask, buildBuilderTask, buildContextPackage, buildCriticTask, buildOwnershipTree, cleanupStaleLocks, computeEffectiveStaleness, computeEma, computeStructureHash, createLogger, createServer, createSnapshot, discoverMetas, filterInScope, findNode, formatProgressEvent, getScopePrefix, hasSteerChanged, isArchitectTriggered, isLocked, isStale, listArchiveFiles, listMetas, loadServiceConfig, mergeAndWrite, metaConfigSchema, metaDescriptor, metaErrorSchema, metaJsonSchema, migrateConfigPath, normalizePath, orchestrate, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, pruneArchive, readLatestArchive, readLockState, registerCustomCliCommands, registerRoutes, registerShutdownHandlers, releaseLock, resolveConfigPath, resolveMetaDir, selectCandidate, serviceConfigSchema, sleep, startService, toMetaError, verifyRuleApplication };