@karmaniverous/jeeves-meta 0.3.2 → 0.4.0

package/dist/index.js

@@ -1,7 +1,10 @@
-import { readdirSync, unlinkSync, readFileSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
-import { join, dirname, relative, sep } from 'node:path';
+import { readdirSync, unlinkSync, readFileSync, mkdirSync, writeFileSync, existsSync, copyFileSync, watchFile } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
 import { z } from 'zod';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import pino from 'pino';
+import { Cron } from 'croner';
+import Fastify from 'fastify';
 
 /**
  * List archive snapshot files in chronological order.
@@ -100,20 +103,18 @@ function createSnapshot(metaPath, meta) {
 }
 
 /**
- * Zod schema for jeeves-meta configuration.
+ * Zod schema for jeeves-meta service configuration.
  *
- * Consumers load config however they want (file, env, constructor).
- * The library validates via this schema.
+ * The service config is a strict superset of the core (library-compatible) meta config.
  *
  * @module schema/config
  */
-/** Zod schema for jeeves-meta configuration. */
-const synthConfigSchema = z.object({
-    /** Filesystem paths to watch for .meta/ directories. */
+/** Zod schema for the core (library-compatible) meta configuration. */
+const metaConfigSchema = z.object({
     /** Watcher service base URL. */
     watcherUrl: z.url(),
     /** OpenClaw gateway base URL for subprocess spawning. */
-    gatewayUrl: z.url().default('http://127.0.0.1:3000'),
+    gatewayUrl: z.url().default('http://127.0.0.1:18789'),
     /** Optional API key for gateway authentication. */
     gatewayApiKey: z.string().optional(),
     /** Run architect every N cycles (per meta). */
@@ -130,134 +131,75 @@ const synthConfigSchema = z.object({
     builderTimeout: z.number().int().min(60).default(600),
     /** Critic subprocess timeout in seconds. */
     criticTimeout: z.number().int().min(30).default(300),
+    /** Thinking level for spawned synthesis sessions. */
+    thinking: z.string().default('low'),
     /** Resolved architect system prompt text. */
     defaultArchitect: z.string(),
     /** Resolved critic system prompt text. */
     defaultCritic: z.string(),
-    /**
-     * When true, skip unchanged candidates and iterate to the next-stalest
-     * until finding one with actual changes. Skipped candidates get their
-     * _generatedAt bumped to prevent re-selection next cycle.
-     */
+    /** Skip unchanged candidates, bump _generatedAt. */
     skipUnchanged: z.boolean().default(true),
-    /** Number of metas to synthesize per invocation. */
-    batchSize: z.number().int().min(1).default(1),
-    /**
-     * Watcher metadata properties for live .meta/meta.json files.
-     * Virtual rules use these to tag live metas; scan queries derive
-     * their filter from the first domain value.
-     */
-    metaProperty: z
-        .object({ domains: z.array(z.string()).min(1) })
-        .default({ domains: ['meta'] }),
-    /**
-     * Watcher metadata properties for .meta/archive/** snapshots.
-     * Virtual rules use these to tag archive files.
-     */
+    /** Watcher metadata properties applied to live .meta/meta.json files. */
+    metaProperty: z.record(z.string(), z.unknown()).default({ _meta: 'current' }),
+    /** Watcher metadata properties applied to archive snapshots. */
     metaArchiveProperty: z
-        .object({ domains: z.array(z.string()).min(1) })
-        .default({ domains: ['meta-archive'] }),
+        .record(z.string(), z.unknown())
+        .default({ _meta: 'archive' }),
 });
-
-/**
- * Structured error from a synthesis step failure.
- *
- * @module schema/error
- */
-/** Zod schema for synthesis step errors. */
-const synthErrorSchema = z.object({
-    /** Which step failed: 'architect', 'builder', or 'critic'. */
-    step: z.enum(['architect', 'builder', 'critic']),
-    /** Error classification code. */
-    code: z.string(),
-    /** Human-readable error message. */
-    message: z.string(),
+/** Zod schema for logging configuration. */
+const loggingSchema = z.object({
+    /** Log level. */
+    level: z.string().default('info'),
+    /** Optional file path for log output. */
+    file: z.string().optional(),
+});
+/** Zod schema for jeeves-meta service configuration (superset of MetaConfig). */
+const serviceConfigSchema = metaConfigSchema.extend({
+    /** HTTP port for the service (default: 1938). */
+    port: z.number().int().min(1).max(65535).default(1938),
+    /** Cron schedule for synthesis cycles (default: every 30 min). */
+    schedule: z.string().default('*/30 * * * *'),
+    /** Optional channel identifier for reporting. */
+    reportChannel: z.string().optional(),
+    /** Logging configuration. */
+    logging: loggingSchema.default(() => loggingSchema.parse({})),
 });
 
 /**
- * Zod schema for .meta/meta.json files.
+ * Load and resolve jeeves-meta service config.
  *
- * Reserved properties are underscore-prefixed and engine-managed.
- * All other keys are open schema (builder output).
+ * Supports \@file: indirection and environment-variable substitution (dollar-brace pattern).
  *
- * @module schema/meta
+ * @module configLoader
  */
-/** Zod schema for the reserved (underscore-prefixed) meta.json properties. */
-const metaJsonSchema = z
-    .object({
-    /** Stable identity. Generated on first synthesis, never changes. */
-    _id: z.uuid(),
-    /** Human-provided steering prompt. Optional. */
-    _steer: z.string().optional(),
-    /** Architect system prompt used this turn. Defaults from config. */
-    _architect: z.string().optional(),
-    /**
-     * Task brief generated by the architect. Cached and reused across cycles;
-     * regenerated only when triggered.
-     */
-    _builder: z.string().optional(),
-    /** Critic system prompt used this turn. Defaults from config. */
-    _critic: z.string().optional(),
-    /** Timestamp of last synthesis. ISO 8601. */
-    _generatedAt: z.iso.datetime().optional(),
-    /** Narrative synthesis output. Rendered by watcher for embedding. */
-    _content: z.string().optional(),
-    /**
-     * Hash of sorted file listing in scope. Detects directory structure
-     * changes that trigger an architect re-run.
-     */
-    _structureHash: z.string().optional(),
-    /**
-     * Cycles since last architect run. Reset to 0 when architect runs.
-     * Used with architectEvery to trigger periodic re-prompting.
-     */
-    _synthesisCount: z.number().int().min(0).optional(),
-    /** Critic evaluation of the last synthesis. */
-    _feedback: z.string().optional(),
-    /**
-     * Present and true on archive snapshots. Distinguishes live vs. archived
-     * metas.
-     */
-    _archived: z.boolean().optional(),
-    /** Timestamp when this snapshot was archived. ISO 8601. */
-    _archivedAt: z.iso.datetime().optional(),
-    /**
-     * Scheduling priority. Higher = updates more often. Negative allowed;
-     * normalized to min 0 at scheduling time.
-     */
-    _depth: z.number().optional(),
-    /**
-     * Emphasis multiplier for depth weighting in scheduling.
-     * Default 1. Higher values increase this meta's scheduling priority
-     * relative to its depth. Set to 0.5 to halve the depth effect,
-     * 2 to double it, 0 to ignore depth entirely for this meta.
-     */
-    _emphasis: z.number().min(0).optional(),
-    /** Token count from last architect subprocess call. */
-    _architectTokens: z.number().int().optional(),
-    /** Token count from last builder subprocess call. */
-    _builderTokens: z.number().int().optional(),
-    /** Token count from last critic subprocess call. */
-    _criticTokens: z.number().int().optional(),
-    /** Exponential moving average of architect token usage (decay 0.3). */
-    _architectTokensAvg: z.number().optional(),
-    /** Exponential moving average of builder token usage (decay 0.3). */
-    _builderTokensAvg: z.number().optional(),
-    /** Exponential moving average of critic token usage (decay 0.3). */
-    _criticTokensAvg: z.number().optional(),
-    /**
-     * Structured error from last cycle. Present when a step failed.
-     * Cleared on successful cycle.
-     */
-    _error: synthErrorSchema.optional(),
-})
-    .loose();
-
 /**
- * Load and resolve jeeves-meta config with \@file: indirection.
+ * Deep-walk a value, replacing `\${VAR\}` patterns with process.env values.
  *
- * @module configLoader
+ * @param value - Arbitrary JSON-compatible value.
+ * @returns Value with env-var placeholders resolved.
  */
+function substituteEnvVars(value) {
+    if (typeof value === 'string') {
+        return value.replace(/\$\{([^}]+)\}/g, (_match, name) => {
+            const envVal = process.env[name];
+            if (envVal === undefined) {
+                throw new Error(`Environment variable ${name} is not set`);
+            }
+            return envVal;
+        });
+    }
+    if (Array.isArray(value)) {
+        return value.map(substituteEnvVars);
+    }
+    if (value !== null && typeof value === 'object') {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = substituteEnvVars(val);
+        }
+        return result;
+    }
+    return value;
+}
 /**
  * Resolve \@file: references in a config value.
  *
@@ -271,23 +213,6 @@ function resolveFileRef(value, baseDir) {
     const filePath = join(baseDir, value.slice(6));
     return readFileSync(filePath, 'utf8');
 }
-/**
- * Load synth config from a JSON file, resolving \@file: references.
- *
- * @param configPath - Path to jeeves-meta.config.json.
- * @returns Validated SynthConfig with resolved prompt strings.
- */
-function loadSynthConfig(configPath) {
-    const raw = JSON.parse(readFileSync(configPath, 'utf8'));
-    const baseDir = dirname(configPath);
-    if (typeof raw.defaultArchitect === 'string') {
-        raw.defaultArchitect = resolveFileRef(raw.defaultArchitect, baseDir);
-    }
-    if (typeof raw.defaultCritic === 'string') {
-        raw.defaultCritic = resolveFileRef(raw.defaultCritic, baseDir);
-    }
-    return synthConfigSchema.parse(raw);
-}
 /**
  * Resolve config path from --config flag or JEEVES_META_CONFIG env var.
  *
@@ -296,17 +221,38 @@ function loadSynthConfig(configPath) {
  * @throws If no config path found.
  */
 function resolveConfigPath(args) {
-    // Check --config flag
-    const configIdx = args.indexOf('--config');
+    let configIdx = args.indexOf('--config');
+    if (configIdx === -1)
+        configIdx = args.indexOf('-c');
     if (configIdx !== -1 && args[configIdx + 1]) {
         return args[configIdx + 1];
     }
-    // Check env var
     const envPath = process.env['JEEVES_META_CONFIG'];
     if (envPath)
         return envPath;
     throw new Error('Config path required. Use --config <path> or set JEEVES_META_CONFIG env var.');
 }
+/**
+ * Load service config from a JSON file.
+ *
+ * Resolves \@file: references for defaultArchitect and defaultCritic,
+ * and substitutes environment-variable placeholders throughout.
+ *
+ * @param configPath - Path to config JSON file.
+ * @returns Validated ServiceConfig.
+ */
+function loadServiceConfig(configPath) {
+    const rawText = readFileSync(configPath, 'utf8');
+    const raw = substituteEnvVars(JSON.parse(rawText));
+    const baseDir = dirname(configPath);
+    if (typeof raw['defaultArchitect'] === 'string') {
+        raw['defaultArchitect'] = resolveFileRef(raw['defaultArchitect'], baseDir);
+    }
+    if (typeof raw['defaultCritic'] === 'string') {
+        raw['defaultCritic'] = resolveFileRef(raw['defaultCritic'], baseDir);
+    }
+    return serviceConfigSchema.parse(raw);
+}
 
 /**
  * Normalize file paths to forward slashes for consistency with watcher-indexed paths.
@@ -323,7 +269,7 @@ function resolveConfigPath(args) {
  * @param p - File path (may contain backslashes).
  * @returns Path with all backslashes replaced by forward slashes.
  */
-function normalizePath$1(p) {
+function normalizePath(p) {
     return p.replaceAll('\\', '/');
 }
 
@@ -358,25 +304,50 @@ async function paginatedScan(watcher, params) {
  *
  * @module discovery/discoverMetas
  */
+/**
+ * Build a single Qdrant filter clause from a key-value pair.
+ *
+ * Arrays use `match.value` on the first element (Qdrant array membership).
+ * Scalars (string, number, boolean) use `match.value` directly.
+ * Objects and other non-filterable types are skipped with a warning.
+ */
+function buildMatchClause(key, value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return null;
+        return { key, match: { value: value[0] } };
+    }
+    if (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return { key, match: { value } };
+    }
+    // Non-filterable value (object, null, etc.) — valid for tagging but
+    // cannot be expressed as a Qdrant match clause.
+    return null;
+}
 /**
  * Build a Qdrant filter from config metaProperty.
  *
- * @param config - Synth config with metaProperty.
+ * Iterates all key-value pairs in `metaProperty` (a generic record)
+ * to construct `must` clauses. Always appends `file_path: meta.json`
+ * for deduplication.
+ *
+ * @param config - Meta config with metaProperty.
  * @returns Qdrant filter object for scanning live metas.
  */
 function buildMetaFilter(config) {
-    return {
-        must: [
-            {
-                key: 'domains',
-                match: { value: config.metaProperty.domains[0] },
-            },
-            {
-                key: 'file_path',
-                match: { text: 'meta.json' },
-            },
-        ],
-    };
+    const must = [];
+    for (const [key, value] of Object.entries(config.metaProperty)) {
+        const clause = buildMatchClause(key, value);
+        if (clause)
+            must.push(clause);
+    }
+    must.push({
+        key: 'file_path',
+        match: { text: '.meta/meta.json' },
+    });
+    return { must };
 }
 /**
  * Discover all .meta/ directories via watcher scan.
@@ -384,7 +355,7 @@ function buildMetaFilter(config) {
  * Queries the watcher for indexed .meta/meta.json points using the
  * configured domain filter. Returns deduplicated meta directory paths.
  *
- * @param config - Synth config (for domain filter).
+ * @param config - Meta config (for domain filter).
  * @param watcher - WatcherClient for scan queries.
  * @returns Array of normalized .meta/ directory paths.
  */
@@ -398,7 +369,7 @@ async function discoverMetas(config, watcher) {
     const seen = new Set();
     const metaPaths = [];
     for (const sf of scanFiles) {
-        const fp = normalizePath$1(sf.file_path);
+        const fp = normalizePath(sf.file_path);
         // Derive .meta/ directory from file_path (strip /meta.json)
         const metaPath = fp.replace(/\/meta\.json$/, '');
         if (seen.has(metaPath))
@@ -412,38 +383,75 @@ async function discoverMetas(config, watcher) {
 /**
  * File-system lock for preventing concurrent synthesis on the same meta.
  *
- * Lock file: .meta/.lock containing PID + timestamp.
+ * Lock file: .meta/.lock containing `_lockPid` + `_lockStartedAt` (underscore-prefixed
+ * reserved keys, consistent with meta.json conventions).
  * Stale timeout: 30 minutes.
  *
  * @module lock
  */
 const LOCK_FILE = '.lock';
+/**
+ * Resolve a path to a .meta directory.
+ *
+ * If the path already ends with '.meta', returns it as-is.
+ * Otherwise, appends '.meta' as a subdirectory.
+ *
+ * @param inputPath - Path that may or may not end with '.meta'.
+ * @returns The resolved .meta directory path.
+ */
+function resolveMetaDir(inputPath) {
+    return inputPath.endsWith('.meta') ? inputPath : join(inputPath, '.meta');
+}
 const STALE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 /**
- * Attempt to acquire a lock on a .meta directory.
+ * Read and classify the state of a .meta/.lock file.
  *
  * @param metaPath - Absolute path to the .meta directory.
- * @returns True if lock was acquired, false if already locked (non-stale).
+ * @returns Parsed lock state.
  */
-function acquireLock(metaPath) {
+function readLockState(metaPath) {
     const lockPath = join(metaPath, LOCK_FILE);
-    if (existsSync(lockPath)) {
-        try {
-            const raw = readFileSync(lockPath, 'utf8');
-            const data = JSON.parse(raw);
-            const lockAge = Date.now() - new Date(data.startedAt).getTime();
-            if (lockAge < STALE_TIMEOUT_MS) {
-                return false; // Lock is active
-            }
-            // Stale lock — fall through to overwrite
+    if (!existsSync(lockPath)) {
+        return { exists: false, staged: false, active: false, data: null };
+    }
+    try {
+        const raw = readFileSync(lockPath, 'utf8');
+        const data = JSON.parse(raw);
+        if ('_id' in data) {
+            return { exists: true, staged: true, active: false, data };
         }
-        catch {
-            // Corrupt lock file — overwrite
+        const startedAt = data._lockStartedAt;
+        if (startedAt) {
+            const lockAge = Date.now() - new Date(startedAt).getTime();
+            return {
+                exists: true,
+                staged: false,
+                active: lockAge < STALE_TIMEOUT_MS,
+                data,
+            };
         }
+        return { exists: true, staged: false, active: false, data };
+    }
+    catch {
+        return { exists: true, staged: false, active: false, data: null };
     }
+}
+/**
+ * Attempt to acquire a lock on a .meta directory.
+ *
+ * @param metaPath - Absolute path to the .meta directory.
+ * @returns True if lock was acquired, false if already locked (non-stale).
+ */
+function acquireLock(metaPath) {
+    const state = readLockState(metaPath);
+    // Active non-stale lock — cannot acquire
+    if (state.active)
+        return false;
+    // Staged, stale, corrupt, or missing — safe to (over)write
+    const lockPath = join(metaPath, LOCK_FILE);
     const lock = {
-        pid: process.pid,
-        startedAt: new Date().toISOString(),
+        _lockPid: process.pid,
+        _lockStartedAt: new Date().toISOString(),
     };
     writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n');
     return true;
@@ -469,17 +477,36 @@ function releaseLock(metaPath) {
  * @returns True if locked and not stale.
  */
 function isLocked(metaPath) {
-    const lockPath = join(metaPath, LOCK_FILE);
-    if (!existsSync(lockPath))
-        return false;
-    try {
-        const raw = readFileSync(lockPath, 'utf8');
-        const data = JSON.parse(raw);
-        const lockAge = Date.now() - new Date(data.startedAt).getTime();
-        return lockAge < STALE_TIMEOUT_MS;
-    }
-    catch {
-        return false; // Corrupt lock = not locked
+    return readLockState(metaPath).active;
+}
+/**
+ * Clean up stale lock files on startup.
+ *
+ * For each .meta directory found via the provided paths:
+ * - If lock contains PID-only data (synthesis incomplete), delete it.
+ * - If lock contains staged result (_id present), log warning and delete.
+ *
+ * @param metaPaths - Array of .meta directory paths to check.
+ * @param logger - Optional logger for warnings.
+ */
+function cleanupStaleLocks(metaPaths, logger) {
+    for (const metaPath of metaPaths) {
+        const state = readLockState(metaPath);
+        if (!state.exists)
+            continue;
+        const lockPath = join(metaPath, LOCK_FILE);
+        if (state.staged) {
+            logger?.warn({ metaPath }, 'Found staged synthesis result in lock file from previous crash — deleting (conservative: not auto-finalizing)');
+        }
+        else {
+            logger?.warn({ metaPath }, 'Found stale lock file from previous crash — deleting');
+        }
+        try {
+            unlinkSync(lockPath);
+        }
+        catch {
+            // Already gone
+        }
     }
 }
 
@@ -492,10 +519,6 @@ function isLocked(metaPath) {
  *
  * @module discovery/ownershipTree
  */
-/** Normalize path separators to forward slashes for consistent comparison. */
-function normalizePath(p) {
-    return p.split(sep).join('/');
-}
 /**
  * Build an ownership tree from an array of .meta/ directory paths.
  *
@@ -610,7 +633,7 @@ async function listMetas(config, watcher) {
         const depth = meta._depth ?? node.treeDepth;
         const emphasis = meta._emphasis ?? 1;
         const hasError = Boolean(meta._error);
-        const locked = isLocked(normalizePath$1(node.metaPath));
+        const locked = isLocked(normalizePath(node.metaPath));
         const neverSynth = !meta._generatedAt;
         // Compute staleness
         let stalenessSeconds;
@@ -741,6 +764,47 @@ function filterInScope(node, files) {
         return true;
     });
 }
+/**
+ * Get all files in scope for a meta node via watcher scan.
+ *
+ * Scans the owner path prefix and filters out child meta subtrees,
+ * keeping only files directly owned by this meta.
+ *
+ * @param node - The meta node.
+ * @param watcher - WatcherClient for scan queries.
+ * @returns Array of in-scope file paths.
+ */
+async function getScopeFiles(node, watcher) {
+    const allScanFiles = await paginatedScan(watcher, {
+        pathPrefix: node.ownerPath,
+    });
+    const allFiles = allScanFiles.map((f) => f.file_path);
+    return {
+        scopeFiles: filterInScope(node, allFiles),
+        allFiles,
+    };
+}
+/**
+ * Get files modified since a given timestamp within a meta node's scope.
+ *
+ * If no generatedAt is provided (first run), returns all scope files.
+ *
+ * @param node - The meta node.
+ * @param watcher - WatcherClient for scan queries.
+ * @param generatedAt - ISO timestamp of last synthesis, or null/undefined for first run.
+ * @param scopeFiles - Pre-computed scope files (used as fallback for first run).
+ * @returns Array of modified in-scope file paths.
+ */
+async function getDeltaFiles(node, watcher, generatedAt, scopeFiles) {
+    if (!generatedAt)
+        return scopeFiles;
+    const modifiedAfter = Math.floor(new Date(generatedAt).getTime() / 1000);
+    const deltaScanFiles = await paginatedScan(watcher, {
+        pathPrefix: node.ownerPath,
+        modifiedAfter,
+    });
+    return filterInScope(node, deltaScanFiles.map((f) => f.file_path));
+}
 
 /**
  * Exponential moving average helper for token tracking.
@@ -768,14 +832,14 @@ function computeEma(current, previous, decay = DEFAULT_DECAY) {
  * @module errors
  */
 /**
- * Wrap an unknown caught value into a SynthError.
+ * 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 SynthError.
+ * @returns A structured MetaError.
  */
-function toSynthError(step, err, code = 'FAILED') {
+function toMetaError(step, err, code = 'FAILED') {
     return {
         step,
         code,
@@ -784,122 +848,185 @@ function toSynthError(step, err, code = 'FAILED') {
 }
 
 /**
- * SynthExecutor implementation using the OpenClaw gateway HTTP API.
+ * 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));
+}
+
+/**
+ * MetaExecutor implementation using the OpenClaw gateway HTTP API.
  *
  * Lives in the library package so both plugin and runner can import it.
- * Spawns sub-agent sessions via the gateway, polls for completion,
- * and extracts output text.
+ * Spawns sub-agent sessions via the gateway's `/tools/invoke` endpoint,
+ * polls for completion, and extracts output text.
  *
  * @module executor/GatewayExecutor
  */
 const DEFAULT_POLL_INTERVAL_MS = 5000;
 const DEFAULT_TIMEOUT_MS = 600_000; // 10 minutes
-/** Sleep helper. */
-function sleep$1(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 /**
- * SynthExecutor that spawns OpenClaw sessions via the gateway HTTP API.
+ * MetaExecutor that spawns OpenClaw sessions via the gateway's
+ * `/tools/invoke` endpoint.
  *
  * Used by both the OpenClaw plugin (in-process tool calls) and the
  * runner/CLI (external invocation). Constructs from `gatewayUrl` and
- * optional `apiKey` — typically sourced from `SynthConfig`.
+ * optional `apiKey` — typically sourced from `MetaConfig`.
  */
 class GatewayExecutor {
     gatewayUrl;
     apiKey;
     pollIntervalMs;
     constructor(options = {}) {
-        this.gatewayUrl = (options.gatewayUrl ?? 'http://127.0.0.1:3000').replace(/\/+$/, '');
+        this.gatewayUrl = (options.gatewayUrl ?? 'http://127.0.0.1:18789').replace(/\/+$/, '');
         this.apiKey = options.apiKey;
         this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     }
-    async spawn(task, options) {
-        const timeoutMs = (options?.timeout ?? DEFAULT_TIMEOUT_MS / 1000) * 1000;
-        const deadline = Date.now() + timeoutMs;
+    /** Invoke a gateway tool via the /tools/invoke HTTP endpoint. */
+    async invoke(tool, args) {
         const headers = {
             'Content-Type': 'application/json',
         };
         if (this.apiKey) {
             headers['Authorization'] = 'Bearer ' + this.apiKey;
         }
-        const spawnRes = await fetch(this.gatewayUrl + '/api/sessions/spawn', {
+        const res = await fetch(this.gatewayUrl + '/tools/invoke', {
             method: 'POST',
             headers,
-            body: JSON.stringify({
-                task,
-                mode: 'run',
-                model: options?.model,
-                runTimeoutSeconds: options?.timeout,
-            }),
+            body: JSON.stringify({ tool, args }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Gateway ${tool} failed: HTTP ${res.status.toString()} - ${text}`);
+        }
+        const data = (await res.json());
+        if (data.ok === false || data.error) {
+            throw new Error(`Gateway ${tool} error: ${data.error?.message ?? JSON.stringify(data)}`);
+        }
+        return data;
+    }
+    async spawn(task, options) {
+        const timeoutSeconds = options?.timeout ?? DEFAULT_TIMEOUT_MS / 1000;
+        const timeoutMs = timeoutSeconds * 1000;
+        const deadline = Date.now() + timeoutMs;
+        // Step 1: Spawn the sub-agent session
+        const spawnResult = await this.invoke('sessions_spawn', {
+            task,
+            label: options?.label ?? 'jeeves-meta-synthesis',
+            runTimeoutSeconds: timeoutSeconds,
+            ...(options?.thinking ? { thinking: options.thinking } : {}),
+            ...(options?.model ? { model: options.model } : {}),
         });
-        if (!spawnRes.ok) {
-            const text = await spawnRes.text();
-            throw new Error('Gateway spawn failed: HTTP ' +
-                spawnRes.status.toString() +
-                ' - ' +
-                text);
-        }
-        const spawnData = (await spawnRes.json());
-        if (!spawnData.sessionKey) {
-            throw new Error('Gateway spawn returned no sessionKey: ' + JSON.stringify(spawnData));
-        }
-        const { sessionKey } = spawnData;
-        // Poll for completion
+        const details = (spawnResult.result?.details ?? spawnResult.result);
+        const sessionKey = details?.childSessionKey ?? details?.sessionKey;
+        if (typeof sessionKey !== 'string' || !sessionKey) {
+            throw new Error('Gateway sessions_spawn returned no sessionKey: ' +
+                JSON.stringify(spawnResult));
+        }
+        // Step 2: Poll for completion via sessions_history
+        await sleep(3000);
         while (Date.now() < deadline) {
-            await sleep$1(this.pollIntervalMs);
-            const historyRes = await fetch(this.gatewayUrl +
-                '/api/sessions/' +
-                encodeURIComponent(sessionKey) +
-                '/history?limit=50', { headers });
-            if (!historyRes.ok)
-                continue;
-            const history = (await historyRes.json());
-            if (history.status === 'completed' || history.status === 'done') {
-                // Extract token usage from session-level or message-level usage
-                let tokens;
-                if (history.usage?.totalTokens) {
-                    tokens = history.usage.totalTokens;
-                }
-                else {
-                    // Sum message-level usage as fallback
-                    let sum = 0;
-                    for (const msg of history.messages ?? []) {
-                        if (msg.usage?.totalTokens)
-                            sum += msg.usage.totalTokens;
-                    }
-                    if (sum > 0)
-                        tokens = sum;
-                }
-                // Extract the last assistant message as output
-                const messages = history.messages ?? [];
-                for (let i = messages.length - 1; i >= 0; i--) {
-                    if (messages[i].role === 'assistant' && messages[i].content) {
-                        return { output: messages[i].content, tokens };
+            try {
+                const historyResult = await this.invoke('sessions_history', {
+                    sessionKey,
+                    limit: 5,
+                    includeTools: false,
+                });
+                const messages = historyResult.result?.details?.messages ??
+                    historyResult.result?.messages ??
+                    [];
+                const msgArray = messages;
+                if (msgArray.length > 0) {
+                    const lastMsg = msgArray[msgArray.length - 1];
+                    // Complete when last message is assistant with a terminal stop reason
+                    if (lastMsg.role === 'assistant' &&
+                        lastMsg.stopReason &&
+                        lastMsg.stopReason !== 'toolUse' &&
+                        lastMsg.stopReason !== 'error') {
+                        // Sum token usage from all messages
+                        let tokens;
+                        let sum = 0;
+                        for (const msg of msgArray) {
+                            if (msg.usage?.totalTokens)
+                                sum += msg.usage.totalTokens;
+                        }
+                        if (sum > 0)
+                            tokens = sum;
+                        // Find the last assistant message with content
+                        for (let i = msgArray.length - 1; i >= 0; i--) {
+                            if (msgArray[i].role === 'assistant' && msgArray[i].content) {
+                                return { output: msgArray[i].content, tokens };
+                            }
+                        }
+                        return { output: '', tokens };
                     }
                 }
-                return { output: '', tokens };
             }
+            catch {
+                // Transient poll failure — keep trying
+            }
+            await sleep(this.pollIntervalMs);
         }
         throw new Error('Synthesis subprocess timed out after ' + timeoutMs.toString() + 'ms');
     }
 }
 
 /**
- * Build the SynthContext for a synthesis cycle.
- *
- * Computes shared inputs once: scope files, delta files, child meta outputs,
- * previous content/feedback, steer, and archive paths.
+ * Pino logger factory.
  *
- * @module orchestrator/contextPackage
+ * @module logger
  */
 /**
- * Condense a file list into glob-like summaries.
- * Groups by directory + extension pattern.
+ * Create a pino logger instance.
  *
- * @param files - Array of file paths.
- * @param maxIndividual - Show individual files up to this count.
- * @returns Condensed summary string.
+ * @param config - Optional logger configuration.
+ * @returns Configured pino logger.
+ */
+function createLogger(config) {
+    const level = config?.level ?? 'info';
+    if (config?.file) {
+        const transport = pino.transport({
+            target: 'pino/file',
+            options: { destination: config.file, mkdir: true },
+        });
+        return pino({ level }, transport);
+    }
+    return pino({ level });
+}
+
+/**
+ * Build the MetaContext for a synthesis cycle.
+ *
+ * Computes shared inputs once: scope files, delta files, child meta outputs,
+ * previous content/feedback, steer, and archive paths.
+ *
+ * @module orchestrator/contextPackage
+ */
+/**
+ * Condense a file list into glob-like summaries.
+ * Groups by directory + extension pattern.
+ *
+ * @param files - Array of file paths.
+ * @param maxIndividual - Show individual files up to this count.
+ * @returns Condensed summary string.
  */
 function condenseScopeFiles(files, maxIndividual = 30) {
     if (files.length <= maxIndividual)
@@ -927,24 +1054,9 @@ function condenseScopeFiles(files, maxIndividual = 30) {
  * @returns The computed context package.
  */
 async function buildContextPackage(node, meta, watcher) {
-    // Scope files via watcher scan, excluding child subtrees
-    const allScanFiles = await paginatedScan(watcher, {
-        pathPrefix: node.ownerPath,
-    });
-    const scopeFiles = filterInScope(node, allScanFiles.map((f) => f.file_path));
-    // Delta files: modified since _generatedAt
-    let deltaFiles;
-    if (meta._generatedAt) {
-        const modifiedAfter = Math.floor(new Date(meta._generatedAt).getTime() / 1000);
-        const deltaScanFiles = await paginatedScan(watcher, {
-            pathPrefix: node.ownerPath,
-            modifiedAfter,
-        });
-        deltaFiles = filterInScope(node, deltaScanFiles.map((f) => f.file_path));
-    }
-    else {
-        deltaFiles = scopeFiles; // First run: all files are delta
-    }
+    // Scope and delta files via watcher scan
+    const { scopeFiles } = await getScopeFiles(node, watcher);
+    const deltaFiles = await getDeltaFiles(node, watcher, meta._generatedAt, scopeFiles);
     // Child meta outputs
     const childMetas = {};
     for (const child of node.children) {
@@ -1086,6 +1198,100 @@ function buildCriticTask(ctx, meta, config) {
     return sections.join('\n');
 }
 
+/**
+ * Structured error from a synthesis step failure.
+ *
+ * @module schema/error
+ */
+/** Zod schema for synthesis step errors. */
+const metaErrorSchema = z.object({
+    /** Which step failed: 'architect', 'builder', or 'critic'. */
+    step: z.enum(['architect', 'builder', 'critic']),
+    /** Error classification code. */
+    code: z.string(),
+    /** Human-readable error message. */
+    message: z.string(),
+});
+
+/**
+ * Zod schema for .meta/meta.json files.
+ *
+ * Reserved properties are underscore-prefixed and engine-managed.
+ * All other keys are open schema (builder output).
+ *
+ * @module schema/meta
+ */
+/** Zod schema for the reserved (underscore-prefixed) meta.json properties. */
+const metaJsonSchema = z
+    .object({
+    /** Stable identity. Generated on first synthesis, never changes. */
+    _id: z.uuid(),
+    /** Human-provided steering prompt. Optional. */
+    _steer: z.string().optional(),
+    /** Architect system prompt used this turn. Defaults from config. */
+    _architect: z.string().optional(),
+    /**
+     * Task brief generated by the architect. Cached and reused across cycles;
+     * regenerated only when triggered.
+     */
+    _builder: z.string().optional(),
+    /** Critic system prompt used this turn. Defaults from config. */
+    _critic: z.string().optional(),
+    /** Timestamp of last synthesis. ISO 8601. */
+    _generatedAt: z.iso.datetime().optional(),
+    /** Narrative synthesis output. Rendered by watcher for embedding. */
+    _content: z.string().optional(),
+    /**
+     * Hash of sorted file listing in scope. Detects directory structure
+     * changes that trigger an architect re-run.
+     */
+    _structureHash: z.string().optional(),
+    /**
+     * Cycles since last architect run. Reset to 0 when architect runs.
+     * Used with architectEvery to trigger periodic re-prompting.
+     */
+    _synthesisCount: z.number().int().min(0).optional(),
+    /** Critic evaluation of the last synthesis. */
+    _feedback: z.string().optional(),
+    /**
+     * Present and true on archive snapshots. Distinguishes live vs. archived
+     * metas.
+     */
+    _archived: z.boolean().optional(),
+    /** Timestamp when this snapshot was archived. ISO 8601. */
+    _archivedAt: z.iso.datetime().optional(),
+    /**
+     * Scheduling priority. Higher = updates more often. Negative allowed;
+     * normalized to min 0 at scheduling time.
+     */
+    _depth: z.number().optional(),
+    /**
+     * Emphasis multiplier for depth weighting in scheduling.
+     * Default 1. Higher values increase this meta's scheduling priority
+     * relative to its depth. Set to 0.5 to halve the depth effect,
+     * 2 to double it, 0 to ignore depth entirely for this meta.
+     */
+    _emphasis: z.number().min(0).optional(),
+    /** Token count from last architect subprocess call. */
+    _architectTokens: z.number().int().optional(),
+    /** Token count from last builder subprocess call. */
+    _builderTokens: z.number().int().optional(),
+    /** Token count from last critic subprocess call. */
+    _criticTokens: z.number().int().optional(),
+    /** Exponential moving average of architect token usage (decay 0.3). */
+    _architectTokensAvg: z.number().optional(),
+    /** Exponential moving average of builder token usage (decay 0.3). */
+    _builderTokensAvg: z.number().optional(),
+    /** Exponential moving average of critic token usage (decay 0.3). */
+    _criticTokensAvg: z.number().optional(),
+    /**
+     * Structured error from last cycle. Present when a step failed.
+     * Cleared on successful cycle.
+     */
+    _error: metaErrorSchema.optional(),
+})
+    .loose();
+
 /**
  * Merge synthesis results into meta.json.
  *
@@ -1168,12 +1374,50 @@ function mergeAndWrite(options) {
     if (!result.success) {
         throw new Error(`Meta validation failed: ${result.error.message}`);
     }
-    // Write atomically
-    const filePath = join(options.metaPath, 'meta.json');
+    // Write to specified path (lock staging) or default meta.json
+    const filePath = options.outputPath ?? join(options.metaPath, 'meta.json');
     writeFileSync(filePath, JSON.stringify(result.data, null, 2) + '\n');
     return result.data;
 }
 
+/**
+ * Weighted staleness formula for candidate selection.
+ *
+ * effectiveStaleness = actualStaleness * (normalizedDepth + 1) ^ (depthWeight * emphasis)
+ *
+ * @module scheduling/weightedFormula
+ */
+/**
+ * Compute effective staleness for a set of candidates.
+ *
+ * Normalizes depths so the minimum becomes 0, then applies the formula:
+ * effectiveStaleness = actualStaleness * (normalizedDepth + 1) ^ (depthWeight * emphasis)
+ *
+ * Per-meta _emphasis (default 1) multiplies depthWeight, allowing individual
+ * metas to tune how much their tree position affects scheduling.
+ *
+ * @param candidates - Array of \{ node, meta, actualStaleness \}.
+ * @param depthWeight - Exponent for depth weighting (0 = pure staleness).
+ * @returns Same array with effectiveStaleness computed.
+ */
+function computeEffectiveStaleness(candidates, depthWeight) {
+    if (candidates.length === 0)
+        return [];
+    // Get depth for each candidate: use _depth override or tree depth
+    const depths = candidates.map((c) => c.meta._depth ?? c.node.treeDepth);
+    // Normalize: shift so minimum becomes 0
+    const minDepth = Math.min(...depths);
+    const normalizedDepths = depths.map((d) => Math.max(0, d - minDepth));
+    return candidates.map((c, i) => {
+        const emphasis = c.meta._emphasis ?? 1;
+        return {
+            ...c,
+            effectiveStaleness: c.actualStaleness *
+                Math.pow(normalizedDepths[i] + 1, depthWeight * emphasis),
+        };
+    });
+}
+
 /**
  * Select the best synthesis candidate from stale metas.
  *
@@ -1198,6 +1442,21 @@ function selectCandidate(candidates) {
     }
     return best;
 }
+/**
+ * Extract stale candidates from a list and return the stalest path.
+ *
+ * Consolidates the repeated pattern of:
+ *   filter → computeEffectiveStaleness → selectCandidate → return path
+ *
+ * @param candidates - Array with node, meta, and stalenessSeconds.
+ * @param depthWeight - Depth weighting exponent from config.
+ * @returns The stalest candidate's metaPath, or null if none are stale.
+ */
+function discoverStalestPath(candidates, depthWeight) {
+    const weighted = computeEffectiveStaleness(candidates, depthWeight);
+    const winner = selectCandidate(weighted);
+    return winner?.node.metaPath ?? null;
+}
 
 /**
  * Staleness detection via watcher scan.
@@ -1265,63 +1524,23 @@ function hasSteerChanged(currentSteer, archiveSteer, hasArchive) {
         return Boolean(currentSteer);
     return currentSteer !== archiveSteer;
 }
-
-/**
- * Weighted staleness formula for candidate selection.
- *
- * effectiveStaleness = actualStaleness * (normalizedDepth + 1) ^ (depthWeight * emphasis)
- *
- * @module scheduling/weightedFormula
- */
-/**
- * Compute effective staleness for a set of candidates.
- *
- * Normalizes depths so the minimum becomes 0, then applies the formula:
- * effectiveStaleness = actualStaleness * (normalizedDepth + 1) ^ (depthWeight * emphasis)
- *
- * Per-meta _emphasis (default 1) multiplies depthWeight, allowing individual
- * metas to tune how much their tree position affects scheduling.
- *
- * @param candidates - Array of \{ node, meta, actualStaleness \}.
- * @param depthWeight - Exponent for depth weighting (0 = pure staleness).
- * @returns Same array with effectiveStaleness computed.
- */
-function computeEffectiveStaleness(candidates, depthWeight) {
-    if (candidates.length === 0)
-        return [];
-    // Get depth for each candidate: use _depth override or tree depth
-    const depths = candidates.map((c) => c.meta._depth ?? c.node.treeDepth);
-    // Normalize: shift so minimum becomes 0
-    const minDepth = Math.min(...depths);
-    const normalizedDepths = depths.map((d) => Math.max(0, d - minDepth));
-    return candidates.map((c, i) => {
-        const emphasis = c.meta._emphasis ?? 1;
-        return {
-            ...c,
-            effectiveStaleness: c.actualStaleness *
-                Math.pow(normalizedDepths[i] + 1, depthWeight * emphasis),
-        };
-    });
-}
-
 /**
- * Compute a structure hash from a sorted file listing.
+ * Compute a normalized staleness score (0–1) for display purposes.
  *
- * Used to detect when directory structure changes, triggering
- * an architect re-run.
- *
- * @module structureHash
- */
-/**
- * Compute a SHA-256 hash of a sorted file listing.
+ * Uses the same depth/emphasis weighting as candidate selection,
+ * normalized to a 30-day window.
  *
- * @param filePaths - Array of file paths in scope.
- * @returns Hex-encoded SHA-256 hash of the sorted, newline-joined paths.
+ * @param stalenessSeconds - Raw staleness in seconds (null = never synthesized).
+ * @param depth - Meta tree depth.
+ * @param emphasis - Scheduling emphasis multiplier.
+ * @param depthWeight - Depth weighting exponent from config.
+ * @returns Normalized score between 0 and 1.
  */
-function computeStructureHash(filePaths) {
-    const sorted = [...filePaths].sort();
-    const content = sorted.join('\n');
-    return createHash('sha256').update(content).digest('hex');
+function computeStalenessScore(stalenessSeconds, depth, emphasis, depthWeight) {
+    if (stalenessSeconds === null)
+        return 1;
+    const depthFactor = Math.pow(1 + depthWeight, depth);
+    return Math.min(1, (stalenessSeconds * depthFactor * emphasis) / (30 * 86400));
 }
 
 /**
@@ -1398,25 +1617,33 @@ function parseCriticOutput(output) {
  *
  * @module orchestrator/orchestrate
  */
-/** Finalize a cycle: merge, snapshot, prune. */
-function finalizeCycle(metaPath, current, config, architect, builder, critic, builderOutput, feedback, structureHash, synthesisCount, error, architectTokens, builderTokens, criticTokens) {
+/** Finalize a cycle using lock staging: write to .lock → copy to meta.json + archive → delete .lock. */
+function finalizeCycle(opts) {
+    const lockPath = join(opts.metaPath, '.lock');
+    const metaJsonPath = join(opts.metaPath, 'meta.json');
+    // Stage: write merged result to .lock
     const updated = mergeAndWrite({
-        metaPath,
-        current,
-        architect,
-        builder,
-        critic,
-        builderOutput,
-        feedback,
-        structureHash,
-        synthesisCount,
-        error,
-        architectTokens,
-        builderTokens,
-        criticTokens,
+        metaPath: opts.metaPath,
+        current: opts.current,
+        architect: opts.architect,
+        builder: opts.builder,
+        critic: opts.critic,
+        builderOutput: opts.builderOutput,
+        feedback: opts.feedback,
+        structureHash: opts.structureHash,
+        synthesisCount: opts.synthesisCount,
+        error: opts.error,
+        architectTokens: opts.architectTokens,
+        builderTokens: opts.builderTokens,
+        criticTokens: opts.criticTokens,
+        outputPath: lockPath,
     });
-    createSnapshot(metaPath, updated);
-    pruneArchive(metaPath, config.maxArchive);
+    // Commit: copy .lock → meta.json
+    copyFileSync(lockPath, metaJsonPath);
+    // Archive + prune from the committed meta.json
+    createSnapshot(opts.metaPath, updated);
+    pruneArchive(opts.metaPath, opts.config.maxArchive);
+    // .lock is cleaned up by the finally block (releaseLock)
     return updated;
 }
 /**
@@ -1430,7 +1657,7 @@ function finalizeCycle(metaPath, current, config, architect, builder, critic, bu
  * @param watcher - Watcher HTTP client.
  * @returns Result indicating whether synthesis occurred.
  */
-async function orchestrateOnce(config, executor, watcher, targetPath) {
+async function orchestrateOnce(config, executor, watcher, targetPath, onProgress) {
     // Step 1: Discover via watcher scan
     const metaPaths = await discoverMetas(config, watcher);
     if (metaPaths.length === 0)
@@ -1440,18 +1667,22 @@ async function orchestrateOnce(config, executor, watcher, targetPath) {
     for (const mp of metaPaths) {
         const metaFilePath = join(mp, 'meta.json');
         try {
-            metas.set(normalizePath$1(mp), JSON.parse(readFileSync(metaFilePath, 'utf8')));
+            metas.set(normalizePath(mp), JSON.parse(readFileSync(metaFilePath, 'utf8')));
         }
         catch {
             // Skip metas with unreadable meta.json
             continue;
         }
     }
-    const tree = buildOwnershipTree(metaPaths);
+    // Only build tree from paths with readable meta.json (excludes orphaned/deleted entries)
+    const validPaths = metaPaths.filter((mp) => metas.has(normalizePath(mp)));
+    if (validPaths.length === 0)
+        return { synthesized: false };
+    const tree = buildOwnershipTree(validPaths);
     // If targetPath specified, skip candidate selection — go directly to that meta
     let targetNode;
     if (targetPath) {
-        const normalized = normalizePath$1(targetPath);
+        const normalized = normalizePath(targetPath);
         targetNode = findNode(tree, normalized) ?? undefined;
         if (!targetNode)
             return { synthesized: false };
@@ -1460,6 +1691,8 @@ async function orchestrateOnce(config, executor, watcher, targetPath) {
     const candidates = [];
     for (const node of tree.nodes.values()) {
         const meta = metas.get(node.metaPath);
+        if (!meta)
+            continue; // Node not in metas map (e.g. unreadable meta.json)
         const staleness = actualStaleness(meta);
         if (staleness > 0) {
             candidates.push({ node, meta, actualStaleness: staleness });
@@ -1502,22 +1735,14 @@ async function orchestrateOnce(config, executor, watcher, targetPath) {
         const currentMeta = JSON.parse(readFileSync(join(node.metaPath, 'meta.json'), 'utf8'));
         const architectPrompt = currentMeta._architect ?? config.defaultArchitect;
         const criticPrompt = currentMeta._critic ?? config.defaultCritic;
-        // Step 5: Structure hash
-        const scopePrefix = getScopePrefix(node);
-        const allScanFiles = await paginatedScan(watcher, {
-            pathPrefix: scopePrefix,
-        });
-        const allFilePaths = allScanFiles.map((f) => f.file_path);
-        // Structure hash uses scope-filtered files (excluding child subtrees)
-        // so changes in child scopes don't trigger parent architect re-runs
-        const scopeFiles = filterInScope(node, allFilePaths);
-        const newStructureHash = computeStructureHash(scopeFiles);
-        const structureChanged = newStructureHash !== currentMeta._structureHash;
-        // Step 6: Steer change detection
+        // Step 5-6: Steer change detection
         const latestArchive = readLatestArchive(node.metaPath);
         const steerChanged = hasSteerChanged(currentMeta._steer, latestArchive?._steer, Boolean(latestArchive));
-        // Step 7: Compute context
+        // Step 7: Compute context (includes scope files and delta files)
         const ctx = await buildContextPackage(node, currentMeta, watcher);
+        // Step 5 (deferred): Structure hash from context scope files
+        const newStructureHash = computeStructureHash(ctx.scopeFiles);
+        const structureChanged = newStructureHash !== currentMeta._structureHash;
         // Step 8: Architect (conditional)
         const architectTriggered = isArchitectTriggered(currentMeta, structureChanged, steerChanged, config.architectEvery);
         let builderBrief = currentMeta._builder ?? '';
@@ -1528,19 +1753,46 @@ async function orchestrateOnce(config, executor, watcher, targetPath) {
         let criticTokens;
         if (architectTriggered) {
             try {
+                await onProgress?.({
+                    type: 'phase_start',
+                    metaPath: node.metaPath,
+                    phase: 'architect',
+                });
+                const phaseStart = Date.now();
                 const architectTask = buildArchitectTask(ctx, currentMeta, config);
                 const architectResult = await executor.spawn(architectTask, {
+                    thinking: config.thinking,
                     timeout: config.architectTimeout,
                 });
                 builderBrief = parseArchitectOutput(architectResult.output);
                 architectTokens = architectResult.tokens;
                 synthesisCount = 0;
+                await onProgress?.({
+                    type: 'phase_complete',
+                    metaPath: node.metaPath,
+                    phase: 'architect',
+                    tokens: architectTokens,
+                    durationMs: Date.now() - phaseStart,
+                });
             }
             catch (err) {
-                stepError = toSynthError('architect', err);
+                stepError = toMetaError('architect', err);
                 if (!currentMeta._builder) {
                     // No cached builder — cycle fails
-                    finalizeCycle(node.metaPath, currentMeta, config, architectPrompt, '', criticPrompt, null, null, newStructureHash, synthesisCount, stepError, architectTokens);
+                    finalizeCycle({
+                        metaPath: node.metaPath,
+                        current: currentMeta,
+                        config,
+                        architect: architectPrompt,
+                        builder: '',
+                        critic: criticPrompt,
+                        builderOutput: null,
+                        feedback: null,
+                        structureHash: newStructureHash,
+                        synthesisCount,
+                        error: stepError,
+                        architectTokens,
+                    });
                     return {
                         synthesized: true,
                         metaPath: node.metaPath,
@@ -1554,16 +1806,30 @@ async function orchestrateOnce(config, executor, watcher, targetPath) {
         const metaForBuilder = { ...currentMeta, _builder: builderBrief };
         let builderOutput = null;
         try {
+            await onProgress?.({
+                type: 'phase_start',
+                metaPath: node.metaPath,
+                phase: 'builder',
+            });
+            const builderStart = Date.now();
             const builderTask = buildBuilderTask(ctx, metaForBuilder, config);
             const builderResult = await executor.spawn(builderTask, {
+                thinking: config.thinking,
                 timeout: config.builderTimeout,
             });
             builderOutput = parseBuilderOutput(builderResult.output);
             builderTokens = builderResult.tokens;
             synthesisCount++;
+            await onProgress?.({
+                type: 'phase_complete',
+                metaPath: node.metaPath,
+                phase: 'builder',
+                tokens: builderTokens,
+                durationMs: Date.now() - builderStart,
+            });
         }
         catch (err) {
-            stepError = toSynthError('builder', err);
+            stepError = toMetaError('builder', err);
             return { synthesized: true, metaPath: node.metaPath, error: stepError };
         }
         // Step 10: Critic
@@ -1573,19 +1839,48 @@ async function orchestrateOnce(config, executor, watcher, targetPath) {
         };
         let feedback = null;
         try {
+            await onProgress?.({
+                type: 'phase_start',
+                metaPath: node.metaPath,
+                phase: 'critic',
+            });
+            const criticStart = Date.now();
             const criticTask = buildCriticTask(ctx, metaForCritic, config);
             const criticResult = await executor.spawn(criticTask, {
+                thinking: config.thinking,
                 timeout: config.criticTimeout,
             });
             feedback = parseCriticOutput(criticResult.output);
             criticTokens = criticResult.tokens;
             stepError = null; // Clear any architect error on full success
+            await onProgress?.({
+                type: 'phase_complete',
+                metaPath: node.metaPath,
+                phase: 'critic',
+                tokens: criticTokens,
+                durationMs: Date.now() - criticStart,
+            });
         }
         catch (err) {
-            stepError = stepError ?? toSynthError('critic', err);
+            stepError = stepError ?? toMetaError('critic', err);
         }
         // Steps 11-12: Merge, archive, prune
-        finalizeCycle(node.metaPath, currentMeta, config, architectPrompt, builderBrief, criticPrompt, builderOutput, feedback, newStructureHash, synthesisCount, stepError, architectTokens, builderTokens, criticTokens);
+        finalizeCycle({
+            metaPath: node.metaPath,
+            current: currentMeta,
+            config,
+            architect: architectPrompt,
+            builder: builderBrief,
+            critic: criticPrompt,
+            builderOutput,
+            feedback,
+            structureHash: newStructureHash,
+            synthesisCount,
+            error: stepError,
+            architectTokens,
+            builderTokens,
+            criticTokens,
+        });
         return {
             synthesized: true,
             metaPath: node.metaPath,
@@ -1598,59 +1893,1317 @@ async function orchestrateOnce(config, executor, watcher, targetPath) {
     }
 }
 /**
- * Run synthesis cycles up to batchSize.
+ * Run a single synthesis cycle.
  *
- * Calls orchestrateOnce() in a loop, stopping when batchSize is reached
- * or no more candidates are available.
+ * Selects the stalest candidate (or a specific target) and runs the
+ * full architect/builder/critic pipeline.
  *
  * @param config - Validated synthesis config.
  * @param executor - Pluggable LLM executor.
  * @param watcher - Watcher HTTP client.
  * @param targetPath - Optional: specific meta/owner path to synthesize instead of stalest candidate.
- * @returns Array of results, one per cycle attempted.
+ * @returns Array with a single result.
  */
-async function orchestrate(config, executor, watcher, targetPath) {
-    const results = [];
-    for (let i = 0; i < config.batchSize; i++) {
-        const result = await orchestrateOnce(config, executor, watcher, targetPath);
-        results.push(result);
-        if (!result.synthesized)
-            break; // No more candidates
-    }
-    return results;
+async function orchestrate(config, executor, watcher, targetPath, onProgress) {
+    const result = await orchestrateOnce(config, executor, watcher, targetPath, onProgress);
+    return [result];
 }
 
 /**
- * HTTP implementation of the WatcherClient interface.
- *
- * Talks to jeeves-watcher's POST /scan and POST /rules endpoints
- * with retry and exponential backoff.
+ * Progress reporting via OpenClaw gateway `/tools/invoke` → `message` tool.
  *
- * @module watcher-client/HttpWatcherClient
+ * @module progress
  */
-/** Default retry configuration. */
-const DEFAULT_MAX_RETRIES = 3;
-const DEFAULT_BACKOFF_BASE_MS = 1000;
-const DEFAULT_BACKOFF_FACTOR = 4;
-/** Sleep for a given number of milliseconds. */
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+function formatSeconds(durationMs) {
+    const seconds = durationMs / 1000;
+    return seconds.toFixed(1) + 's';
 }
-/** Check if an error is transient (worth retrying). */
-function isTransient(status) {
-    return status >= 500 || status === 408 || status === 429;
+function titleCasePhase(phase) {
+    return phase.charAt(0).toUpperCase() + phase.slice(1);
 }
-/**
- * HTTP-based WatcherClient implementation with retry.
- */
-class HttpWatcherClient {
-    baseUrl;
-    maxRetries;
-    backoffBaseMs;
-    backoffFactor;
-    constructor(options) {
-        this.baseUrl = options.baseUrl.replace(/\/+$/, '');
-        this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+function formatProgressEvent(event) {
+    switch (event.type) {
+        case 'synthesis_start':
+            return `🔬 Started meta synthesis: ${event.metaPath}`;
+        case 'phase_start': {
+            if (!event.phase) {
+                return `  ⚙️ Phase started: ${event.metaPath}`;
+            }
+            return `  ⚙️ ${titleCasePhase(event.phase)} phase started`;
+        }
+        case 'phase_complete': {
+            const phase = event.phase ? titleCasePhase(event.phase) : 'Phase';
+            const tokens = event.tokens ?? 0;
+            const duration = event.durationMs !== undefined
+                ? formatSeconds(event.durationMs)
+                : '0.0s';
+            return `  ✅ ${phase} phase complete (${String(tokens)} tokens / ${duration})`;
+        }
+        case 'synthesis_complete': {
+            const tokens = event.tokens ?? 0;
+            const duration = event.durationMs !== undefined
+                ? formatSeconds(event.durationMs)
+                : '0.0s';
+            return `✅ Completed: ${event.metaPath} (${String(tokens)} tokens / ${duration})`;
+        }
+        case 'error': {
+            const phase = event.phase ? `${titleCasePhase(event.phase)} ` : '';
+            const error = event.error ?? 'Unknown error';
+            return `❌ Synthesis failed at ${phase}phase: ${event.metaPath}\n   Error: ${error}`;
+        }
+        default: {
+            return 'Unknown progress event';
+        }
+    }
+}
+class ProgressReporter {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    async report(event) {
+        const target = this.config.reportChannel;
+        if (!target)
+            return;
+        const message = formatProgressEvent(event);
+        const url = new URL('/tools/invoke', this.config.gatewayUrl);
+        const payload = {
+            tool: 'message',
+            args: {
+                action: 'send',
+                target,
+                message,
+            },
+        };
+        try {
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...(this.config.gatewayApiKey
+                        ? { authorization: `Bearer ${this.config.gatewayApiKey}` }
+                        : {}),
+                },
+                body: JSON.stringify(payload),
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => '');
+                this.logger.warn({ status: res.status, statusText: res.statusText, body: text }, 'Progress reporting failed');
+            }
+        }
+        catch (err) {
+            this.logger.warn({ err }, 'Progress reporting threw');
+        }
+    }
+}
+
+/**
+ * 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;
+        }
+        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;
+    }
+    /**
+     * Set a callback to invoke when a new (non-duplicate) item is enqueued.
+     */
+    onEnqueue(callback) {
+        this.onEnqueueCallback = callback;
+    }
+    /**
+     * Add a path to the synthesis queue.
+     *
+     * @param path - Meta path to synthesize.
+     * @param priority - If true, insert at front of queue.
+     * @returns Position and whether the path was already queued.
+     */
+    enqueue(path, priority = false) {
+        // Check if currently being synthesized.
+        if (this.currentItem?.path === path) {
+            return { position: 0, alreadyQueued: true };
+        }
+        // Check if already in queue.
+        const existingIndex = this.queue.findIndex((item) => item.path === path);
+        if (existingIndex !== -1) {
+            return { position: existingIndex, alreadyQueued: true };
+        }
+        const item = {
+            path,
+            priority,
+            enqueuedAt: new Date().toISOString(),
+        };
+        if (priority) {
+            this.queue.unshift(item);
+        }
+        else {
+            this.queue.push(item);
+        }
+        if (this.queue.length > DEPTH_WARNING_THRESHOLD) {
+            this.logger.warn({ depth: this.queue.length }, 'Queue depth exceeds threshold');
+        }
+        const position = this.queue.findIndex((i) => i.path === path);
+        this.onEnqueueCallback?.();
+        return { position, alreadyQueued: false };
+    }
+    /**
+     * Remove and return the next item from the queue.
+     *
+     * @returns The next QueueItem, or undefined if the queue is empty.
+     */
+    dequeue() {
+        const item = this.queue.shift();
+        if (item) {
+            this.currentItem = item;
+        }
+        return item;
+    }
+    /** Mark the currently-running synthesis as complete. */
+    complete() {
+        this.currentItem = null;
+    }
+    /** Number of items waiting in the queue (excludes current). */
+    get depth() {
+        return this.queue.length;
+    }
+    /** The item currently being synthesized, or null. */
+    get current() {
+        return this.currentItem;
+    }
+    /** A shallow copy of the queued items. */
+    get items() {
+        return [...this.queue];
+    }
+    /**
+     * Check whether a path is in the queue or currently being synthesized.
+     *
+     * @param path - Meta path to look up.
+     * @returns True if the path is queued or currently running.
+     */
+    has(path) {
+        if (this.currentItem?.path === path)
+            return true;
+        return this.queue.some((item) => item.path === path);
+    }
+    /**
+     * Get the 0-indexed position of a path in the queue.
+     *
+     * @param path - Meta path to look up.
+     * @returns Position index, or null if not found in the queue.
+     */
+    getPosition(path) {
+        const index = this.queue.findIndex((item) => item.path === path);
+        return index === -1 ? null : index;
+    }
+    /**
+     * Return a snapshot of queue state for the /status endpoint.
+     *
+     * @returns Queue depth and item list.
+     */
+    getState() {
+        return {
+            depth: this.queue.length,
+            items: this.queue.map((item) => ({
+                path: item.path,
+                priority: item.priority,
+                enqueuedAt: item.enqueuedAt,
+            })),
+        };
+    }
+    /**
+     * Process queued items one at a time until the queue is empty.
+     *
+     * Re-entry is prevented: if already processing, the call returns
+     * immediately. Errors are logged and do not block subsequent items.
+     *
+     * @param synthesizeFn - Async function that performs synthesis for a path.
+     */
+    async processQueue(synthesizeFn) {
+        if (this.processing)
+            return;
+        this.processing = true;
+        try {
+            let item = this.dequeue();
+            while (item) {
+                try {
+                    await synthesizeFn(item.path);
+                }
+                catch (err) {
+                    this.logger.error({ path: item.path, err }, 'Synthesis failed');
+                }
+                this.complete();
+                item = this.dequeue();
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+}
+
+/**
+ * GET /config/validate — return sanitized service configuration.
+ *
+ * @module routes/configValidate
+ */
+function registerConfigValidateRoute(app, deps) {
+    app.get('/config/validate', () => {
+        const sanitized = {
+            ...deps.config,
+            gatewayApiKey: deps.config.gatewayApiKey ? '[REDACTED]' : undefined,
+        };
+        return sanitized;
+    });
+}
+
+/**
+ * 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(),
+});
+/** Compute summary stats from a filtered set of MetaEntries. */
+function computeFilteredSummary(entries) {
+    let staleCount = 0;
+    let errorCount = 0;
+    let neverSynthCount = 0;
+    let stalestPath = null;
+    let stalestSeconds = -1;
+    let lastSynthesizedPath = null;
+    let lastSynthesizedAt = null;
+    let totalArchitectTokens = 0;
+    let totalBuilderTokens = 0;
+    let totalCriticTokens = 0;
+    for (const e of entries) {
+        if (e.stalenessSeconds > 0)
+            staleCount++;
+        if (e.hasError)
+            errorCount++;
+        if (e.stalenessSeconds === Infinity)
+            neverSynthCount++;
+        if (e.stalenessSeconds > stalestSeconds) {
+            stalestSeconds = e.stalenessSeconds;
+            stalestPath = e.path;
+        }
+        if (e.lastSynthesized &&
+            (!lastSynthesizedAt || e.lastSynthesized > lastSynthesizedAt)) {
+            lastSynthesizedAt = e.lastSynthesized;
+            lastSynthesizedPath = e.path;
+        }
+        totalArchitectTokens += e.architectTokens ?? 0;
+        totalBuilderTokens += e.builderTokens ?? 0;
+        totalCriticTokens += e.criticTokens ?? 0;
+    }
+    return {
+        total: entries.length,
+        stale: staleCount,
+        errors: errorCount,
+        neverSynthesized: neverSynthCount,
+        stalestPath,
+        lastSynthesizedPath,
+        lastSynthesizedAt,
+        tokens: {
+            architect: totalArchitectTokens,
+            builder: totalBuilderTokens,
+            critic: totalCriticTokens,
+        },
+    };
+}
+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.stalenessSeconds === Infinity) === 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 = computeFilteredSummary(entries);
+        // 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(readFileSync(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,
+            },
+        };
+        // Archive
+        if (query.includeArchive) {
+            const archiveFiles = listArchiveFiles(targetNode.metaPath);
+            const limit = typeof query.includeArchive === 'number'
+                ? query.includeArchive
+                : archiveFiles.length;
+            const selected = archiveFiles.slice(-limit).reverse();
+            response.archive = selected.map((af) => {
+                const raw = readFileSync(af, 'utf8');
+                return projectMeta(JSON.parse(raw));
+            });
+        }
+        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 {
+            result = await listMetas(config, watcher);
+        }
+        catch {
+            return reply.status(503).send({
+                error: 'SERVICE_UNAVAILABLE',
+                message: 'Watcher unreachable — cannot compute preview',
+            });
+        }
+        let targetNode;
+        if (query.path) {
+            const normalized = normalizePath(query.path);
+            targetNode = findNode(result.tree, normalized);
+            if (!targetNode) {
+                return {
+                    error: 'NOT_FOUND',
+                    message: 'Meta path not found: ' + query.path,
+                };
+            }
+        }
+        else {
+            // Select stalest candidate
+            const stale = result.entries
+                .filter((e) => e.stalenessSeconds > 0)
+                .map((e) => ({
+                node: e.node,
+                meta: e.meta,
+                actualStaleness: e.stalenessSeconds,
+            }));
+            const stalestPath = discoverStalestPath(stale, config.depthWeight);
+            if (!stalestPath) {
+                return { message: 'No stale metas found. Nothing to synthesize.' };
+            }
+            targetNode = findNode(result.tree, stalestPath);
+        }
+        const meta = JSON.parse(readFileSync(join(targetNode.metaPath, 'meta.json'), 'utf8'));
+        // Scope files
+        const { scopeFiles } = await getScopeFiles(targetNode, watcher);
+        const structureHash = computeStructureHash(scopeFiles);
+        const structureChanged = structureHash !== meta._structureHash;
+        const latestArchive = readLatestArchive(targetNode.metaPath);
+        const steerChanged = hasSteerChanged(meta._steer, latestArchive?._steer, Boolean(latestArchive));
+        const architectTriggered = isArchitectTriggered(meta, structureChanged, steerChanged, config.architectEvery);
+        // Delta files
+        const deltaFiles = await getDeltaFiles(targetNode, watcher, meta._generatedAt, scopeFiles);
+        // EMA token estimates
+        const estimatedTokens = {
+            architect: meta._architectTokensAvg ?? meta._architectTokens ?? 0,
+            builder: meta._builderTokensAvg ?? meta._builderTokens ?? 0,
+            critic: meta._criticTokensAvg ?? meta._criticTokens ?? 0,
+        };
+        // Compute staleness
+        const stalenessSeconds = meta._generatedAt
+            ? Math.round((Date.now() - new Date(meta._generatedAt).getTime()) / 1000)
+            : null;
+        const stalenessScore = computeStalenessScore(stalenessSeconds, meta._depth ?? 0, meta._emphasis ?? 1, config.depthWeight);
+        return {
+            path: targetNode.metaPath,
+            staleness: {
+                seconds: stalenessSeconds,
+                score: Math.round(stalenessScore * 100) / 100,
+            },
+            architectWillRun: architectTriggered,
+            architectReason: [
+                ...(!meta._builder ? ['no cached builder (first run)'] : []),
+                ...(structureChanged ? ['structure changed'] : []),
+                ...(steerChanged ? ['steer changed'] : []),
+                ...((meta._synthesisCount ?? 0) >= config.architectEvery
+                    ? ['periodic refresh']
+                    : []),
+            ].join(', ') || 'not triggered',
+            scope: {
+                ownedFiles: scopeFiles.length,
+                childMetas: targetNode.children.length,
+                deltaFiles: deltaFiles
+                    .slice(0, 50)
+                    .map((f) => ({ path: f, action: 'modified' })),
+                deltaCount: deltaFiles.length,
+            },
+            estimatedTokens,
+        };
+    });
+}
+
+/**
+ * POST /seed — create a .meta/ directory with an empty meta.json.
+ *
+ * @module routes/seed
+ */
+const seedBodySchema = z.object({
+    path: z.string().min(1),
+});
+function registerSeedRoute(app, deps) {
+    app.post('/seed', (request, reply) => {
+        const body = seedBodySchema.parse(request.body);
+        const metaDir = resolveMetaDir(body.path);
+        if (existsSync(metaDir)) {
+            return reply.status(409).send({
+                error: 'CONFLICT',
+                message: `.meta directory already exists at ${body.path}`,
+            });
+        }
+        deps.logger.info({ metaDir }, 'creating .meta directory');
+        mkdirSync(metaDir, { recursive: true });
+        const metaJson = { _id: randomUUID() };
+        const metaJsonPath = join(metaDir, 'meta.json');
+        deps.logger.info({ metaJsonPath }, 'writing meta.json');
+        writeFileSync(metaJsonPath, JSON.stringify(metaJson, null, 2) + '\n');
+        return reply.status(201).send({
+            status: 'created',
+            path: body.path,
+            metaDir,
+            _id: metaJson._id,
+        });
+    });
+}
+
+/**
+ * GET /status — service health and status overview.
+ *
+ * On-demand dependency health checks (lightweight ping).
+ *
+ * @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 };
+    }
+}
+function registerStatusRoute(app, deps) {
+    app.get('/status', async () => {
+        const { config, queue, scheduler, stats, watcher } = deps;
+        // On-demand dependency checks
+        const [watcherHealth, gatewayHealth] = await Promise.all([
+            checkDependency(config.watcherUrl, '/status'),
+            checkDependency(config.gatewayUrl, '/api/status'),
+        ]);
+        const degraded = watcherHealth.status !== 'ok' || gatewayHealth.status !== 'ok';
+        // Determine status
+        let status;
+        if (deps.shuttingDown) {
+            status = 'stopping';
+        }
+        else if (queue.current) {
+            status = 'synthesizing';
+        }
+        else if (degraded) {
+            status = 'degraded';
+        }
+        else {
+            status = 'idle';
+        }
+        // Metas summary from listMetas (already computed)
+        let metasSummary = { total: 0, stale: 0, errors: 0, neverSynthesized: 0 };
+        try {
+            const result = await listMetas(config, watcher);
+            metasSummary = {
+                total: result.summary.total,
+                stale: result.summary.stale,
+                errors: result.summary.errors,
+                neverSynthesized: result.summary.neverSynthesized,
+            };
+        }
+        catch {
+            // Watcher unreachable — leave zeros
+        }
+        return {
+            service: 'jeeves-meta',
+            version: '0.4.0',
+            uptime: process.uptime(),
+            status,
+            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,
+                gateway: gatewayHealth,
+            },
+            metas: metasSummary,
+        };
+    });
+}
+
+/**
+ * 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);
+    registerConfigValidateRoute(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.
+ */
+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_unix: {
+                            type: 'integer',
+                            set: '{{toUnix json._generatedAt}}',
+                        },
+                        has_error: {
+                            type: 'boolean',
+                            set: '{{#if json._error}}true{{else}}false{{/if}}',
+                        },
+                    },
+                },
+            ],
+            render: {
+                frontmatter: [
+                    'meta_id',
+                    'meta_steer',
+                    'generated_at_unix',
+                    'meta_depth',
+                    'meta_emphasis',
+                    'meta_architect_tokens',
+                    'meta_builder_tokens',
+                    'meta_critic_tokens',
+                ],
+                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;
+    }
+}
+
+/**
+ * Minimal Fastify HTTP server for jeeves-meta service.
+ *
+ * @module server
+ */
+/**
+ * Create and configure the Fastify server.
+ *
+ * @param options - Server creation options.
+ * @returns Configured Fastify instance (not yet listening).
+ */
+function createServer(options) {
+    const app = Fastify({ logger: options.logger });
+    registerRoutes(app, {
+        config: options.config,
+        logger: options.logger,
+        queue: options.queue,
+        watcher: options.watcher,
+        scheduler: options.scheduler,
+        stats: options.stats,
+    });
+    return app;
+}
+
+/**
+ * Graceful shutdown handler.
+ *
+ * On SIGTERM/SIGINT: stops scheduler, drains queue, cleans up locks.
+ *
+ * @module shutdown
+ */
+/**
+ * Register shutdown handlers for SIGTERM and SIGINT.
+ *
+ * Flow:
+ * 1. Stop scheduler (no new ticks)
+ * 2. If synthesis in progress, release its lock
+ * 3. Close Fastify server
+ * 4. Exit
+ */
+function registerShutdownHandlers(deps) {
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        deps.logger.info({ signal }, 'Shutdown signal received');
+        // Signal stopping state to /status
+        if (deps.routeDeps) {
+            deps.routeDeps.shuttingDown = true;
+        }
+        // 1. Stop scheduler
+        if (deps.scheduler) {
+            deps.scheduler.stop();
+            deps.logger.info('Scheduler stopped');
+        }
+        // 2. Release lock for in-progress synthesis
+        const current = deps.queue.current;
+        if (current) {
+            try {
+                releaseLock(current.path);
+                deps.logger.info({ path: current.path }, 'Released lock for in-progress synthesis');
+            }
+            catch {
+                deps.logger.warn({ path: current.path }, 'Failed to release lock during shutdown');
+            }
+        }
+        // 3. Close server
+        try {
+            await deps.server.close();
+            deps.logger.info('HTTP server closed');
+        }
+        catch (err) {
+            deps.logger.error(err, 'Error closing HTTP server');
+        }
+        process.exit(0);
+    };
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+}
+
+/**
+ * HTTP implementation of the WatcherClient interface.
+ *
+ * Talks to jeeves-watcher's POST /scan and POST /rules endpoints
+ * with retry and exponential backoff.
+ *
+ * @module watcher-client/HttpWatcherClient
+ */
+/** Default retry configuration. */
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BACKOFF_BASE_MS = 1000;
+const DEFAULT_BACKOFF_FACTOR = 4;
+/** Check if an error is transient (worth retrying). */
+function isTransient(status) {
+    return status >= 500 || status === 408 || status === 429;
+}
+/**
+ * HTTP-based WatcherClient implementation with retry.
+ */
+class HttpWatcherClient {
+    baseUrl;
+    maxRetries;
+    backoffBaseMs;
+    backoffFactor;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, '');
+        this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
         this.backoffBaseMs = options.backoffBaseMs ?? DEFAULT_BACKOFF_BASE_MS;
         this.backoffFactor = options.backoffFactor ?? DEFAULT_BACKOFF_FACTOR;
     }
@@ -1735,4 +3288,176 @@ class HttpWatcherClient {
     }
 }
 
-export { GatewayExecutor, HttpWatcherClient, acquireLock, actualStaleness, buildArchitectTask, buildBuilderTask, buildContextPackage, buildCriticTask, buildMetaFilter, buildOwnershipTree, computeEffectiveStaleness, computeEma, computeStructureHash, createSnapshot, discoverMetas, filterInScope, findNode, getScopePrefix, hasSteerChanged, isArchitectTriggered, isLocked, isStale, listArchiveFiles, listMetas, loadSynthConfig, mergeAndWrite, metaJsonSchema, normalizePath$1 as normalizePath, orchestrate, paginatedScan, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, pruneArchive, readLatestArchive, releaseLock, resolveConfigPath, selectCandidate, synthConfigSchema, synthErrorSchema, toSynthError };
+/**
+ * Jeeves Meta Service — knowledge synthesis HTTP service for the Jeeves platform.
+ *
+ * @packageDocumentation
+ */
+// ── Archive ──
+/**
+ * Bootstrap the service: create logger, build server, start listening,
+ * wire scheduler, queue processing, rule registration, config hot-reload,
+ * startup lock cleanup, and shutdown.
+ *
+ * @param config - Validated service configuration.
+ * @param configPath - Optional path to config file for hot-reload.
+ */
+async function startService(config, configPath) {
+    const logger = createLogger({
+        level: config.logging.level,
+        file: config.logging.file,
+    });
+    // Wire synthesis executor + watcher
+    const watcher = new HttpWatcherClient({ baseUrl: config.watcherUrl });
+    const executor = new GatewayExecutor({
+        gatewayUrl: config.gatewayUrl,
+        apiKey: config.gatewayApiKey,
+    });
+    // Runtime stats (mutable, shared with routes)
+    const stats = {
+        totalSyntheses: 0,
+        totalTokens: 0,
+        totalErrors: 0,
+        lastCycleDurationMs: null,
+        lastCycleAt: null,
+    };
+    const queue = new SynthesisQueue(logger);
+    // Scheduler (needs watcher for discovery)
+    const scheduler = new Scheduler(config, queue, logger, watcher);
+    const routeDeps = {
+        config,
+        logger,
+        queue,
+        watcher,
+        scheduler,
+        stats,
+    };
+    const server = createServer({
+        logger,
+        config,
+        queue,
+        watcher,
+        scheduler,
+        stats,
+    });
+    // Start HTTP server
+    try {
+        await server.listen({ port: config.port, host: '0.0.0.0' });
+        logger.info({ port: config.port }, 'Service listening');
+    }
+    catch (err) {
+        logger.error(err, 'Failed to start service');
+        process.exit(1);
+    }
+    // Progress reporter — uses shared config reference so hot-reload propagates
+    const progress = new ProgressReporter(config, logger);
+    // Wire queue processing — synthesize one meta per dequeue
+    const synthesizeFn = async (path) => {
+        const startMs = Date.now();
+        let cycleTokens = 0;
+        await progress.report({
+            type: 'synthesis_start',
+            metaPath: path,
+        });
+        try {
+            const results = await orchestrate(config, executor, watcher, path, async (evt) => {
+                // Track token stats from phase completions
+                if (evt.type === 'phase_complete' && evt.tokens) {
+                    stats.totalTokens += evt.tokens;
+                    cycleTokens += evt.tokens;
+                }
+                await progress.report(evt);
+            });
+            // orchestrate() always returns exactly one result
+            const result = results[0];
+            const durationMs = Date.now() - startMs;
+            // Update stats
+            stats.totalSyntheses++;
+            stats.lastCycleDurationMs = durationMs;
+            stats.lastCycleAt = new Date().toISOString();
+            if (result.error) {
+                stats.totalErrors++;
+                await progress.report({
+                    type: 'error',
+                    metaPath: path,
+                    error: result.error.message,
+                });
+            }
+            else {
+                scheduler.resetBackoff();
+                await progress.report({
+                    type: 'synthesis_complete',
+                    metaPath: path,
+                    tokens: cycleTokens,
+                    durationMs,
+                });
+            }
+        }
+        catch (err) {
+            stats.totalErrors++;
+            const message = err instanceof Error ? err.message : String(err);
+            await progress.report({
+                type: 'error',
+                metaPath: path,
+                error: message,
+            });
+            throw err;
+        }
+    };
+    // Auto-process queue when new items arrive
+    queue.onEnqueue(() => {
+        void queue.processQueue(synthesizeFn);
+    });
+    // Startup: clean stale locks (gap #16)
+    try {
+        const metaResult = await listMetas(config, watcher);
+        const metaPaths = metaResult.entries.map((e) => e.node.metaPath);
+        cleanupStaleLocks(metaPaths, logger);
+    }
+    catch (err) {
+        logger.warn({ err }, 'Could not clean stale locks (watcher may be down)');
+    }
+    // Start scheduler
+    scheduler.start();
+    // Rule registration (fire-and-forget with retries)
+    const registrar = new RuleRegistrar(config, logger, watcher);
+    scheduler.setRegistrar(registrar);
+    void registrar.register();
+    // Config hot-reload (gap #12)
+    if (configPath) {
+        watchFile(configPath, { interval: 5000 }, () => {
+            try {
+                const newConfig = loadServiceConfig(configPath);
+                // Hot-reloadable fields: schedule, reportChannel, logging level
+                if (newConfig.schedule !== config.schedule) {
+                    scheduler.updateSchedule(newConfig.schedule);
+                    logger.info({ schedule: newConfig.schedule }, 'Schedule hot-reloaded');
+                }
+                if (newConfig.reportChannel !== config.reportChannel) {
+                    // Mutate shared config reference for progress reporter
+                    config.reportChannel =
+                        newConfig.reportChannel;
+                    logger.info({ reportChannel: newConfig.reportChannel }, 'reportChannel hot-reloaded');
+                }
+                if (newConfig.logging.level !== config.logging.level) {
+                    logger.level = newConfig.logging.level;
+                    logger.info({ level: newConfig.logging.level }, 'Log level hot-reloaded');
+                }
+            }
+            catch (err) {
+                logger.warn({ err }, 'Config hot-reload failed');
+            }
+        });
+    }
+    // Shutdown handlers
+    registerShutdownHandlers({
+        server,
+        scheduler,
+        queue,
+        logger,
+        routeDeps,
+    });
+    logger.info('Service fully initialized');
+}
+
+export { GatewayExecutor, HttpWatcherClient, ProgressReporter, RuleRegistrar, Scheduler, SynthesisQueue, acquireLock, actualStaleness, buildArchitectTask, buildBuilderTask, buildContextPackage, buildCriticTask, buildMetaFilter, buildOwnershipTree, cleanupStaleLocks, computeEffectiveStaleness, computeEma, computeStructureHash, createLogger, createServer, createSnapshot, discoverMetas, filterInScope, findNode, formatProgressEvent, getScopePrefix, hasSteerChanged, isArchitectTriggered, isLocked, isStale, listArchiveFiles, listMetas, loadServiceConfig, mergeAndWrite, metaConfigSchema, metaErrorSchema, metaJsonSchema, normalizePath, orchestrate, paginatedScan, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, pruneArchive, readLatestArchive, readLockState, registerRoutes, registerShutdownHandlers, releaseLock, resolveConfigPath, resolveMetaDir, selectCandidate, serviceConfigSchema, sleep, startService, toMetaError };