@karmaniverous/jeeves-meta 0.15.2 → 0.15.4

package/dist/cli/jeeves-meta/index.js

@@ -15,9 +15,9 @@ import * as commander from 'commander';
 import { execSync } from 'node:child_process';
 import { homedir, tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import Handlebars from 'handlebars';
 import { readFile, unlink, mkdir, writeFile, copyFile } from 'node:fs/promises';
 import pino from 'pino';
-import Handlebars from 'handlebars';
 import process$1 from 'node:process';
 import { Cron } from 'croner';
 import Fastify from 'fastify';
@@ -7239,6 +7239,11 @@ const workspaceCoreConfigSchema = z
     configRoot: z.string().optional().describe('Platform config root path'),
     /** OpenClaw gateway URL. */
     gatewayUrl: z.string().optional().describe('OpenClaw gateway URL'),
+    /** Dev repo paths keyed by component name. */
+    devRepos: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Dev repo paths by component name'),
 })
     .partial();
 /** Memory shared config section. */
@@ -7253,13 +7258,6 @@ const workspaceMemoryConfigSchema = z
         .max(1)
         .optional()
         .describe('Memory warning threshold'),
-    /** Staleness threshold in days. */
-    staleDays: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe('Memory staleness threshold in days'),
 })
     .partial();
 /** Workspace config Zod schema. */
@@ -8167,16 +8165,115 @@ function createServiceCli(descriptor) {
     });
     // Apply custom CLI commands if provided
     if (descriptor.customCliCommands) {
-        // Cast required: @commander-js/extra-typings Command has generic type
-        // parameters that don't align with the descriptor's base Command type.
-        // The descriptor can't know the parent Command's exact generic parameters
-        // at definition time. The cast is safe — customCliCommands only adds
-        // subcommands and doesn't depend on the parent's generic state.
         descriptor.customCliCommands(program);
     }
     return program;
 }
 
+var toolsPlatformTemplate = `### Tool Hierarchy
+
+When searching for information across indexed paths, **always use \`watcher_search\` before filesystem commands** (\`exec\`, \`grep\`, \`find\`). The semantic index covers the full indexed corpus and surfaces related files you may not have considered.
+
+Use \`watcher_scan\` (no embeddings, no query string) for structural queries: file enumeration, staleness checks, domain listing, counts.
+
+Direct filesystem access is for **acting on** search results, not bypassing them.
+
+### Shell Scripting
+
+Default to \`node -e\` or \`.js\` scripts for \`exec\` calls. PowerShell corrupts multi-byte UTF-8 characters and mangles escaping. Use PowerShell only for Windows service management, registry operations, and similar platform-specific tasks.
+
+### File Bridge for External Repos
+
+When editing files outside the workspace, use the bridge pattern: copy in → edit the workspace copy → bridge out. Never write temp patch scripts. The workspace is the authoritative working directory.
+
+### Gateway Self-Destruction Warning
+
+⚠️ Any command that stops the gateway **stops the assistant**. Never run \`openclaw gateway stop\` or \`openclaw gateway restart\` without explicit owner approval. When approved, it must be the **absolute last action** — all other work must be complete first, all messages sent, all files saved.
+
+### Messaging
+
+**Same-channel replies:** Don't use the \`message\` tool. It fires immediately, jumping ahead of streaming narration. Just write text as your response.
+
+**Cross-channel sends:** Use the \`message\` tool with an explicit \`target\` to send to a different channel or DM.
+
+### Plugin Lifecycle
+
+\`\`\`bash
+# Platform bootstrap (content seeding)
+npx @karmaniverous/jeeves install
+
+# Component plugin install
+npx @karmaniverous/jeeves-{component}-openclaw install
+
+# Component plugin uninstall
+npx @karmaniverous/jeeves-{component}-openclaw uninstall
+
+# Platform teardown (remove managed sections)
+npx @karmaniverous/jeeves uninstall
+\`\`\`
+
+Never manually edit \`~/.openclaw/extensions/\`. Always use the CLI commands above.
+
+### Reference Templates
+
+{{#if templatePath}}
+Reference templates are available at \`{{templatePath}}\`:
+
+| Template | Purpose |
+|----------|---------|
+| \`spec.md\` | Skeleton for new product specifications — all section headers, decision format, dev plan format |
+| \`spec-to-code-guide.md\` | The spec-to-code development practice — 7-stage iterative process, convergence loops, release gates |
+
+Read these templates when creating new specs, onboarding to new projects, or when asked about the development process.
+{{else}}
+> Reference templates not yet installed. Run \`npx @karmaniverous/jeeves install\` to seed templates.
+{{/if}}
+
+### Post-Upgrade Maintenance
+
+After updating OpenClaw (\`npm install -g openclaw@latest\` or equivalent), reinstall all Jeeves component plugins to repair install state:
+
+\`\`\`bash
+npx @karmaniverous/jeeves install
+npx @karmaniverous/jeeves-runner-openclaw install
+npx @karmaniverous/jeeves-watcher-openclaw install
+npx @karmaniverous/jeeves-server-openclaw install
+npx @karmaniverous/jeeves-meta-openclaw install
+\`\`\`
+
+Then restart the gateway. Plugin installers copy dist files and patch config; reinstalling after an OpenClaw update ensures the extensions directory stays consistent.
+
+### Source Code Preference
+
+{{#if devRepos}}
+When investigating, debugging, or analyzing Jeeves components, always read TypeScript source from dev repos — never compiled \`dist/\` from the global npm install. Dev repos:
+
+| Component | Dev Repo |
+|-----------|----------|
+{{#each devRepos}}
+| {{@key}} | \`{{this}}\` |
+{{/each}}
+
+Built code is minified, harder to reason about, and wastes context. Always \`git pull\` before analysis.
+{{else}}
+> Dev repo paths not configured. Add \`core.devRepos\` to \`jeeves.config.json\` to enable source code preference guidance.
+{{/if}}
+`;
+
+/**
+ * Internal function to maintain SOUL.md, AGENTS.md, and TOOLS.md Platform section.
+ *
+ * @remarks
+ * Called by `ComponentWriter` on each cycle. Not directly exposed to components.
+ * Reads content files from the package's `content/` directory, renders the
+ * Platform template with live data, and writes managed sections using
+ * `updateManagedSection`.
+ */
+/** Compiled Handlebars template for the Platform section (cached at module level). */
+Handlebars.compile(toolsPlatformTemplate, {
+    noEscape: true,
+});
+
 /**
  * Core configuration schema and resolution.
  *
@@ -8273,10 +8370,10 @@ function getServiceUrl(serviceName, consumerName) {
     if (coreUrl)
         return coreUrl;
     // 3. Fall back to port constants
-    const port = DEFAULT_PORTS[serviceName];
-    {
-        return `http://127.0.0.1:${String(port)}`;
+    if (serviceName in DEFAULT_PORTS) {
+        return `http://127.0.0.1:${String(DEFAULT_PORTS[serviceName])}`;
     }
+    throw new Error(`jeeves-core: unknown service "${serviceName}" and no config found`);
 }
 
 /**
@@ -8322,323 +8419,107 @@ function sleepAsync(ms) {
 }
 
 /**
- * Shared live config hot-reload support.
+ * Compute summary statistics from an array of MetaEntry objects.
  *
- * Used by both file-watch reloads in bootstrap and POST /config/apply
- * via the component descriptor's onConfigApply callback.
+ * Shared between listMetas() (full list) and route handlers (filtered lists).
  *
- * @module configHotReload
+ * @module discovery/computeSummary
  */
 /**
- * Fields that require a service restart to take effect.
+ * Compute summary statistics from a list of meta entries.
  *
- * Shared between the descriptor's `onConfigApply` and the file-watcher
- * hot-reload in `bootstrap.ts`.
+ * @param entries - Enriched meta entries (full or filtered).
+ * @param depthWeight - Config depth weight for effective staleness calculation.
+ * @returns Aggregated summary statistics.
  */
-const RESTART_REQUIRED_FIELDS = [
-    'port',
-    'watcherUrl',
-    'gatewayUrl',
-    'gatewayApiKey',
-    'defaultArchitect',
-    'defaultCritic',
-];
-let runtime = null;
-/** Register the active service runtime for config-apply hot reload. */
-function registerConfigHotReloadRuntime(nextRuntime) {
-    runtime = nextRuntime;
-}
-/** Apply hot-reloadable config changes to the live shared config object. */
-function applyHotReloadedConfig(newConfig) {
-    if (!runtime)
-        return;
-    const { config, logger, scheduler } = runtime;
-    for (const field of RESTART_REQUIRED_FIELDS) {
-        const oldVal = config[field];
-        const nextVal = newConfig[field];
-        if (oldVal !== nextVal) {
-            logger.warn({ field, oldValue: oldVal, newValue: nextVal }, 'Config field changed but requires restart to take effect');
-        }
-    }
-    if (newConfig.schedule !== config.schedule) {
-        scheduler?.updateSchedule(newConfig.schedule);
-        config.schedule = newConfig.schedule;
-        logger.info({ schedule: newConfig.schedule }, 'Schedule hot-reloaded');
-    }
-    if (newConfig.logging.level !== config.logging.level) {
-        logger.level = newConfig.logging.level;
-        config.logging.level = newConfig.logging.level;
-        logger.info({ level: newConfig.logging.level }, 'Log level hot-reloaded');
-    }
-    const restartSet = new Set(RESTART_REQUIRED_FIELDS);
-    for (const key of Object.keys(newConfig)) {
-        if (restartSet.has(key) || key === 'logging' || key === 'schedule') {
-            continue;
+function computeSummary(entries, depthWeight) {
+    let staleCount = 0;
+    let errorCount = 0;
+    let lockedCount = 0;
+    let disabledCount = 0;
+    let neverSynthesizedCount = 0;
+    let totalArchitectTokens = 0;
+    let totalBuilderTokens = 0;
+    let totalCriticTokens = 0;
+    let stalestPath = null;
+    let stalestEffective = -1;
+    let lastSynthesizedPath = null;
+    let lastSynthesizedAt = null;
+    for (const e of entries) {
+        if (e.stalenessSeconds > 0)
+            staleCount++;
+        if (e.hasError)
+            errorCount++;
+        if (e.locked)
+            lockedCount++;
+        if (e.disabled)
+            disabledCount++;
+        if (e.lastSynthesized === null)
+            neverSynthesizedCount++;
+        totalArchitectTokens += e.architectTokens ?? 0;
+        totalBuilderTokens += e.builderTokens ?? 0;
+        totalCriticTokens += e.criticTokens ?? 0;
+        // Track last synthesized
+        if (e.lastSynthesized &&
+            (!lastSynthesizedAt || e.lastSynthesized > lastSynthesizedAt)) {
+            lastSynthesizedAt = e.lastSynthesized;
+            lastSynthesizedPath = e.path;
         }
-        const oldVal = config[key];
-        const nextVal = newConfig[key];
-        if (JSON.stringify(oldVal) !== JSON.stringify(nextVal)) {
-            config[key] = nextVal;
-            logger.info({ field: key }, 'Config field hot-reloaded');
+        // Track stalest (effective staleness for scheduling)
+        const depthFactor = Math.pow(1 + depthWeight, e.depth);
+        const effectiveStaleness = e.stalenessSeconds * depthFactor * e.emphasis;
+        if (effectiveStaleness > stalestEffective) {
+            stalestEffective = effectiveStaleness;
+            stalestPath = e.path;
         }
     }
+    return {
+        total: entries.length,
+        stale: staleCount,
+        errors: errorCount,
+        locked: lockedCount,
+        disabled: disabledCount,
+        neverSynthesized: neverSynthesizedCount,
+        tokens: {
+            architect: totalArchitectTokens,
+            builder: totalBuilderTokens,
+            critic: totalCriticTokens,
+        },
+        stalestPath,
+        lastSynthesizedPath,
+        lastSynthesizedAt,
+    };
 }
 
 /**
- * Zod schema for jeeves-meta service configuration.
+ * Normalize file paths to forward slashes for consistency with watcher-indexed paths.
  *
- * The service config is a strict superset of the core (library-compatible) meta config.
+ * Watcher indexes paths with forward slashes (`j:/domains/...`). This utility
+ * ensures all paths in the library use the same convention, regardless of
+ * the platform's native separator.
  *
- * @module schema/config
+ * @module normalizePath
  */
-/** 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:18789'),
-    /** Optional API key for gateway authentication. */
-    gatewayApiKey: z.string().optional(),
-    /** Run architect every N cycles (per meta). */
-    architectEvery: z.number().int().min(1).default(10),
-    /** Exponent for depth weighting in staleness formula. */
-    depthWeight: z.number().min(0).default(0.5),
-    /** Maximum archive snapshots to retain per meta. */
-    maxArchive: z.number().int().min(1).default(20),
-    /** Maximum lines of context to include in subprocess prompts. */
-    maxLines: z.number().int().min(50).default(500),
-    /** Architect subprocess timeout in seconds. */
-    architectTimeout: z.number().int().min(30).default(180),
-    /** Builder subprocess timeout in seconds. */
-    builderTimeout: z.number().int().min(60).default(360),
-    /** Critic subprocess timeout in seconds. */
-    criticTimeout: z.number().int().min(30).default(240),
-    /** Thinking level for spawned synthesis sessions. */
-    thinking: z.string().default('low'),
-    /** Resolved architect system prompt text. Falls back to built-in default. */
-    defaultArchitect: z.string().optional(),
-    /** Resolved critic system prompt text. Falls back to built-in default. */
-    defaultCritic: z.string().optional(),
-    /** Skip unchanged candidates, bump _generatedAt. */
-    skipUnchanged: z.boolean().default(true),
-    /** 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
-        .record(z.string(), z.unknown())
-        .default({ _meta: 'archive' }),
-});
-/** 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 a single auto-seed policy rule. */
-const autoSeedRuleSchema = z.object({
-    /** Glob pattern matched against watcher walk results. */
-    match: z.string(),
-    /** Optional steering prompt for seeded metas. */
-    steer: z.string().optional(),
-    /** Optional cross-references for seeded metas. */
-    crossRefs: z.array(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 * * * *'),
-    /** Messaging channel name (e.g. 'slack'). Legacy: also used as target if reportTarget is unset. */
-    reportChannel: z.string().optional(),
-    /** Channel/user ID to send progress messages to. */
-    reportTarget: z.string().optional(),
-    /** Optional base URL for the service, used to construct entity links in progress reports. */
-    serverBaseUrl: z.string().optional(),
-    /** Interval in ms for periodic watcher health check. 0 = disabled. Default: 60000. */
-    watcherHealthIntervalMs: z.number().int().min(0).default(60_000),
-    /** Logging configuration. */
-    logging: loggingSchema.default(() => loggingSchema.parse({})),
-    /**
-     * Auto-seed policy: declarative rules for auto-creating .meta/ directories.
-     * Rules are evaluated in order; last match wins for steer/crossRefs.
-     */
-    autoSeed: z.array(autoSeedRuleSchema).optional().default([]),
-});
+/**
+ * Normalize a file path to forward slashes.
+ *
+ * @param p - File path (may contain backslashes).
+ * @returns Path with all backslashes replaced by forward slashes.
+ */
+function normalizePath(p) {
+    return p.replaceAll('\\', '/');
+}
 
 /**
- * Load and resolve jeeves-meta service config.
+ * Discover .meta/ directories via watcher `/walk` endpoint.
  *
- * Supports \@file: indirection and environment-variable substitution (dollar-brace pattern).
+ * Uses filesystem enumeration through the watcher (not Qdrant) to find
+ * all `.meta/meta.json` files and returns deduplicated meta directory paths.
  *
- * @module configLoader
+ * @module discovery/discoverMetas
  */
 /**
- * Deep-walk a value, replacing `\${VAR\}` patterns with process.env values.
- *
- * @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.
- *
- * @param value - String value that may start with "\@file:".
- * @param baseDir - Base directory for resolving relative paths.
- * @returns The resolved string (file contents or original value).
- */
-function resolveFileRef(value, baseDir) {
-    if (!value.startsWith('@file:'))
-        return value;
-    const filePath = join(baseDir, value.slice(6));
-    return readFileSync(filePath, 'utf8');
-}
-/**
- * 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);
-}
-
-/**
- * Compute summary statistics from an array of MetaEntry objects.
- *
- * Shared between listMetas() (full list) and route handlers (filtered lists).
- *
- * @module discovery/computeSummary
- */
-/**
- * Compute summary statistics from a list of meta entries.
- *
- * @param entries - Enriched meta entries (full or filtered).
- * @param depthWeight - Config depth weight for effective staleness calculation.
- * @returns Aggregated summary statistics.
- */
-function computeSummary(entries, depthWeight) {
-    let staleCount = 0;
-    let errorCount = 0;
-    let lockedCount = 0;
-    let disabledCount = 0;
-    let neverSynthesizedCount = 0;
-    let totalArchitectTokens = 0;
-    let totalBuilderTokens = 0;
-    let totalCriticTokens = 0;
-    let stalestPath = null;
-    let stalestEffective = -1;
-    let lastSynthesizedPath = null;
-    let lastSynthesizedAt = null;
-    for (const e of entries) {
-        if (e.stalenessSeconds > 0)
-            staleCount++;
-        if (e.hasError)
-            errorCount++;
-        if (e.locked)
-            lockedCount++;
-        if (e.disabled)
-            disabledCount++;
-        if (e.lastSynthesized === null)
-            neverSynthesizedCount++;
-        totalArchitectTokens += e.architectTokens ?? 0;
-        totalBuilderTokens += e.builderTokens ?? 0;
-        totalCriticTokens += e.criticTokens ?? 0;
-        // Track last synthesized
-        if (e.lastSynthesized &&
-            (!lastSynthesizedAt || e.lastSynthesized > lastSynthesizedAt)) {
-            lastSynthesizedAt = e.lastSynthesized;
-            lastSynthesizedPath = e.path;
-        }
-        // Track stalest (effective staleness for scheduling)
-        const depthFactor = Math.pow(1 + depthWeight, e.depth);
-        const effectiveStaleness = e.stalenessSeconds * depthFactor * e.emphasis;
-        if (effectiveStaleness > stalestEffective) {
-            stalestEffective = effectiveStaleness;
-            stalestPath = e.path;
-        }
-    }
-    return {
-        total: entries.length,
-        stale: staleCount,
-        errors: errorCount,
-        locked: lockedCount,
-        disabled: disabledCount,
-        neverSynthesized: neverSynthesizedCount,
-        tokens: {
-            architect: totalArchitectTokens,
-            builder: totalBuilderTokens,
-            critic: totalCriticTokens,
-        },
-        stalestPath,
-        lastSynthesizedPath,
-        lastSynthesizedAt,
-    };
-}
-
-/**
- * Normalize file paths to forward slashes for consistency with watcher-indexed paths.
- *
- * Watcher indexes paths with forward slashes (`j:/domains/...`). This utility
- * ensures all paths in the library use the same convention, regardless of
- * the platform's native separator.
- *
- * @module normalizePath
- */
-/**
- * Normalize a file path to forward slashes.
- *
- * @param p - File path (may contain backslashes).
- * @returns Path with all backslashes replaced by forward slashes.
- */
-function normalizePath(p) {
-    return p.replaceAll('\\', '/');
-}
-
-/**
- * Discover .meta/ directories via watcher `/walk` endpoint.
- *
- * Uses filesystem enumeration through the watcher (not Qdrant) to find
- * all `.meta/meta.json` files and returns deduplicated meta directory paths.
- *
- * @module discovery/discoverMetas
- */
-/**
- * Discover all .meta/ directories via watcher walk.
+ * Discover all .meta/ directories via watcher walk.
  *
  * Uses the watcher's `/walk` endpoint to find all `.meta/meta.json` files
  * and returns deduplicated meta directory paths.
@@ -9193,6 +9074,263 @@ function getDeltaFiles(generatedAt, scopeFiles) {
     return filterModifiedAfter(scopeFiles, new Date(generatedAt).getTime());
 }
 
+/**
+ * In-memory cache for listMetas results with TTL and concurrent refresh guard.
+ *
+ * @module cache
+ */
+const TTL_MS = 60_000;
+/**
+ * Caches listMetas results to avoid expensive repeated filesystem walks.
+ * Supports concurrent refresh coalescing and manual invalidation.
+ */
+class MetaCache {
+    result = null;
+    updatedAt = 0;
+    refreshPromise = null;
+    /** Get cached result or refresh if stale. */
+    async get(config, watcher) {
+        if (this.result && Date.now() - this.updatedAt < TTL_MS) {
+            return this.result;
+        }
+        return this.refresh(config, watcher);
+    }
+    /** Force-expire the cache so next get() triggers a refresh. */
+    invalidate() {
+        this.updatedAt = 0;
+    }
+    async refresh(config, watcher) {
+        if (this.refreshPromise)
+            return this.refreshPromise;
+        this.refreshPromise = listMetas(config, watcher)
+            .then((result) => {
+            this.result = result;
+            this.updatedAt = Date.now();
+            return result;
+        })
+            .finally(() => {
+            this.refreshPromise = null;
+        });
+        return this.refreshPromise;
+    }
+}
+
+/**
+ * Shared live config hot-reload support.
+ *
+ * Used by both file-watch reloads in bootstrap and POST /config/apply
+ * via the component descriptor's onConfigApply callback.
+ *
+ * @module configHotReload
+ */
+/**
+ * Fields that require a service restart to take effect.
+ *
+ * Shared between the descriptor's `onConfigApply` and the file-watcher
+ * hot-reload in `bootstrap.ts`.
+ */
+const RESTART_REQUIRED_FIELDS = [
+    'port',
+    'watcherUrl',
+    'gatewayUrl',
+    'gatewayApiKey',
+    'defaultArchitect',
+    'defaultCritic',
+];
+let runtime = null;
+/** Register the active service runtime for config-apply hot reload. */
+function registerConfigHotReloadRuntime(nextRuntime) {
+    runtime = nextRuntime;
+}
+/** Apply hot-reloadable config changes to the live shared config object. */
+function applyHotReloadedConfig(newConfig) {
+    if (!runtime)
+        return;
+    const { config, logger, scheduler } = runtime;
+    for (const field of RESTART_REQUIRED_FIELDS) {
+        const oldVal = config[field];
+        const nextVal = newConfig[field];
+        if (oldVal !== nextVal) {
+            logger.warn({ field, oldValue: oldVal, newValue: nextVal }, 'Config field changed but requires restart to take effect');
+        }
+    }
+    if (newConfig.schedule !== config.schedule) {
+        scheduler?.updateSchedule(newConfig.schedule);
+        config.schedule = newConfig.schedule;
+        logger.info({ schedule: newConfig.schedule }, 'Schedule hot-reloaded');
+    }
+    if (newConfig.logging.level !== config.logging.level) {
+        logger.level = newConfig.logging.level;
+        config.logging.level = newConfig.logging.level;
+        logger.info({ level: newConfig.logging.level }, 'Log level hot-reloaded');
+    }
+    const restartSet = new Set(RESTART_REQUIRED_FIELDS);
+    for (const key of Object.keys(newConfig)) {
+        if (restartSet.has(key) || key === 'logging' || key === 'schedule') {
+            continue;
+        }
+        const oldVal = config[key];
+        const nextVal = newConfig[key];
+        if (JSON.stringify(oldVal) !== JSON.stringify(nextVal)) {
+            config[key] = nextVal;
+            logger.info({ field: key }, 'Config field hot-reloaded');
+        }
+    }
+}
+
+/**
+ * Zod schema for jeeves-meta service configuration.
+ *
+ * The service config is a strict superset of the core (library-compatible) meta config.
+ *
+ * @module schema/config
+ */
+/** 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:18789'),
+    /** Optional API key for gateway authentication. */
+    gatewayApiKey: z.string().optional(),
+    /** Run architect every N cycles (per meta). */
+    architectEvery: z.number().int().min(1).default(10),
+    /** Exponent for depth weighting in staleness formula. */
+    depthWeight: z.number().min(0).default(0.5),
+    /** Maximum archive snapshots to retain per meta. */
+    maxArchive: z.number().int().min(1).default(20),
+    /** Maximum lines of context to include in subprocess prompts. */
+    maxLines: z.number().int().min(50).default(500),
+    /** Architect subprocess timeout in seconds. */
+    architectTimeout: z.number().int().min(30).default(180),
+    /** Builder subprocess timeout in seconds. */
+    builderTimeout: z.number().int().min(60).default(360),
+    /** Critic subprocess timeout in seconds. */
+    criticTimeout: z.number().int().min(30).default(240),
+    /** Thinking level for spawned synthesis sessions. */
+    thinking: z.string().default('low'),
+    /** Resolved architect system prompt text. Falls back to built-in default. */
+    defaultArchitect: z.string().optional(),
+    /** Resolved critic system prompt text. Falls back to built-in default. */
+    defaultCritic: z.string().optional(),
+    /** Skip unchanged candidates, bump _generatedAt. */
+    skipUnchanged: z.boolean().default(true),
+    /** 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
+        .record(z.string(), z.unknown())
+        .default({ _meta: 'archive' }),
+});
+/** 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 a single auto-seed policy rule. */
+const autoSeedRuleSchema = z.object({
+    /** Glob pattern matched against watcher walk results. */
+    match: z.string(),
+    /** Optional steering prompt for seeded metas. */
+    steer: z.string().optional(),
+    /** Optional cross-references for seeded metas. */
+    crossRefs: z.array(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 * * * *'),
+    /** Messaging channel name (e.g. 'slack'). Legacy: also used as target if reportTarget is unset. */
+    reportChannel: z.string().optional(),
+    /** Channel/user ID to send progress messages to. */
+    reportTarget: z.string().optional(),
+    /** Optional base URL for the service, used to construct entity links in progress reports. */
+    serverBaseUrl: z.string().optional(),
+    /** Interval in ms for periodic watcher health check. 0 = disabled. Default: 60000. */
+    watcherHealthIntervalMs: z.number().int().min(0).default(60_000),
+    /** Logging configuration. */
+    logging: loggingSchema.default(() => loggingSchema.parse({})),
+    /**
+     * Auto-seed policy: declarative rules for auto-creating .meta/ directories.
+     * Rules are evaluated in order; last match wins for steer/crossRefs.
+     */
+    autoSeed: z.array(autoSeedRuleSchema).optional().default([]),
+});
+
+/**
+ * Load and resolve jeeves-meta service config.
+ *
+ * Supports \@file: indirection and environment-variable substitution (dollar-brace pattern).
+ *
+ * @module configLoader
+ */
+/**
+ * Deep-walk a value, replacing `\${VAR\}` patterns with process.env values.
+ *
+ * @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.
+ *
+ * @param value - String value that may start with "\@file:".
+ * @param baseDir - Base directory for resolving relative paths.
+ * @returns The resolved string (file contents or original value).
+ */
+function resolveFileRef(value, baseDir) {
+    if (!value.startsWith('@file:'))
+        return value;
+    const filePath = join(baseDir, value.slice(6));
+    return readFileSync(filePath, 'utf8');
+}
+/**
+ * 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);
+}
+
 /**
  * Error thrown when a spawned subprocess is aborted via AbortController.
  *
@@ -9291,21 +9429,29 @@ class GatewayExecutor {
         }
         return data;
     }
-    /** Look up totalTokens for a session via sessions_list. */
-    async getSessionTokens(sessionKey) {
+    /** Look up session metadata (tokens, completion status) via sessions_list. */
+    async getSessionInfo(sessionKey) {
         try {
             const result = await this.invoke('sessions_list', {
-                limit: 20,
+                limit: 200,
                 messageLimit: 0,
             });
             const sessions = (result.result?.details?.sessions ??
                 result.result?.sessions ??
                 []);
             const match = sessions.find((s) => s.key === sessionKey);
-            return match?.totalTokens ?? undefined;
+            if (!match) {
+                // Session absent from list — likely cleaned up after completion.
+                // With limit=200 this is reliable; a false positive here only
+                // means we read the output file slightly early (still correct
+                // if the file exists).
+                return { completed: true };
+            }
+            const done = match.status === 'completed' || match.status === 'done';
+            return { tokens: match.totalTokens, completed: done };
         }
         catch {
-            return undefined;
+            return { completed: false };
         }
     }
     /** Whether this executor has been aborted by the operator. */
@@ -9335,7 +9481,7 @@ class GatewayExecutor {
             'Write your complete output to a file using the Write tool at:\n' +
             outputPath +
             '\n\n' +
-            'Reply with ONLY the file path you wrote to. No other text.';
+            'After writing the file, reply with ONLY: NO_REPLY';
         // Step 1: Spawn the sub-agent session (unique label per cycle to avoid
         // "label already in use" errors — gateway labels persist after session completion)
         const labelBase = options?.label ?? 'jeeves-meta-synthesis';
@@ -9371,48 +9517,53 @@ class GatewayExecutor {
                     historyResult.result?.messages ??
                     [];
                 const msgArray = messages;
+                // Check 1: terminal stop reason in history
+                let historyDone = false;
                 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') {
-                        // Fetch token usage from session metadata
-                        const tokens = await this.getSessionTokens(sessionKey);
-                        // Read output from file (sub-agent wrote it via Write tool)
-                        if (existsSync(outputPath)) {
+                        historyDone = true;
+                    }
+                }
+                // Check 2: session completion status via sessions_list
+                const sessionInfo = await this.getSessionInfo(sessionKey);
+                if (historyDone || sessionInfo.completed) {
+                    const tokens = sessionInfo.tokens;
+                    // Read output from file (sub-agent wrote it via Write tool)
+                    if (existsSync(outputPath)) {
+                        try {
+                            const output = readFileSync(outputPath, 'utf8');
+                            return { output, tokens };
+                        }
+                        finally {
                             try {
-                                const output = readFileSync(outputPath, 'utf8');
-                                return { output, tokens };
+                                unlinkSync(outputPath);
                             }
-                            finally {
-                                try {
-                                    unlinkSync(outputPath);
-                                }
-                                catch {
-                                    /* cleanup best-effort */
-                                }
+                            catch {
+                                /* cleanup best-effort */
                             }
                         }
-                        // Fallback: extract from message content if file wasn't written
-                        for (let i = msgArray.length - 1; i >= 0; i--) {
-                            const msg = msgArray[i];
-                            if (msg.role === 'assistant' && msg.content) {
-                                const text = typeof msg.content === 'string'
+                    }
+                    // Fallback: extract from message content if file wasn't written
+                    for (let i = msgArray.length - 1; i >= 0; i--) {
+                        const msg = msgArray[i];
+                        if (msg.role === 'assistant' && msg.content) {
+                            const text = typeof msg.content === 'string'
+                                ? msg.content
+                                : Array.isArray(msg.content)
                                     ? msg.content
-                                    : Array.isArray(msg.content)
-                                        ? msg.content
-                                            .filter((b) => b.type === 'text' && b.text)
-                                            .map((b) => b.text)
-                                            .join('\n')
-                                        : '';
-                                if (text)
-                                    return { output: text, tokens };
-                            }
+                                        .filter((b) => b.type === 'text' && b.text)
+                                        .map((b) => b.text)
+                                        .join('\n')
+                                    : '';
+                            if (text)
+                                return { output: text, tokens };
                         }
-                        return { output: '', tokens };
                     }
+                    return { output: '', tokens };
                 }
             }
             catch {
@@ -9775,6 +9926,7 @@ async function buildContextPackage(node, meta, watcher, logger) {
  *
  * @module orchestrator/buildTask
  */
+Handlebars.registerHelper('gt', (a, b) => a > b);
 /** Build the template context from synthesis inputs. */
 function buildTemplateContext(ctx, meta, config) {
     return {
@@ -9929,134 +10081,6 @@ function buildCriticTask(ctx, meta, config) {
     return compileTemplate(sections.join('\n'), buildTemplateContext(ctx, meta, config));
 }
 
-/**
- * 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
- */
-/** Valid states for a synthesis phase. */
-const phaseStatuses = [
-    'fresh',
-    'stale',
-    'pending',
-    'running',
-    'failed',
-];
-/** Zod schema for a per-phase status value. */
-const phaseStatusSchema = z.enum(phaseStatuses);
-/** Zod schema for the per-meta phase state record. */
-const phaseStateSchema = z.object({
-    architect: phaseStatusSchema,
-    builder: phaseStatusSchema,
-    critic: phaseStatusSchema,
-});
-/** Zod schema for the reserved (underscore-prefixed) meta.json properties. */
-z
-    .object({
-    /** Stable identity. Auto-generated on first synthesis if not provided. */
-    _id: z.uuid().optional(),
-    /** Human-provided steering prompt. Optional. */
-    _steer: z.string().optional(),
-    /**
-     * Explicit cross-references to other meta owner paths.
-     * Referenced metas' _content is included as architect/builder context.
-     */
-    _crossRefs: z.array(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(),
-    /**
-     * Opaque state carried across synthesis cycles for progressive work.
-     * Set by the builder, passed back as context on next cycle.
-     */
-    _state: z.unknown().optional(),
-    /**
-     * Structured error from last cycle. Present when a step failed.
-     * Cleared on successful cycle.
-     */
-    _error: metaErrorSchema.optional(),
-    /** When true, this meta is skipped during staleness scheduling. Manual trigger still works. */
-    _disabled: z.boolean().optional(),
-    /**
-     * Per-phase state machine record. Engine-managed.
-     * Keyed by phase name (architect, builder, critic) with status values.
-     * Persisted to survive ticks; derived on first load for back-compat.
-     */
-    _phaseState: phaseStateSchema.optional(),
-})
-    .loose();
-
 /**
  * Build a minimal MetaNode from a known meta path using watcher walk.
  *
@@ -10118,222 +10142,6 @@ async function buildMinimalNode(metaPath, watcher) {
     return node;
 }
 
-/**
- * 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.
- *
- * Picks the meta with highest effective staleness.
- *
- * @module scheduling/selectCandidate
- */
-/**
- * Select the candidate with the highest effective staleness.
- *
- * @param candidates - Array of candidates with computed effective staleness.
- * @returns The winning candidate, or null if no candidates.
- */
-function selectCandidate(candidates) {
-    if (candidates.length === 0)
-        return null;
-    let best = candidates[0];
-    for (let i = 1; i < candidates.length; i++) {
-        if (candidates[i].effectiveStaleness > best.effectiveStaleness) {
-            best = candidates[i];
-        }
-    }
-    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;
-}
-
-/**
- * Shared error utilities.
- *
- * @module errors
- */
-/**
- * Wrap an unknown caught value into a MetaError.
- *
- * @param step - Which synthesis step failed.
- * @param err - The caught error value.
- * @param code - Error classification code.
- * @returns A structured MetaError.
- */
-function toMetaError(step, err, code = 'FAILED') {
-    return {
-        step,
-        code,
-        message: err instanceof Error ? err.message : String(err),
-    };
-}
-
-/**
- * Compute a structure hash from a sorted file listing.
- *
- * Used to detect when directory structure changes, triggering
- * an architect re-run.
- *
- * @module structureHash
- */
-/**
- * Compute a SHA-256 hash of a sorted file listing.
- *
- * @param filePaths - Array of file paths in scope.
- * @returns Hex-encoded SHA-256 hash of the sorted, newline-joined paths.
- */
-function computeStructureHash(filePaths) {
-    const sorted = [...filePaths].sort();
-    const content = sorted.join('\n');
-    return createHash('sha256').update(content).digest('hex');
-}
-
-/**
- * Parse subprocess outputs for each synthesis step.
- *
- * - Architect: returns text \> _builder
- * - Builder: returns JSON \> _content + structured fields
- * - Critic: returns text \> _feedback
- *
- * @module orchestrator/parseOutput
- */
-/**
- * Parse architect output. The architect returns a task brief as text.
- *
- * @param output - Raw subprocess output.
- * @returns The task brief string.
- */
-function parseArchitectOutput(output) {
-    return output.trim();
-}
-/**
- * Parse builder output. The builder returns JSON with _content and optional fields.
- *
- * Attempts JSON parse first. If that fails, treats the entire output as _content.
- *
- * @param output - Raw subprocess output.
- * @returns Parsed builder output with content and structured fields.
- */
-function parseBuilderOutput(output) {
-    const trimmed = output.trim();
-    // Strategy 1: Try to parse the entire output as JSON directly
-    const direct = tryParseJson(trimmed);
-    if (direct)
-        return direct;
-    // Strategy 2: Try all fenced code blocks (last match first — models often narrate then output)
-    const fencePattern = /```(?:json)?\s*([\s\S]*?)```/g;
-    const fenceMatches = [];
-    let match;
-    while ((match = fencePattern.exec(trimmed)) !== null) {
-        fenceMatches.push(match[1].trim());
-    }
-    // Try last fence first (most likely to be the actual output)
-    for (let i = fenceMatches.length - 1; i >= 0; i--) {
-        const result = tryParseJson(fenceMatches[i]);
-        if (result)
-            return result;
-    }
-    // Strategy 3: Find outermost { ... } braces
-    const firstBrace = trimmed.indexOf('{');
-    const lastBrace = trimmed.lastIndexOf('}');
-    if (firstBrace !== -1 && lastBrace > firstBrace) {
-        const result = tryParseJson(trimmed.substring(firstBrace, lastBrace + 1));
-        if (result)
-            return result;
-    }
-    // Fallback: treat entire output as content
-    return { content: trimmed, fields: {} };
-}
-/** Try to parse a string as JSON and extract builder output fields. */
-function tryParseJson(str) {
-    try {
-        const raw = JSON.parse(str);
-        if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
-            return null;
-        }
-        const parsed = raw;
-        // Extract _content
-        const content = typeof parsed['_content'] === 'string'
-            ? parsed['_content']
-            : typeof parsed['content'] === 'string'
-                ? parsed['content']
-                : null;
-        if (content === null)
-            return null;
-        // Extract _state (the ONLY underscore key the builder is allowed to set)
-        const state = '_state' in parsed ? parsed['_state'] : undefined;
-        // Extract non-underscore fields
-        const fields = {};
-        for (const [key, value] of Object.entries(parsed)) {
-            if (!key.startsWith('_') && key !== 'content') {
-                fields[key] = value;
-            }
-        }
-        return { content, fields, ...(state !== undefined ? { state } : {}) };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Parse critic output. The critic returns evaluation text.
- *
- * @param output - Raw subprocess output.
- * @returns The feedback string.
- */
-function parseCriticOutput(output) {
-    return output.trim();
-}
-
 /**
  * Pure phase-state transition functions.
  *
@@ -10383,7 +10191,42 @@ function enforceInvariant(state) {
             // running in non-first position would be a bug, but don't mask it
         }
     }
-    return result;
+    return result;
+}
+// ── Invalidation cascades ──────────────────────────────────────────────
+/**
+ * Architect invalidated: architect → pending; builder, critic → stale.
+ * Triggers: _structureHash change, _steer change, _architect change,
+ * _crossRefs declaration change, _synthesisCount \>= architectEvery.
+ */
+function invalidateArchitect(state) {
+    return enforceInvariant({
+        architect: state.architect === 'failed' ? 'failed' : 'pending',
+        builder: state.builder === 'fresh' ? 'stale' : state.builder,
+        critic: state.critic === 'fresh' ? 'stale' : state.critic,
+    });
+}
+/**
+ * Builder invalidated (scope mtime or cross-ref _content change):
+ * builder → pending; critic → stale.
+ * Only applies when architect is fresh; otherwise, builder stays stale.
+ */
+function invalidateBuilder(state) {
+    if (state.architect !== 'fresh') {
+        // Architect is not fresh — builder stays stale (or whatever it is)
+        return enforceInvariant({
+            ...state,
+            builder: state.builder === 'fresh' || state.builder === 'stale'
+                ? 'stale'
+                : state.builder,
+            critic: state.critic === 'fresh' ? 'stale' : state.critic,
+        });
+    }
+    return enforceInvariant({
+        ...state,
+        builder: state.builder === 'failed' ? 'failed' : 'pending',
+        critic: state.critic === 'fresh' ? 'stale' : state.critic,
+    });
 }
 // ── Phase success transitions ──────────────────────────────────────────
 /**
@@ -10553,7 +10396,9 @@ function derivePhaseState(meta, inputs) {
     }
     // Check architect invalidation (when inputs are provided)
     if (inputs) {
-        const architectInvalidated = inputs.structureChanged ||
+        // Progressive metas: structure changes invalidate builder, not architect
+        const structureInvalidatesArchitect = inputs.structureChanged && meta._state === undefined;
+        const architectInvalidated = structureInvalidatesArchitect ||
             inputs.steerChanged ||
             inputs.architectChanged ||
             inputs.crossRefsChanged ||
@@ -10565,6 +10410,14 @@ function derivePhaseState(meta, inputs) {
                 critic: 'stale',
             };
         }
+        // Progressive meta with structure change: builder-only invalidation
+        if (inputs.structureChanged && meta._state !== undefined) {
+            return {
+                architect: 'fresh',
+                builder: 'pending',
+                critic: 'stale',
+            };
+        }
     }
     // Has _builder but no _content: builder is pending
     if (meta._builder && !meta._content) {
@@ -10586,6 +10439,154 @@ function derivePhaseState(meta, inputs) {
     return freshPhaseState();
 }
 
+/**
+ * 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');
+}
+
+/**
+ * Per-tick invalidation pass.
+ *
+ * Computes architect-invalidating and builder-invalidating inputs for a meta,
+ * then applies the cascade to update _phaseState.
+ *
+ * @module phaseState/invalidate
+ */
+/**
+ * Compute invalidation inputs and apply cascade for a single meta.
+ *
+ * @param meta - Current meta.json content with existing _phaseState.
+ * @param scopeFiles - Sorted file list from scope.
+ * @param config - MetaConfig for architectEvery.
+ * @param node - MetaNode for archive access.
+ * @param crossRefMetas - Map of cross-ref owner paths to their current _content.
+ * @param archiveCrossRefContent - Map of cross-ref owner paths to their archived _content.
+ * @returns Updated phase state and invalidation details.
+ */
+async function computeInvalidation(meta, scopeFiles, config, node, crossRefMetas, archiveCrossRefContent) {
+    let phaseState = meta._phaseState ?? {
+        architect: 'fresh',
+        builder: 'fresh',
+        critic: 'fresh',
+    };
+    // ── Architect-level inputs ──
+    const structureHash = computeStructureHash(scopeFiles);
+    const structureChanged = structureHash !== meta._structureHash;
+    const latestArchive = await readLatestArchive(node.metaPath);
+    const steerChanged = hasSteerChanged(meta._steer, latestArchive?._steer, Boolean(latestArchive));
+    // _architect change: compare current vs. archive
+    const architectChanged = latestArchive
+        ? (meta._architect ?? '') !== (latestArchive._architect ?? '')
+        : Boolean(meta._architect);
+    // _crossRefs declaration change
+    const currentRefs = (meta._crossRefs ?? []).slice().sort().join(',');
+    const archiveRefs = (latestArchive?._crossRefs ?? [])
+        .slice()
+        .sort()
+        .join(',');
+    const crossRefsDeclChanged = latestArchive
+        ? currentRefs !== archiveRefs
+        : currentRefs.length > 0;
+    const architectInvalidators = [];
+    if (structureChanged) {
+        if (meta._state !== undefined) {
+            // Progressive entity: new files → builder only (cursor handles incremental)
+            phaseState = invalidateBuilder(phaseState);
+        }
+        else {
+            architectInvalidators.push('structureHash');
+        }
+    }
+    if (steerChanged)
+        architectInvalidators.push('steer');
+    if (architectChanged)
+        architectInvalidators.push('_architect');
+    if (crossRefsDeclChanged)
+        architectInvalidators.push('_crossRefs');
+    if ((meta._synthesisCount ?? 0) >= config.architectEvery) {
+        architectInvalidators.push('architectEvery');
+    }
+    // First-run check: no _builder means architect must run
+    const firstRun = !meta._builder;
+    if (architectInvalidators.length > 0 || firstRun) {
+        phaseState = invalidateArchitect(phaseState);
+    }
+    // ── Builder-level inputs ──
+    // Scope file mtime check — if any file newer than _generatedAt
+    const scopeMtimeMax = null;
+    // Note: actual mtime check is done by the caller or via isStale;
+    // here we just detect cross-ref content changes for the cascade.
+    // Cross-ref _content change (builder-invalidating)
+    let crossRefContentChanged = false;
+    return {
+        phaseState,
+        architectInvalidators,
+        stalenessInputs: {
+            structureHash,
+            steerChanged,
+            architectChanged,
+            crossRefsDeclChanged,
+            scopeMtimeMax,
+            crossRefContentChanged,
+        },
+        structureHash,
+        steerChanged,
+    };
+}
+
+/**
+ * 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),
+        };
+    });
+}
+
 /**
  * Corpus-wide phase scheduler.
  *
@@ -10598,18 +10599,30 @@ function derivePhaseState(meta, inputs) {
 /**
  * Build phase candidates from listMetas entries.
  *
- * Derives phase state and auto-retries failed phases for each entry.
+ * Derives phase state, auto-retries failed phases, and applies Tier 1
+ * cheap-invalidation (no I/O) for metas with persisted _phaseState.
  * Used by orchestratePhase, queue route, and status route.
  */
-function buildPhaseCandidates(entries) {
-    return entries.map((entry) => ({
-        node: entry.node,
-        meta: entry.meta,
-        phaseState: retryAllFailed(derivePhaseState(entry.meta)),
-        actualStaleness: entry.stalenessSeconds,
-        locked: entry.locked,
-        disabled: entry.disabled,
-    }));
+function buildPhaseCandidates(entries, architectEvery) {
+    return entries.map((entry) => {
+        let ps = retryAllFailed(derivePhaseState(entry.meta));
+        // Tier 1 cheap invalidation for metas with persisted _phaseState
+        if (entry.meta._phaseState) {
+            const needsArchitect = !entry.meta._builder ||
+                (entry.meta._synthesisCount ?? 0) >= architectEvery;
+            if (needsArchitect && ps.architect === 'fresh') {
+                ps = { architect: 'pending', builder: 'stale', critic: 'stale' };
+            }
+        }
+        return {
+            node: entry.node,
+            meta: entry.meta,
+            phaseState: ps,
+            actualStaleness: entry.stalenessSeconds,
+            locked: entry.locked,
+            disabled: entry.disabled,
+        };
+    });
 }
 /**
  * Rank all eligible phase candidates by priority.
@@ -10672,6 +10685,124 @@ function selectPhaseCandidate(metas, depthWeight) {
     return rankPhaseCandidates(metas, depthWeight)[0] ?? null;
 }
 
+/**
+ * Shared error utilities.
+ *
+ * @module errors
+ */
+/**
+ * Wrap an unknown caught value into a MetaError.
+ *
+ * @param step - Which synthesis step failed.
+ * @param err - The caught error value.
+ * @param code - Error classification code.
+ * @returns A structured MetaError.
+ */
+function toMetaError(step, err, code = 'FAILED') {
+    return {
+        step,
+        code,
+        message: err instanceof Error ? err.message : String(err),
+    };
+}
+
+/**
+ * Parse subprocess outputs for each synthesis step.
+ *
+ * - Architect: returns text \> _builder
+ * - Builder: returns JSON \> _content + structured fields
+ * - Critic: returns text \> _feedback
+ *
+ * @module orchestrator/parseOutput
+ */
+/**
+ * Parse architect output. The architect returns a task brief as text.
+ *
+ * @param output - Raw subprocess output.
+ * @returns The task brief string.
+ */
+function parseArchitectOutput(output) {
+    return output.trim();
+}
+/**
+ * Parse builder output. The builder returns JSON with _content and optional fields.
+ *
+ * Attempts JSON parse first. If that fails, treats the entire output as _content.
+ *
+ * @param output - Raw subprocess output.
+ * @returns Parsed builder output with content and structured fields.
+ */
+function parseBuilderOutput(output) {
+    const trimmed = output.trim();
+    // Strategy 1: Try to parse the entire output as JSON directly
+    const direct = tryParseJson(trimmed);
+    if (direct)
+        return direct;
+    // Strategy 2: Try all fenced code blocks (last match first — models often narrate then output)
+    const fencePattern = /```(?:json)?\s*([\s\S]*?)```/g;
+    const fenceMatches = [];
+    let match;
+    while ((match = fencePattern.exec(trimmed)) !== null) {
+        fenceMatches.push(match[1].trim());
+    }
+    // Try last fence first (most likely to be the actual output)
+    for (let i = fenceMatches.length - 1; i >= 0; i--) {
+        const result = tryParseJson(fenceMatches[i]);
+        if (result)
+            return result;
+    }
+    // Strategy 3: Find outermost { ... } braces
+    const firstBrace = trimmed.indexOf('{');
+    const lastBrace = trimmed.lastIndexOf('}');
+    if (firstBrace !== -1 && lastBrace > firstBrace) {
+        const result = tryParseJson(trimmed.substring(firstBrace, lastBrace + 1));
+        if (result)
+            return result;
+    }
+    // Fallback: treat entire output as content
+    return { content: trimmed, fields: {} };
+}
+/** Try to parse a string as JSON and extract builder output fields. */
+function tryParseJson(str) {
+    try {
+        const raw = JSON.parse(str);
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+            return null;
+        }
+        const parsed = raw;
+        // Extract _content
+        const content = typeof parsed['_content'] === 'string'
+            ? parsed['_content']
+            : typeof parsed['content'] === 'string'
+                ? parsed['content']
+                : null;
+        if (content === null)
+            return null;
+        // Extract _state (the ONLY underscore key the builder is allowed to set)
+        const state = '_state' in parsed ? parsed['_state'] : undefined;
+        // Extract non-underscore fields
+        const fields = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (!key.startsWith('_') && key !== 'content') {
+                fields[key] = value;
+            }
+        }
+        return { content, fields, ...(state !== undefined ? { state } : {}) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse critic output. The critic returns evaluation text.
+ *
+ * @param output - Raw subprocess output.
+ * @returns The feedback string.
+ */
+function parseCriticOutput(output) {
+    return output.trim();
+}
+
 /**
  * Per-phase executors for the phase-state machine.
  *
@@ -10930,7 +11061,7 @@ async function orchestratePhase(config, executor, watcher, targetPath, onProgres
     if (metaResult.entries.length === 0)
         return { executed: false };
     // Build candidates with phase state (including invalidation + auto-retry)
-    const candidates = buildPhaseCandidates(metaResult.entries);
+    const candidates = buildPhaseCandidates(metaResult.entries, config.architectEvery);
     // Select best phase candidate
     const winner = selectPhaseCandidate(candidates, config.depthWeight);
     if (!winner) {
@@ -11605,46 +11736,6 @@ function buildMetaRules(config) {
             },
             renderAs: 'md',
         },
-        {
-            name: 'meta-config',
-            description: 'jeeves-meta configuration file',
-            match: {
-                properties: {
-                    file: {
-                        properties: {
-                            path: {
-                                type: 'string',
-                                glob: '**/jeeves-meta{.config.json,/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',
-        },
     ];
 }
 /**
@@ -11888,13 +11979,15 @@ class Scheduler {
     queue;
     logger;
     watcher;
+    cache;
     registrar = null;
     currentExpression;
-    constructor(config, queue, logger, watcher) {
+    constructor(config, queue, logger, watcher, cache) {
         this.config = config;
         this.queue = queue;
         this.logger = logger;
         this.watcher = watcher;
+        this.cache = cache;
         this.currentExpression = config.schedule;
     }
     /** Set the rule registrar for watcher restart detection. */
@@ -12011,8 +12104,8 @@ class Scheduler {
      */
     async discoverNextPhase() {
         try {
-            const result = await listMetas(this.config, this.watcher);
-            const candidates = buildPhaseCandidates(result.entries);
+            const result = await this.cache.get(this.config, this.watcher);
+            const candidates = buildPhaseCandidates(result.entries, this.config.architectEvery);
             const winner = selectPhaseCandidate(candidates, this.config.depthWeight);
             if (!winner)
                 return null;
@@ -12437,11 +12530,11 @@ function registerMetasUpdateRoute(app, deps) {
  */
 function registerPreviewRoute(app, deps) {
     app.get('/preview', async (request, reply) => {
-        const { config, watcher } = deps;
+        const { config, watcher, cache } = deps;
         const query = request.query;
         let result;
         try {
-            result = await listMetas(config, watcher);
+            result = await cache.get(config, watcher);
         }
         catch {
             return reply.status(503).send({
@@ -12461,40 +12554,24 @@ function registerPreviewRoute(app, deps) {
             }
         }
         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) {
+            // Select best phase candidate
+            const candidates = buildPhaseCandidates(result.entries, config.architectEvery);
+            const winner = selectPhaseCandidate(candidates, config.depthWeight);
+            if (!winner) {
                 return { message: 'No stale metas found. Nothing to synthesize.' };
             }
-            targetNode = findNode(result.tree, stalestPath);
+            targetNode = findNode(result.tree, winner.node.metaPath);
         }
         const meta = await readMetaJson(targetNode.metaPath);
         // Scope files
         const { scopeFiles } = await getScopeFiles(targetNode, watcher);
-        const structureHash = computeStructureHash(scopeFiles);
+        // Compute invalidation inputs (DRY: reuse phaseState/invalidate logic)
+        const invalidation = await computeInvalidation(meta, scopeFiles, config, targetNode);
+        const { architectInvalidators, stalenessInputs } = invalidation;
+        const { structureHash } = invalidation;
         const structureChanged = structureHash !== meta._structureHash;
-        const latestArchive = await readLatestArchive(targetNode.metaPath);
-        const steerChanged = hasSteerChanged(meta._steer, latestArchive?._steer, Boolean(latestArchive));
-        // _architect change detection
-        const architectChanged = latestArchive
-            ? (meta._architect ?? '') !== (latestArchive._architect ?? '')
-            : Boolean(meta._architect);
-        // _crossRefs declaration change detection
-        const currentRefs = (meta._crossRefs ?? []).slice().sort().join(',');
-        const archiveRefs = (latestArchive?._crossRefs ?? [])
-            .slice()
-            .sort()
-            .join(',');
-        const crossRefsDeclChanged = latestArchive
-            ? currentRefs !== archiveRefs
-            : currentRefs.length > 0;
+        const { steerChanged } = invalidation;
+        const { architectChanged, crossRefsDeclChanged } = stalenessInputs;
         const architectTriggered = isArchitectTriggered(meta, structureChanged, steerChanged, config.architectEvery);
         // Delta files
         const deltaFiles = getDeltaFiles(meta._generatedAt, scopeFiles);
@@ -12519,30 +12596,6 @@ function registerPreviewRoute(app, deps) {
         });
         const owedPhase = getOwedPhase(phaseState);
         const priorityBand = getPriorityBand(phaseState);
-        // Architect invalidators
-        const architectInvalidators = [];
-        if (owedPhase === 'architect') {
-            if (structureChanged)
-                architectInvalidators.push('structureHash');
-            if (steerChanged)
-                architectInvalidators.push('steer');
-            if (architectChanged)
-                architectInvalidators.push('_architect');
-            if (crossRefsDeclChanged)
-                architectInvalidators.push('_crossRefs');
-            if ((meta._synthesisCount ?? 0) >= config.architectEvery) {
-                architectInvalidators.push('architectEvery');
-            }
-        }
-        // Staleness inputs
-        const stalenessInputs = {
-            structureHash,
-            steerChanged,
-            architectChanged,
-            crossRefsDeclChanged,
-            scopeMtimeMax: null,
-            crossRefContentChanged: false,
-        };
         return {
             path: targetNode.metaPath,
             staleness: {
@@ -12616,8 +12669,8 @@ function registerQueueRoutes(app, deps) {
         // ranked by scheduler priority (computed on read, not persisted)
         let automatic = [];
         try {
-            const metaResult = await listMetas(deps.config, deps.watcher);
-            const candidates = buildPhaseCandidates(metaResult.entries);
+            const metaResult = await deps.cache.get(deps.config, deps.watcher);
+            const candidates = buildPhaseCandidates(metaResult.entries, deps.config.architectEvery);
             const ranked = rankPhaseCandidates(candidates, deps.config.depthWeight);
             automatic = ranked.map((c) => ({
                 path: c.node.metaPath,
@@ -12840,7 +12893,7 @@ function registerStatusRoute(app, deps) {
         name: SERVICE_NAME,
         version: SERVICE_VERSION,
         getHealth: async () => {
-            const { config, queue, scheduler, stats, watcher } = deps;
+            const { config, queue, scheduler, stats, watcher, cache } = deps;
             // On-demand dependency checks
             const [watcherHealth, gatewayHealth] = await Promise.all([
                 checkWatcher(config.watcherUrl),
@@ -12854,7 +12907,7 @@ function registerStatusRoute(app, deps) {
             };
             let nextPhase = null;
             try {
-                const metaResult = await listMetas(config, watcher);
+                const metaResult = await cache.get(config, watcher);
                 // Count raw phase states (before retry) for display
                 for (const entry of metaResult.entries) {
                     const ps = derivePhaseState(entry.meta);
@@ -12863,7 +12916,7 @@ function registerStatusRoute(app, deps) {
                     }
                 }
                 // Build candidates (with auto-retry) for scheduling
-                const candidates = buildPhaseCandidates(metaResult.entries);
+                const candidates = buildPhaseCandidates(metaResult.entries, config.architectEvery);
                 // Find next phase candidate
                 const winner = selectPhaseCandidate(candidates, config.depthWeight);
                 if (winner) {
@@ -12926,7 +12979,7 @@ const synthesizeBodySchema = z.object({
 function registerSynthesizeRoute(app, deps) {
     app.post('/synthesize', async (request, reply) => {
         const body = synthesizeBodySchema.parse(request.body);
-        const { config, watcher, queue } = deps;
+        const { config, watcher, queue, cache } = deps;
         if (body.path) {
             // Path-targeted trigger: create override entry
             const targetPath = resolveMetaDir(body.path);
@@ -12963,7 +13016,7 @@ function registerSynthesizeRoute(app, deps) {
         // Corpus-wide trigger: discover stalest candidate
         let result;
         try {
-            result = await listMetas(config, watcher);
+            result = await cache.get(config, watcher);
         }
         catch {
             return reply.status(503).send({
@@ -12971,20 +13024,15 @@ function registerSynthesizeRoute(app, deps) {
                 message: 'Watcher unreachable — cannot discover candidates',
             });
         }
-        const stale = result.entries
-            .filter((e) => e.stalenessSeconds > 0 && !e.disabled)
-            .map((e) => ({
-            node: e.node,
-            meta: e.meta,
-            actualStaleness: e.stalenessSeconds,
-        }));
-        const stalest = discoverStalestPath(stale, config.depthWeight);
-        if (!stalest) {
+        const candidates = buildPhaseCandidates(result.entries, config.architectEvery);
+        const winner = selectPhaseCandidate(candidates, config.depthWeight);
+        if (!winner) {
             return reply.code(200).send({
                 status: 'skipped',
                 message: 'No stale metas found. Nothing to synthesize.',
             });
         }
+        const stalest = winner.node.metaPath;
         const enqueueResult = queue.enqueue(stalest);
         return reply.code(202).send({
             status: 'accepted',
@@ -13085,6 +13133,18 @@ function createServer(options) {
     // Fastify 5 requires `loggerInstance` for external pino loggers
     const app = Fastify({
         loggerInstance: options.logger,
+        requestTimeout: 30_000,
+    });
+    // Readiness gate: return 503 while service is initializing
+    app.addHook('onRequest', async (request, reply) => {
+        if (options.deps.ready)
+            return;
+        const url = request.url;
+        if (url === '/config' || url.startsWith('/config/apply'))
+            return;
+        return reply
+            .status(503)
+            .send({ status: 'starting', message: 'Service initializing' });
     });
     registerRoutes(app, options.deps);
     return app;
@@ -13260,8 +13320,9 @@ async function startService(config, configPath) {
         lastCycleAt: null,
     };
     const queue = new SynthesisQueue(logger);
+    const cache = new MetaCache();
     // Scheduler (needs watcher for discovery)
-    const scheduler = new Scheduler(config, queue, logger, watcher);
+    const scheduler = new Scheduler(config, queue, logger, watcher, cache);
     const routeDeps = {
         config,
         logger,
@@ -13269,6 +13330,8 @@ async function startService(config, configPath) {
         watcher,
         scheduler,
         stats,
+        cache,
+        ready: false,
         executor,
         configPath,
     };
@@ -13319,6 +13382,9 @@ async function startService(config, configPath) {
                 }
                 await progress.report(evt);
             }, logger);
+            // Invalidate cache only when a phase was actually executed
+            if (result.executed)
+                cache.invalidate();
             const durationMs = Date.now() - startMs;
             if (!result.executed) {
                 logger.debug({ path: ownerPath }, 'Phase skipped (fully fresh or locked)');
@@ -13382,9 +13448,13 @@ async function startService(config, configPath) {
     scheduler.setRegistrar(registrar);
     routeDeps.registrar = registrar;
     void registrar.register().then(() => {
+        routeDeps.ready = true;
         if (registrar.isRegistered) {
             void verifyRuleApplication(watcher, logger);
         }
+    }, () => {
+        // Registration failed after max retries — mark ready anyway
+        routeDeps.ready = true;
     });
     // Periodic watcher health check (independent of scheduler)
     const healthCheck = new WatcherHealthCheck({