@karmaniverous/jeeves-meta 0.15.3 → 0.15.5

package/dist/index.js

@@ -1,6 +1,7 @@
-import fs, { readdirSync, readFileSync, existsSync, writeFileSync, renameSync, unlinkSync, mkdirSync, copyFileSync, statSync, watchFile } from 'node:fs';
+import fs, { readdirSync, readFileSync, existsSync, writeFileSync, renameSync, unlinkSync, statSync, mkdirSync, copyFileSync, watchFile } from 'node:fs';
 import path, { join, dirname, resolve, basename, relative, posix } from 'node:path';
 import { unlink, readFile, mkdir, writeFile, copyFile } from 'node:fs/promises';
+import { z } from 'zod';
 import { fileURLToPath } from 'node:url';
 import process$1 from 'node:process';
 import { randomUUID, createHash } from 'node:crypto';
@@ -12,7 +13,6 @@ import require$$4 from 'util';
 import require$$5 from 'assert';
 import require$$2 from 'events';
 import vm from 'vm';
-import { z } from 'zod';
 import * as commander from 'commander';
 import 'node:child_process';
 import { tmpdir } from 'node:os';
@@ -67,6 +67,72 @@ async function pruneArchive(metaPath, maxArchive) {
     return toRemove;
 }
 
+/**
+ * Shared component descriptor constants for jeeves-meta.
+ *
+ * Single source of truth consumed by both the service descriptor and
+ * the OpenClaw plugin registration.
+ */
+/** Shared jeeves-meta component descriptor constants. */
+const META_COMPONENT = {
+    name: 'meta',
+    servicePackage: '@karmaniverous/jeeves-meta',
+    pluginPackage: '@karmaniverous/jeeves-meta-openclaw',
+    defaultPort: 1938};
+
+/**
+ * Structured error schema from a synthesis step failure.
+ *
+ */
+/** 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 the core (library-compatible) meta configuration. */
+/** 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' }),
+});
+
 /**
  * Normalize file paths to forward slashes for consistency with watcher-indexed paths.
  *
@@ -74,7 +140,6 @@ async function pruneArchive(metaPath, maxArchive) {
  * 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.
@@ -85,6 +150,22 @@ async function pruneArchive(metaPath, maxArchive) {
 function normalizePath(p) {
     return p.replaceAll('\\', '/');
 }
+/** 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,
+});
 
 /**
  * Archive reading helpers — watcher scan with filesystem fallback.
@@ -322,7 +403,7 @@ function packageDirectorySync({cwd, ignoreTypeOnlyPackageJson} = {}) {
  * @module constants
  */
 /** Default HTTP port for the jeeves-meta service. */
-const DEFAULT_PORT = 1938;
+const DEFAULT_PORT = META_COMPONENT.defaultPort;
 /** Default port as a string (for Commander CLI defaults). */
 const DEFAULT_PORT_STR = String(DEFAULT_PORT);
 /** Service name identifier. */
@@ -1503,11 +1584,11 @@ var hasRequiredRetry$1;
 function requireRetry$1 () {
 	if (hasRequiredRetry$1) return retry$1;
 	hasRequiredRetry$1 = 1;
-	(function (exports$1) {
+	(function (exports) {
 		var RetryOperation = requireRetry_operation();
 
-		exports$1.operation = function(options) {
-		  var timeouts = exports$1.timeouts(options);
+		exports.operation = function(options) {
+		  var timeouts = exports.timeouts(options);
 		  return new RetryOperation(timeouts, {
 		      forever: options && options.forever,
 		      unref: options && options.unref,
@@ -1515,7 +1596,7 @@ function requireRetry$1 () {
 		  });
 		};
 
-		exports$1.timeouts = function(options) {
+		exports.timeouts = function(options) {
 		  if (options instanceof Array) {
 		    return [].concat(options);
 		  }
@@ -1552,7 +1633,7 @@ function requireRetry$1 () {
 		  return timeouts;
 		};
 
-		exports$1.createTimeout = function(attempt, opts) {
+		exports.createTimeout = function(attempt, opts) {
 		  var random = (opts.randomize)
 		    ? (Math.random() + 1)
 		    : 1;
@@ -1563,7 +1644,7 @@ function requireRetry$1 () {
 		  return timeout;
 		};
 
-		exports$1.wrap = function(obj, options, methods) {
+		exports.wrap = function(obj, options, methods) {
 		  if (options instanceof Array) {
 		    methods = options;
 		    options = null;
@@ -1583,7 +1664,7 @@ function requireRetry$1 () {
 		    var original = obj[method];
 
 		    obj[method] = function retryWrapper(original) {
-		      var op       = exports$1.operation(options);
+		      var op       = exports.operation(options);
 		      var args     = Array.prototype.slice.call(arguments, 1);
 		      var callback = args.pop();
 
@@ -4592,7 +4673,7 @@ var hasRequiredRe;
 function requireRe () {
 	if (hasRequiredRe) return re.exports;
 	hasRequiredRe = 1;
-	(function (module, exports$1) {
+	(function (module, exports) {
 
 		const {
 		  MAX_SAFE_COMPONENT_LENGTH,
@@ -4600,14 +4681,14 @@ function requireRe () {
 		  MAX_LENGTH,
 		} = requireConstants();
 		const debug = requireDebug();
-		exports$1 = module.exports = {};
+		exports = module.exports = {};
 
 		// The actual regexps go on exports.re
-		const re = exports$1.re = [];
-		const safeRe = exports$1.safeRe = [];
-		const src = exports$1.src = [];
-		const safeSrc = exports$1.safeSrc = [];
-		const t = exports$1.t = {};
+		const re = exports.re = [];
+		const safeRe = exports.safeRe = [];
+		const src = exports.src = [];
+		const safeSrc = exports.safeSrc = [];
+		const t = exports.t = {};
 		let R = 0;
 
 		const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
@@ -4730,7 +4811,7 @@ function requireRe () {
 		createToken('GTLT', '((?:<|>)?=?)');
 
 		// Something like "2.*" or "1.2.x".
-		// Note that "x.x" is a valid xRange identifer, meaning "any version"
+		// Note that "x.x" is a valid xRange identifier, meaning "any version"
 		// Only the first item is strictly required.
 		createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
 		createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
@@ -4771,7 +4852,7 @@ function requireRe () {
 		createToken('LONETILDE', '(?:~>?)');
 
 		createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
-		exports$1.tildeTrimReplace = '$1~';
+		exports.tildeTrimReplace = '$1~';
 
 		createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
 		createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
@@ -4781,7 +4862,7 @@ function requireRe () {
 		createToken('LONECARET', '(?:\\^)');
 
 		createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
-		exports$1.caretTrimReplace = '$1^';
+		exports.caretTrimReplace = '$1^';
 
 		createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
 		createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
@@ -4794,7 +4875,7 @@ function requireRe () {
 		// it modifies, so that `> 1.2.3` ==> `>1.2.3`
 		createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
 		}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
-		exports$1.comparatorTrimReplace = '$1$2$3';
+		exports.comparatorTrimReplace = '$1$2$3';
 
 		// Something like `1.2.3 - 1.2.4`
 		// Note that these all use the loose form, because they'll be
@@ -5726,6 +5807,62 @@ function requireCoerce () {
 	return coerce_1;
 }
 
+var truncate_1;
+var hasRequiredTruncate;
+
+function requireTruncate () {
+	if (hasRequiredTruncate) return truncate_1;
+	hasRequiredTruncate = 1;
+
+	const parse = requireParse();
+	const constants = requireConstants();
+	const SemVer = requireSemver$1();
+
+	const truncate = (version, truncation, options) => {
+	  if (!constants.RELEASE_TYPES.includes(truncation)) {
+	    return null
+	  }
+
+	  const clonedVersion = cloneInputVersion(version, options);
+	  return clonedVersion && doTruncation(clonedVersion, truncation)
+	};
+
+	const cloneInputVersion = (version, options) => {
+	  const versionStringToParse = (
+	    version instanceof SemVer ? version.version : version
+	  );
+
+	  return parse(versionStringToParse, options)
+	};
+
+	const doTruncation = (version, truncation) => {
+	  if (isPrerelease(truncation)) {
+	    return version.version
+	  }
+
+	  version.prerelease = [];
+
+	  switch (truncation) {
+	    case 'major':
+	      version.minor = 0;
+	      version.patch = 0;
+	      break
+	    case 'minor':
+	      version.patch = 0;
+	      break
+	  }
+
+	  return version.format()
+	};
+
+	const isPrerelease = (type) => {
+	  return type.startsWith('pre')
+	};
+
+	truncate_1 = truncate;
+	return truncate_1;
+}
+
 var lrucache;
 var hasRequiredLrucache;
 
@@ -7175,6 +7312,7 @@ function requireSemver () {
 	const lte = requireLte();
 	const cmp = requireCmp();
 	const coerce = requireCoerce();
+	const truncate = requireTruncate();
 	const Comparator = requireComparator();
 	const Range = requireRange();
 	const satisfies = requireSatisfies();
@@ -7213,6 +7351,7 @@ function requireSemver () {
 	  lte,
 	  cmp,
 	  coerce,
+	  truncate,
 	  Comparator,
 	  Range,
 	  satisfies,
@@ -7510,31 +7649,31 @@ var hasRequiredExtraTypings;
 function requireExtraTypings () {
 	if (hasRequiredExtraTypings) return extraTypings.exports;
 	hasRequiredExtraTypings = 1;
-	(function (module, exports$1) {
+	(function (module, exports) {
 		const commander = require$$0;
 
-		exports$1 = module.exports = {};
+		exports = module.exports = {};
 
 		// Return a different global program than commander,
 		// and don't also return it as default export.
-		exports$1.program = new commander.Command();
+		exports.program = new commander.Command();
 
 		/**
 		 * Expose classes. The FooT versions are just types, so return Commander original implementations!
 		 */
 
-		exports$1.Argument = commander.Argument;
-		exports$1.Command = commander.Command;
-		exports$1.CommanderError = commander.CommanderError;
-		exports$1.Help = commander.Help;
-		exports$1.InvalidArgumentError = commander.InvalidArgumentError;
-		exports$1.InvalidOptionArgumentError = commander.InvalidArgumentError; // Deprecated
-		exports$1.Option = commander.Option;
+		exports.Argument = commander.Argument;
+		exports.Command = commander.Command;
+		exports.CommanderError = commander.CommanderError;
+		exports.Help = commander.Help;
+		exports.InvalidArgumentError = commander.InvalidArgumentError;
+		exports.InvalidOptionArgumentError = commander.InvalidArgumentError; // Deprecated
+		exports.Option = commander.Option;
 
-		exports$1.createCommand = (name) => new commander.Command(name);
-		exports$1.createOption = (flags, description) =>
+		exports.createCommand = (name) => new commander.Command(name);
+		exports.createOption = (flags, description) =>
 		  new commander.Option(flags, description);
-		exports$1.createArgument = (name, description) =>
+		exports.createArgument = (name, description) =>
 		  new commander.Argument(name, description); 
 	} (extraTypings, extraTypings.exports));
 	return extraTypings.exports;
@@ -8116,508 +8255,247 @@ function registerCustomCliCommands(program) {
 }
 
 /**
- * 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');
+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;
         }
     }
-    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') {
+    return {
+        total: entries.length,
+        stale: staleCount,
+        errors: errorCount,
+        locked: lockedCount,
+        disabled: disabledCount,
+        neverSynthesized: neverSynthesizedCount,
+        tokens: {
+            architect: totalArchitectTokens,
+            builder: totalBuilderTokens,
+            critic: totalCriticTokens,
+        },
+        stalestPath,
+        lastSynthesizedPath,
+        lastSynthesizedAt,
+    };
+}
+
+/**
+ * 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.
+ *
+ * Uses the watcher's `/walk` endpoint to find all `.meta/meta.json` files
+ * and returns deduplicated meta directory paths.
+ *
+ * @param watcher - WatcherClient for walk queries.
+ * @returns Array of normalized .meta/ directory paths.
+ */
+async function discoverMetas(watcher) {
+    const allPaths = await watcher.walk(['**/.meta/meta.json']);
+    // Deduplicate by .meta/ directory path (handles multi-chunk files)
+    const seen = new Set();
+    const metaPaths = [];
+    for (const filePath of allPaths) {
+        const fp = normalizePath(filePath);
+        // Derive .meta/ directory from file_path (strip /meta.json)
+        const metaPath = fp.replace(/\/meta\.json$/, '');
+        if (seen.has(metaPath))
             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');
-        }
+        seen.add(metaPath);
+        metaPaths.push(metaPath);
     }
+    return metaPaths;
 }
 
 /**
- * Zod schema for jeeves-meta service configuration.
+ * File-system lock for preventing concurrent synthesis on the same meta.
  *
- * The service config is a strict superset of the core (library-compatible) meta config.
+ * Lock file: .meta/.lock containing `_lockPid` + `_lockStartedAt` (underscore-prefixed
+ * reserved keys, consistent with meta.json conventions).
+ * Stale timeout: 30 minutes.
  *
- * @module schema/config
+ * @module lock
  */
-/** 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([]),
-});
-
+const LOCK_FILE = '.lock';
 /**
- * Load and resolve jeeves-meta service config.
+ * Resolve a path to a .meta directory.
  *
- * Supports \@file: indirection and environment-variable substitution (dollar-brace pattern).
+ * If the path already ends with '.meta', returns it as-is.
+ * Otherwise, appends '.meta' as a subdirectory.
  *
- * @module configLoader
+ * @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
 /**
- * Deep-walk a value, replacing `\${VAR\}` patterns with process.env values.
+ * Read and classify the state of a .meta/.lock file.
  *
- * @param value - Arbitrary JSON-compatible value.
- * @returns Value with env-var placeholders resolved.
+ * @param metaPath - Absolute path to the .meta directory.
+ * @returns Parsed lock state.
  */
-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);
+function readLockState(metaPath) {
+    const lockPath = join(metaPath, LOCK_FILE);
+    if (!existsSync(lockPath)) {
+        return { exists: false, staged: false, active: false, data: null };
     }
-    if (value !== null && typeof value === 'object') {
-        const result = {};
-        for (const [key, val] of Object.entries(value)) {
-            result[key] = substituteEnvVars(val);
+    try {
+        const raw = readFileSync(lockPath, 'utf8');
+        const data = JSON.parse(raw);
+        if ('_id' in data) {
+            return { exists: true, staged: true, active: false, data };
         }
-        return result;
+        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 };
     }
-    return value;
 }
 /**
- * Resolve \@file: references in a config value.
+ * Attempt to acquire a lock on a .meta directory.
  *
- * @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).
+ * @param metaPath - Absolute path to the .meta directory.
+ * @returns True if lock was acquired, false if already locked (non-stale).
  */
-function resolveFileRef(value, baseDir) {
-    if (!value.startsWith('@file:'))
-        return value;
-    const filePath = join(baseDir, value.slice(6));
-    return readFileSync(filePath, 'utf8');
+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 = {
+        _lockPid: process.pid,
+        _lockStartedAt: new Date().toISOString(),
+    };
+    writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n');
+    return true;
 }
 /**
- * Migrate legacy config path to the new canonical location.
- *
- * If the old path `{configRoot}/jeeves-meta.config.json` exists and the new
- * path `{configRoot}/jeeves-meta/config.json` does NOT exist, copies the file
- * to the new location and logs a warning.
+ * Release a lock on a .meta directory.
  *
- * @param configRoot - Root directory for configuration files.
- * @param warn - Optional callback for logging the migration warning.
+ * @param metaPath - Absolute path to the .meta directory.
  */
-function migrateConfigPath(configRoot, warn) {
-    const oldPath = join(configRoot, 'jeeves-meta.config.json');
-    const newDir = join(configRoot, 'jeeves-meta');
-    const newPath = join(newDir, 'config.json');
-    if (existsSync(oldPath) && !existsSync(newPath)) {
-        mkdirSync(newDir, { recursive: true });
-        copyFileSync(oldPath, newPath);
-        const message = `Migrated config from ${oldPath} to ${newPath}. The old file can be removed.`;
-        if (warn) {
-            warn(message);
-        }
-        else {
-            console.warn(`[jeeves-meta] ${message}`);
-        }
+function releaseLock(metaPath) {
+    const lockPath = join(metaPath, LOCK_FILE);
+    try {
+        unlinkSync(lockPath);
+    }
+    catch {
+        // Already removed or never existed
     }
 }
 /**
- * Resolve config path from --config flag or JEEVES_META_CONFIG env var.
+ * Check if a .meta directory is currently locked (non-stale).
  *
- * @param args - CLI arguments (process.argv.slice(2)).
- * @returns Resolved config path.
- * @throws If no config path found.
+ * @param metaPath - Absolute path to the .meta directory.
+ * @returns True if locked and not stale.
  */
-function resolveConfigPath(args) {
-    let configIdx = args.indexOf('--config');
-    if (configIdx === -1)
-        configIdx = args.indexOf('-c');
-    if (configIdx !== -1 && args[configIdx + 1]) {
-        return args[configIdx + 1];
-    }
-    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.');
+function isLocked(metaPath) {
+    return readLockState(metaPath).active;
 }
 /**
- * Load service config from a JSON file.
+ * Clean up stale lock files on startup.
  *
- * Resolves \@file: references for defaultArchitect and defaultCritic,
- * and substitutes environment-variable placeholders throughout.
+ * 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 configPath - Path to config JSON file.
- * @returns Validated ServiceConfig.
+ * @param metaPaths - Array of .meta directory paths to check.
+ * @param logger - Optional logger for warnings.
  */
-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);
+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
+        }
     }
-    return serviceConfigSchema.parse(raw);
 }
 
 /**
- * Compute summary statistics from an array of MetaEntry objects.
+ * Read and parse a meta.json file from a `.meta/` directory.
  *
- * 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,
-    };
-}
-
-/**
- * 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.
- *
- * Uses the watcher's `/walk` endpoint to find all `.meta/meta.json` files
- * and returns deduplicated meta directory paths.
- *
- * @param watcher - WatcherClient for walk queries.
- * @returns Array of normalized .meta/ directory paths.
- */
-async function discoverMetas(watcher) {
-    const allPaths = await watcher.walk(['**/.meta/meta.json']);
-    // Deduplicate by .meta/ directory path (handles multi-chunk files)
-    const seen = new Set();
-    const metaPaths = [];
-    for (const filePath of allPaths) {
-        const fp = normalizePath(filePath);
-        // Derive .meta/ directory from file_path (strip /meta.json)
-        const metaPath = fp.replace(/\/meta\.json$/, '');
-        if (seen.has(metaPath))
-            continue;
-        seen.add(metaPath);
-        metaPaths.push(metaPath);
-    }
-    return metaPaths;
-}
-
-/**
- * File-system lock for preventing concurrent synthesis on the same meta.
- *
- * 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
-/**
- * Read and classify the state of a .meta/.lock file.
- *
- * @param metaPath - Absolute path to the .meta directory.
- * @returns Parsed lock state.
- */
-function readLockState(metaPath) {
-    const lockPath = join(metaPath, LOCK_FILE);
-    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 };
-        }
-        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 = {
-        _lockPid: process.pid,
-        _lockStartedAt: new Date().toISOString(),
-    };
-    writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n');
-    return true;
-}
-/**
- * Release a lock on a .meta directory.
- *
- * @param metaPath - Absolute path to the .meta directory.
- */
-function releaseLock(metaPath) {
-    const lockPath = join(metaPath, LOCK_FILE);
-    try {
-        unlinkSync(lockPath);
-    }
-    catch {
-        // Already removed or never existed
-    }
-}
-/**
- * Check if a .meta directory is currently locked (non-stale).
- *
- * @param metaPath - Absolute path to the .meta directory.
- * @returns True if locked and not stale.
- */
-function isLocked(metaPath) {
-    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
-        }
-    }
-}
-
-/**
- * Read and parse a meta.json file from a `.meta/` directory.
- *
- * Shared utility to eliminate repeated `JSON.parse(readFileSync(...))` across
- * discovery, orchestration, and route handlers.
+ * Shared utility to eliminate repeated `JSON.parse(readFileSync(...))` across
+ * discovery, orchestration, and route handlers.
  *
  * @module readMetaJson
  */
@@ -9030,22 +8908,287 @@ function getDeltaFiles(generatedAt, scopeFiles) {
 }
 
 /**
- * Error thrown when a spawned subprocess is aborted via AbortController.
+ * In-memory cache for listMetas results with TTL and concurrent refresh guard.
  *
- * @module executor/SpawnAbortedError
+ * @module cache
  */
-/** Error indicating a spawn was deliberately aborted. */
-class SpawnAbortedError extends Error {
-    constructor(message = 'Synthesis was aborted') {
-        super(message);
-        this.name = 'SpawnAbortedError';
+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;
     }
 }
 
 /**
- * Error thrown when a spawned subprocess times out.
+ * Shared live config hot-reload support.
  *
- * Carries the output file path so callers can attempt partial output recovery.
+ * 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 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');
+}
+/**
+ * Migrate legacy config path to the new canonical location.
+ *
+ * If the old path `{configRoot}/jeeves-meta.config.json` exists and the new
+ * path `{configRoot}/jeeves-meta/config.json` does NOT exist, copies the file
+ * to the new location and logs a warning.
+ *
+ * @param configRoot - Root directory for configuration files.
+ * @param warn - Optional callback for logging the migration warning.
+ */
+function migrateConfigPath(configRoot, warn) {
+    const oldPath = join(configRoot, 'jeeves-meta.config.json');
+    const newDir = join(configRoot, 'jeeves-meta');
+    const newPath = join(newDir, 'config.json');
+    if (existsSync(oldPath) && !existsSync(newPath)) {
+        mkdirSync(newDir, { recursive: true });
+        copyFileSync(oldPath, newPath);
+        const message = `Migrated config from ${oldPath} to ${newPath}. The old file can be removed.`;
+        if (warn) {
+            warn(message);
+        }
+        else {
+            console.warn(`[jeeves-meta] ${message}`);
+        }
+    }
+}
+/**
+ * Resolve config path from --config flag or JEEVES_META_CONFIG env var.
+ *
+ * @param args - CLI arguments (process.argv.slice(2)).
+ * @returns Resolved config path.
+ * @throws If no config path found.
+ */
+function resolveConfigPath(args) {
+    let configIdx = args.indexOf('--config');
+    if (configIdx === -1)
+        configIdx = args.indexOf('-c');
+    if (configIdx !== -1 && args[configIdx + 1]) {
+        return args[configIdx + 1];
+    }
+    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);
+}
+
+/**
+ * Error thrown when a spawned subprocess is aborted via AbortController.
+ *
+ * @module executor/SpawnAbortedError
+ */
+/** Error indicating a spawn was deliberately aborted. */
+class SpawnAbortedError extends Error {
+    constructor(message = 'Synthesis was aborted') {
+        super(message);
+        this.name = 'SpawnAbortedError';
+    }
+}
+
+/**
+ * Error thrown when a spawned subprocess times out.
+ *
+ * Carries the output file path so callers can attempt partial output recovery.
  *
  * @module executor/SpawnTimeoutError
  */
@@ -9127,21 +9270,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. */
@@ -9183,8 +9334,10 @@ class GatewayExecutor {
             ...(options?.thinking ? { thinking: options.thinking } : {}),
             ...(options?.model ? { model: options.model } : {}),
         });
-        const details = (spawnResult.result?.details ?? spawnResult.result);
-        const sessionKey = details?.childSessionKey ?? details?.sessionKey;
+        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));
@@ -9207,48 +9360,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 {
@@ -9423,6 +9581,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 {
@@ -9578,264 +9737,16 @@ function buildCriticTask(ctx, meta, config) {
 }
 
 /**
- * Exponential moving average helper for token tracking.
+ * Build a minimal MetaNode from a known meta path using watcher walk.
  *
- * @module ema
+ * Used for targeted synthesis (when a specific path is requested) to avoid
+ * the full discovery + ownership tree build. Discovers only immediate child
+ * `.meta/` directories.
+ *
+ * @module discovery/buildMinimalNode
  */
-const DEFAULT_DECAY = 0.3;
 /**
- * Compute exponential moving average.
- *
- * @param current - New observation.
- * @param previous - Previous EMA value, or undefined for first observation.
- * @param decay - Decay factor (0-1). Higher = more weight on new value. Default 0.3.
- * @returns Updated EMA.
- */
-function computeEma(current, previous, decay = DEFAULT_DECAY) {
-    if (previous === undefined)
-        return current;
-    return decay * current + (1 - decay) * previous;
-}
-
-/**
- * Structured error from a synthesis step failure.
- *
- * @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. */
-const metaJsonSchema = 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();
-
-/**
- * Merge synthesis results into meta.json.
- *
- * Preserves human-set fields (_id, _steer, _depth).
- * Writes engine fields (_generatedAt, _structureHash, etc.).
- * Validates against schema before writing.
- *
- * @module orchestrator/merge
- */
-/**
- * Merge results into meta.json and write atomically.
- *
- * @param options - Merge options.
- * @returns The updated MetaJson.
- * @throws If validation fails (malformed output).
- */
-async function mergeAndWrite(options) {
-    const merged = {
-        // Preserve human-set fields (auto-generate _id on first synthesis)
-        _id: options.current._id ?? randomUUID(),
-        _steer: options.current._steer,
-        _depth: options.current._depth,
-        _emphasis: options.current._emphasis,
-        // Engine fields
-        _architect: options.architect,
-        _builder: options.builder,
-        _critic: options.critic,
-        _generatedAt: options.stateOnly
-            ? options.current._generatedAt
-            : new Date().toISOString(),
-        _structureHash: options.structureHash,
-        _synthesisCount: options.synthesisCount,
-        // Token tracking
-        _architectTokens: options.architectTokens,
-        _builderTokens: options.builderTokens,
-        _criticTokens: options.criticTokens,
-        _architectTokensAvg: options.architectTokens !== undefined
-            ? computeEma(options.architectTokens, options.current._architectTokensAvg)
-            : options.current._architectTokensAvg,
-        _builderTokensAvg: options.builderTokens !== undefined
-            ? computeEma(options.builderTokens, options.current._builderTokensAvg)
-            : options.current._builderTokensAvg,
-        _criticTokensAvg: options.criticTokens !== undefined
-            ? computeEma(options.criticTokens, options.current._criticTokensAvg)
-            : options.current._criticTokensAvg,
-        // Content from builder (stateOnly preserves previous content)
-        _content: options.stateOnly
-            ? options.current._content
-            : (options.builderOutput?.content ?? options.current._content),
-        // Feedback from critic
-        _feedback: options.feedback ?? options.current._feedback,
-        // Progressive state
-        _state: options.state,
-        // Error handling
-        _error: options.error ?? undefined,
-        // Phase state machine
-        _phaseState: options.phaseState,
-        // Spread structured fields from builder
-        ...options.builderOutput?.fields,
-    };
-    // Clean up undefined optional fields
-    if (merged._steer === undefined)
-        delete merged._steer;
-    if (merged._depth === undefined)
-        delete merged._depth;
-    if (merged._emphasis === undefined)
-        delete merged._emphasis;
-    if (merged._architectTokens === undefined)
-        delete merged._architectTokens;
-    if (merged._builderTokens === undefined)
-        delete merged._builderTokens;
-    if (merged._criticTokens === undefined)
-        delete merged._criticTokens;
-    if (merged._architectTokensAvg === undefined)
-        delete merged._architectTokensAvg;
-    if (merged._builderTokensAvg === undefined)
-        delete merged._builderTokensAvg;
-    if (merged._criticTokensAvg === undefined)
-        delete merged._criticTokensAvg;
-    if (merged._state === undefined)
-        delete merged._state;
-    if (merged._error === undefined)
-        delete merged._error;
-    if (merged._content === undefined)
-        delete merged._content;
-    if (merged._feedback === undefined)
-        delete merged._feedback;
-    if (merged._phaseState === undefined)
-        delete merged._phaseState;
-    // Validate
-    const result = metaJsonSchema.safeParse(merged);
-    if (!result.success) {
-        throw new Error(`Meta validation failed: ${result.error.message}`);
-    }
-    // Write to specified path (lock staging) or default meta.json
-    const filePath = options.outputPath ?? join(options.metaPath, 'meta.json');
-    await writeFile(filePath, JSON.stringify(result.data, null, 2) + '\n');
-    return result.data;
-}
-
-/**
- * Build a minimal MetaNode from a known meta path using watcher walk.
- *
- * Used for targeted synthesis (when a specific path is requested) to avoid
- * the full discovery + ownership tree build. Discovers only immediate child
- * `.meta/` directories.
- *
- * @module discovery/buildMinimalNode
- */
-/**
- * Build a minimal MetaNode for a known meta path.
+ * Build a minimal MetaNode for a known meta path.
  *
  * Walks the owner directory for child `.meta/meta.json` files and constructs
  * a shallow ownership tree (self + direct children only).
@@ -9887,103 +9798,301 @@ async function buildMinimalNode(metaPath, watcher) {
 }
 
 /**
- * Weighted staleness formula for candidate selection.
+ * Pure phase-state transition functions.
  *
- * effectiveStaleness = actualStaleness * (normalizedDepth + 1) ^ (depthWeight * emphasis)
+ * Implements every row of the §8 "Transitions and invalidation cascade" table.
+ * No I/O — pure functions over PhaseState and documented inputs.
  *
- * @module scheduling/weightedFormula
+ * @module phaseState/phaseTransitions
  */
 /**
- * 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.
+ * Create a fresh (fully-complete) phase state.
  */
-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),
-        };
-    });
+function freshPhaseState() {
+    return { architect: 'fresh', builder: 'fresh', critic: 'fresh' };
 }
-
 /**
- * Select the best synthesis candidate from stale metas.
- *
- * Picks the meta with highest effective staleness.
- *
- * @module scheduling/selectCandidate
+ * Create a phase state for a never-synthesized meta (all pending from architect).
  */
+function initialPhaseState() {
+    return { architect: 'pending', builder: 'stale', critic: 'stale' };
+}
 /**
- * Select the candidate with the highest effective staleness.
+ * Enforce the per-meta invariant: at most one phase is pending or running,
+ * and it is the first non-fresh phase in pipeline order.
  *
- * @param candidates - Array of candidates with computed effective staleness.
- * @returns The winning candidate, or null if no candidates.
+ * Stale phases that become the first non-fresh phase are promoted to pending.
  */
-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];
+function enforceInvariant(state) {
+    const result = { ...state };
+    let foundNonFresh = false;
+    for (const phase of ['architect', 'builder', 'critic']) {
+        const s = result[phase];
+        if (s === 'fresh')
+            continue;
+        if (!foundNonFresh) {
+            foundNonFresh = true;
+            // First non-fresh: if stale, promote to pending
+            if (s === 'stale') {
+                result[phase] = 'pending';
+            }
+            // pending, running, failed stay as-is
+        }
+        else {
+            // Subsequent non-fresh: must not be pending or running
+            if (s === 'pending') {
+                result[phase] = 'stale';
+            }
+            // running in non-first position would be a bug, but don't mask it
         }
     }
-    return best;
+    return result;
 }
+// ── Invalidation cascades ──────────────────────────────────────────────
 /**
- * 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.
+ * Architect invalidated: architect → pending; builder, critic → stale.
+ * Triggers: _structureHash change, _steer change, _architect change,
+ * _crossRefs declaration change, _synthesisCount \>= architectEvery.
  */
-function discoverStalestPath(candidates, depthWeight) {
-    const weighted = computeEffectiveStaleness(candidates, depthWeight);
-    const winner = selectCandidate(weighted);
-    return winner?.node.metaPath ?? null;
+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,
+    });
 }
-
 /**
- * Shared error utilities.
- *
- * @module errors
+ * 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 ──────────────────────────────────────────
 /**
- * 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.
+ * Architect completes successfully.
+ * architect → fresh; builder → pending; critic → stale.
  */
-function toMetaError(step, err, code = 'FAILED') {
+function architectSuccess(state) {
+    return enforceInvariant({
+        architect: 'fresh',
+        builder: state.builder === 'failed' ? 'failed' : 'pending',
+        critic: state.critic === 'fresh' ? 'stale' : state.critic,
+    });
+}
+/**
+ * Builder completes successfully.
+ * builder → fresh; critic → pending.
+ */
+function builderSuccess(state) {
+    return enforceInvariant({
+        ...state,
+        builder: 'fresh',
+        critic: state.critic === 'failed' ? 'failed' : 'pending',
+    });
+}
+/**
+ * Critic completes successfully.
+ * critic → fresh. Meta becomes fully fresh.
+ */
+function criticSuccess(state) {
+    return enforceInvariant({
+        ...state,
+        critic: 'fresh',
+    });
+}
+// ── Failure transition ─────────────────────────────────────────────────
+/**
+ * A phase fails (error, timeout, or abort).
+ * Target phase → failed; upstream and downstream unchanged.
+ */
+function phaseFailed(state, phase) {
+    return enforceInvariant({
+        ...state,
+        [phase]: 'failed',
+    });
+}
+// ── Surgical retry ─────────────────────────────────────────────────────
+/**
+ * Retry a failed phase: failed → pending.
+ * Only valid when the phase is currently failed.
+ */
+function retryPhase(state, phase) {
+    if (state[phase] !== 'failed')
+        return state;
+    return enforceInvariant({
+        ...state,
+        [phase]: 'pending',
+    });
+}
+/**
+ * Retry all failed phases: each failed phase → pending.
+ * Used by scheduler ticks and queue reads to auto-promote failed phases.
+ */
+function retryAllFailed(state) {
+    let result = state;
+    for (const phase of ['architect', 'builder', 'critic']) {
+        if (result[phase] === 'failed') {
+            result = retryPhase(result, phase);
+        }
+    }
+    return result;
+}
+// ── Running transition ─────────────────────────────────────────────────
+/**
+ * Mark a phase as running (scheduler picks it).
+ */
+function phaseRunning(state, phase) {
     return {
-        step,
-        code,
-        message: err instanceof Error ? err.message : String(err),
+        ...state,
+        [phase]: 'running',
     };
 }
+// ── Query helpers ──────────────────────────────────────────────────────
+/**
+ * Get the owed phase: first non-fresh phase in pipeline order, or null.
+ */
+function getOwedPhase(state) {
+    for (const phase of ['architect', 'builder', 'critic']) {
+        if (state[phase] !== 'fresh')
+            return phase;
+    }
+    return null;
+}
+/**
+ * Check if a meta is fully fresh (all phases fresh).
+ */
+function isFullyFresh(state) {
+    return (state.architect === 'fresh' &&
+        state.builder === 'fresh' &&
+        state.critic === 'fresh');
+}
+/**
+ * Get the scheduler priority band for a meta's owed phase.
+ * 1 = critic (highest), 2 = builder, 3 = architect, null = fully fresh.
+ */
+function getPriorityBand(state) {
+    const owed = getOwedPhase(state);
+    if (!owed)
+        return null;
+    if (owed === 'critic')
+        return 1;
+    if (owed === 'builder')
+        return 2;
+    return 3;
+}
+
+/**
+ * Backward-compatible derivation of _phaseState from existing meta fields.
+ *
+ * When a meta is loaded from disk without _phaseState, this reconstructs
+ * the phase state from _content, _builder, _state, _error.step, and
+ * the architect-invalidating inputs.
+ *
+ * @module phaseState/derivePhaseState
+ */
+/**
+ * Derive _phaseState from existing meta fields.
+ *
+ * If the meta already has _phaseState, returns it as-is.
+ *
+ * Otherwise, reconstructs from available fields:
+ * - Never-synthesized meta (no _content, no _builder): all phases start pending/stale.
+ * - Errored meta: the failed phase is mapped from _error.step.
+ * - Mid-cycle meta with cached _builder but no _content: builder pending.
+ * - Fully-fresh meta: all phases fresh.
+ * - Meta with stale architect inputs: architect pending, downstream stale.
+ *
+ * @param meta - The meta.json content.
+ * @param inputs - Optional derivation inputs. If not provided, a simpler
+ *   heuristic is used (no architect invalidation check).
+ * @returns The derived PhaseState.
+ */
+function derivePhaseState(meta, inputs) {
+    // Already has _phaseState — use it
+    if (meta._phaseState)
+        return meta._phaseState;
+    // Check for errors first — _error.step maps directly to failed phase
+    if (meta._error) {
+        const failedPhase = meta._error.step;
+        const state = freshPhaseState();
+        state[failedPhase] = 'failed';
+        // If architect failed and no _builder, downstream is stale
+        if (failedPhase === 'architect') {
+            if (!meta._builder) {
+                state.builder = 'stale';
+                state.critic = 'stale';
+            }
+        }
+        // If builder failed, critic is stale
+        if (failedPhase === 'builder') {
+            state.critic = 'stale';
+        }
+        return state;
+    }
+    // Never synthesized: no _content AND no _builder (and no error)
+    if (!meta._content && !meta._builder) {
+        return initialPhaseState();
+    }
+    // Check architect invalidation (when inputs are provided)
+    if (inputs) {
+        // Progressive metas: structure changes invalidate builder, not architect
+        const structureInvalidatesArchitect = inputs.structureChanged && meta._state === undefined;
+        const architectInvalidated = structureInvalidatesArchitect ||
+            inputs.steerChanged ||
+            inputs.architectChanged ||
+            inputs.crossRefsChanged ||
+            (meta._synthesisCount ?? 0) >= inputs.architectEvery;
+        if (architectInvalidated) {
+            return {
+                architect: 'pending',
+                builder: 'stale',
+                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) {
+        return {
+            architect: 'fresh',
+            builder: 'pending',
+            critic: 'stale',
+        };
+    }
+    // Has _content but no _feedback: critic is pending
+    if (meta._content && !meta._feedback) {
+        return {
+            architect: 'fresh',
+            builder: 'fresh',
+            critic: 'pending',
+        };
+    }
+    // Default: fully fresh
+    return freshPhaseState();
+}
 
 /**
  * Compute a structure hash from a sorted file listing.
@@ -10006,86 +10115,296 @@ function computeStructureHash(filePaths) {
 }
 
 /**
- * Lock-staged cycle finalization: write to .lock, copy to meta.json, archive, prune.
- *
- * @module orchestrator/finalizeCycle
- */
-/** Finalize a cycle using lock staging: write to .lock → copy to meta.json + archive → delete .lock. */
-async function finalizeCycle(opts) {
-    const lockPath = join(opts.metaPath, '.lock');
-    const metaJsonPath = join(opts.metaPath, 'meta.json');
-    // Stage: write merged result to .lock (sequential — ordering matters)
-    const updated = await mergeAndWrite({
-        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,
-        state: opts.state,
-        stateOnly: opts.stateOnly,
-    });
-    // Commit: copy .lock → meta.json
-    await copyFile(lockPath, metaJsonPath);
-    // Archive + prune from the committed meta.json (sequential)
-    await createSnapshot(opts.metaPath, updated);
-    await pruneArchive(opts.metaPath, opts.config.maxArchive);
-    // .lock is cleaned up by the finally block (releaseLock)
-    return updated;
-}
-
-/**
- * Parse subprocess outputs for each synthesis step.
+ * Per-tick invalidation pass.
  *
- * - Architect: returns text \> _builder
- * - Builder: returns JSON \> _content + structured fields
- * - Critic: returns text \> _feedback
+ * Computes architect-invalidating and builder-invalidating inputs for a meta,
+ * then applies the cascade to update _phaseState.
  *
- * @module orchestrator/parseOutput
+ * @module phaseState/invalidate
  */
 /**
- * Parse architect output. The architect returns a task brief as text.
+ * Compute invalidation inputs and apply cascade for a single meta.
  *
- * @param output - Raw subprocess output.
- * @returns The task brief string.
+ * @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.
  */
-function parseArchitectOutput(output) {
-    return output.trim();
+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,
+    };
 }
+
 /**
- * Parse builder output. The builder returns JSON with _content and optional fields.
+ * Weighted staleness formula for candidate selection.
  *
- * Attempts JSON parse first. If that fails, treats the entire output as _content.
+ * effectiveStaleness = actualStaleness * (normalizedDepth + 1) ^ (depthWeight * emphasis)
  *
- * @param output - Raw subprocess output.
- * @returns Parsed builder output with content and structured fields.
+ * @module scheduling/weightedFormula
  */
-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;
+/**
+ * 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.
+ *
+ * Selects the highest-priority ready phase across all metas.
+ * Priority: critic (band 1) \> builder (band 2) \> architect (band 3).
+ * Tiebreak within band: weighted staleness (§3.9).
+ *
+ * @module phaseState/phaseScheduler
+ */
+/**
+ * Build phase candidates from listMetas entries.
+ *
+ * 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, 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.
+ *
+ * Filters to pending phases, computes effective staleness, and sorts by
+ * band (ascending: critic first) then effective staleness (descending).
+ *
+ * Used by selectPhaseCandidate (returns first) and the queue route (returns all).
+ */
+function rankPhaseCandidates(metas, depthWeight) {
+    // Filter to metas with a pending (scheduler-eligible) phase
+    const eligible = metas.filter((m) => {
+        if (m.locked)
+            return false;
+        if (m.disabled && !m.isOverride)
+            return false;
+        const owed = getOwedPhase(m.phaseState);
+        if (!owed)
+            return false;
+        return m.phaseState[owed] === 'pending';
+    });
+    if (eligible.length === 0)
+        return [];
+    // Compute effective staleness for tiebreaking
+    const withStaleness = computeEffectiveStaleness(eligible.map((m) => ({
+        node: m.node,
+        meta: m.meta,
+        actualStaleness: m.actualStaleness,
+    })), depthWeight);
+    // Build candidates with band info
+    const candidates = withStaleness.map((ws, i) => {
+        const m = eligible[i];
+        const owedPhase = getOwedPhase(m.phaseState);
+        return {
+            node: ws.node,
+            meta: ws.meta,
+            phaseState: m.phaseState,
+            owedPhase,
+            band: getPriorityBand(m.phaseState),
+            actualStaleness: ws.actualStaleness,
+            effectiveStaleness: ws.effectiveStaleness,
+        };
+    });
+    // Sort by band (ascending = critic first) then effective staleness (descending)
+    candidates.sort((a, b) => {
+        if (a.band !== b.band)
+            return a.band - b.band;
+        return b.effectiveStaleness - a.effectiveStaleness;
+    });
+    return candidates;
+}
+/**
+ * Select the best phase candidate across the corpus.
+ *
+ * @param metas - Array of (node, meta, phaseState, stalenessSeconds) tuples.
+ * @param depthWeight - Config depthWeight for staleness tiebreak.
+ * @returns The winning candidate, or null if no phase is ready.
+ */
+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('{');
@@ -10121,730 +10440,22 @@ function tryParseJson(str) {
         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();
-}
-
-/**
- * Timeout recovery — salvage partial builder state after a SpawnTimeoutError.
- *
- * @module orchestrator/timeoutRecovery
- */
-/**
- * Attempt to recover partial state from a timed-out builder spawn.
- *
- * Returns an {@link OrchestrateResult} if state was salvaged, or `null`
- * if the caller should fall through to a hard failure.
- */
-async function attemptTimeoutRecovery(opts) {
-    const { err, currentMeta, metaPath, config, builderBrief, structureHash, synthesisCount, } = opts;
-    let partialOutput = null;
-    try {
-        const raw = await readFile(err.outputPath, 'utf8');
-        partialOutput = parseBuilderOutput(raw);
-    }
-    catch {
-        // Could not read partial output — fall through to hard failure
-    }
-    if (partialOutput?.state !== undefined) {
-        const currentState = JSON.stringify(currentMeta._state);
-        const newState = JSON.stringify(partialOutput.state);
-        if (newState !== currentState) {
-            const timeoutError = {
-                step: 'builder',
-                code: 'TIMEOUT',
-                message: err.message,
-            };
-            await finalizeCycle({
-                metaPath,
-                current: currentMeta,
-                config,
-                architect: currentMeta._architect ?? '',
-                builder: builderBrief,
-                critic: currentMeta._critic ?? '',
-                builderOutput: null,
-                feedback: null,
-                structureHash,
-                synthesisCount,
-                error: timeoutError,
-                state: partialOutput.state,
-                stateOnly: true,
-            });
-            return {
-                synthesized: true,
-                metaPath,
-                error: timeoutError,
-            };
-        }
-    }
-    return null;
-}
-
-/**
- * Single-node synthesis pipeline — architect, builder, critic.
- *
- * @module orchestrator/synthesizeNode
- */
-/** Run the architect/builder/critic pipeline on a single node. */
-async function synthesizeNode(node, currentMeta, config, executor, watcher, onProgress, logger) {
-    // Step 5-6: Steer change detection
-    const latestArchive = await readLatestArchive(node.metaPath);
-    const steerChanged = hasSteerChanged(currentMeta._steer, latestArchive?._steer, Boolean(latestArchive));
-    // Step 7: Compute context (includes scope files and delta files)
-    const ctx = await buildContextPackage(node, currentMeta, watcher, logger);
-    // Skip empty-scope entities that have no prior content.
-    // Without scope files, child metas, or cross-refs there is nothing for
-    // the architect/builder to work with and the cycle will either time out
-    // or produce empty output.
-    const hasScope = ctx.scopeFiles.length > 0 ||
-        Object.keys(ctx.childMetas).length > 0 ||
-        Object.keys(ctx.crossRefMetas).length > 0;
-    if (!hasScope && !currentMeta._content) {
-        // Bump _generatedAt so this entity doesn't keep winning the staleness
-        // race every cycle. It will be re-evaluated when files appear.
-        // Uses lock-staging for atomic write consistency.
-        currentMeta._generatedAt = new Date().toISOString();
-        const lockPath = join(node.metaPath, '.lock');
-        const metaJsonPath = join(node.metaPath, 'meta.json');
-        await writeFile(lockPath, JSON.stringify(currentMeta, null, 2));
-        await copyFile(lockPath, metaJsonPath);
-        logger?.debug({ path: node.ownerPath }, 'Skipping empty-scope entity');
-        return { synthesized: false };
-    }
-    // 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 ?? '';
-    let synthesisCount = currentMeta._synthesisCount ?? 0;
-    let stepError = null;
-    let architectTokens;
-    let builderTokens;
-    let criticTokens;
-    // Shared base options for all finalizeCycle calls.
-    // Note: synthesisCount is excluded because it mutates during the pipeline.
-    const baseFinalizeOptions = {
-        metaPath: node.metaPath,
-        current: currentMeta,
-        config,
-        architect: currentMeta._architect ?? '',
-        critic: currentMeta._critic ?? '',
-        structureHash: newStructureHash,
-    };
-    if (architectTriggered) {
-        try {
-            await onProgress?.({
-                type: 'phase_start',
-                path: node.ownerPath,
-                phase: 'architect',
-            });
-            const phaseStart = Date.now();
-            const architectTask = buildArchitectTask(ctx, currentMeta, config);
-            const architectResult = await executor.spawn(architectTask, {
-                thinking: config.thinking,
-                timeout: config.architectTimeout,
-                label: 'meta-architect',
-            });
-            builderBrief = parseArchitectOutput(architectResult.output);
-            architectTokens = architectResult.tokens;
-            synthesisCount = 0;
-            await onProgress?.({
-                type: 'phase_complete',
-                path: node.ownerPath,
-                phase: 'architect',
-                tokens: architectTokens,
-                durationMs: Date.now() - phaseStart,
-            });
-        }
-        catch (err) {
-            stepError = toMetaError('architect', err);
-            if (!currentMeta._builder) {
-                // No cached builder — cycle fails
-                await finalizeCycle({
-                    ...baseFinalizeOptions,
-                    builder: '',
-                    builderOutput: null,
-                    feedback: null,
-                    synthesisCount,
-                    error: stepError,
-                    architectTokens,
-                });
-                return {
-                    synthesized: true,
-                    metaPath: node.metaPath,
-                    error: stepError,
-                };
-            }
-            // Has cached builder — continue with existing
-        }
-    }
-    // Step 9: Builder
-    const metaForBuilder = { ...currentMeta, _builder: builderBrief };
-    let builderOutput;
-    try {
-        await onProgress?.({
-            type: 'phase_start',
-            path: node.ownerPath,
-            phase: 'builder',
-        });
-        const builderStart = Date.now();
-        const builderTask = buildBuilderTask(ctx, metaForBuilder, config);
-        const builderResult = await executor.spawn(builderTask, {
-            thinking: config.thinking,
-            timeout: config.builderTimeout,
-            label: 'meta-builder',
-        });
-        builderOutput = parseBuilderOutput(builderResult.output);
-        builderTokens = builderResult.tokens;
-        synthesisCount++;
-        await onProgress?.({
-            type: 'phase_complete',
-            path: node.ownerPath,
-            phase: 'builder',
-            tokens: builderTokens,
-            durationMs: Date.now() - builderStart,
-        });
-    }
-    catch (err) {
-        if (err instanceof SpawnTimeoutError) {
-            const recovered = await attemptTimeoutRecovery({
-                err,
-                currentMeta,
-                metaPath: node.metaPath,
-                config,
-                builderBrief,
-                structureHash: newStructureHash,
-                synthesisCount,
-            });
-            if (recovered)
-                return recovered;
-        }
-        stepError = toMetaError('builder', err);
-        await finalizeCycle({
-            ...baseFinalizeOptions,
-            builder: builderBrief,
-            builderOutput: null,
-            feedback: null,
-            synthesisCount,
-            error: stepError,
-        });
-        return { synthesized: true, metaPath: node.metaPath, error: stepError };
-    }
-    // Step 10: Critic
-    const metaForCritic = {
-        ...currentMeta,
-        _content: builderOutput.content,
-    };
-    let feedback = null;
-    try {
-        await onProgress?.({
-            type: 'phase_start',
-            path: node.ownerPath,
-            phase: 'critic',
-        });
-        const criticStart = Date.now();
-        const criticTask = buildCriticTask(ctx, metaForCritic, config);
-        const criticResult = await executor.spawn(criticTask, {
-            thinking: config.thinking,
-            timeout: config.criticTimeout,
-            label: 'meta-critic',
-        });
-        feedback = parseCriticOutput(criticResult.output);
-        criticTokens = criticResult.tokens;
-        stepError = null; // Clear any architect error on full success
-        await onProgress?.({
-            type: 'phase_complete',
-            path: node.ownerPath,
-            phase: 'critic',
-            tokens: criticTokens,
-            durationMs: Date.now() - criticStart,
-        });
-    }
-    catch (err) {
-        stepError = stepError ?? toMetaError('critic', err);
-    }
-    // Steps 11-12: Merge, archive, prune
-    await finalizeCycle({
-        ...baseFinalizeOptions,
-        builder: builderBrief,
-        builderOutput,
-        feedback,
-        synthesisCount,
-        error: stepError,
-        architectTokens,
-        builderTokens,
-        criticTokens,
-        state: builderOutput.state,
-    });
-    return {
-        synthesized: true,
-        metaPath: node.metaPath,
-        error: stepError ?? undefined,
-    };
-}
-
-/**
- * Main orchestration entry point — discovery, scheduling, candidate selection.
- *
- * @module orchestrator/orchestrate
- */
-async function orchestrateOnce(config, executor, watcher, targetPath, onProgress, logger) {
-    // When targetPath is provided, skip the expensive full discovery scan.
-    // Build a minimal node from the filesystem instead.
-    if (targetPath) {
-        const normalizedTarget = normalizePath(targetPath);
-        const targetMetaJson = join(normalizedTarget, 'meta.json');
-        if (!existsSync(targetMetaJson))
-            return { synthesized: false };
-        const node = await buildMinimalNode(normalizedTarget, watcher);
-        if (!acquireLock(node.metaPath))
-            return { synthesized: false };
-        try {
-            const currentMeta = await readMetaJson(normalizedTarget);
-            return await synthesizeNode(node, currentMeta, config, executor, watcher, onProgress, logger);
-        }
-        finally {
-            releaseLock(node.metaPath);
-        }
-    }
-    // Full discovery path (scheduler-driven, no specific target)
-    // Step 1: Discover via watcher walk
-    const discoveryStart = Date.now();
-    const metaPaths = await discoverMetas(watcher);
-    logger?.debug({ paths: metaPaths.length, durationMs: Date.now() - discoveryStart }, 'discovery complete');
-    if (metaPaths.length === 0)
-        return { synthesized: false };
-    // Read meta.json for each discovered meta
-    const metas = new Map();
-    for (const mp of metaPaths) {
-        try {
-            metas.set(normalizePath(mp), await readMetaJson(mp));
-        }
-        catch {
-            // Skip metas with unreadable meta.json
-            continue;
-        }
-    }
-    // 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);
-    // Steps 3-4: Staleness check + candidate selection
-    const candidates = [];
-    for (const treeNode of tree.nodes.values()) {
-        const meta = metas.get(treeNode.metaPath);
-        if (!meta)
-            continue;
-        const staleness = actualStaleness(meta);
-        if (staleness > 0) {
-            candidates.push({ node: treeNode, meta, actualStaleness: staleness });
-        }
-    }
-    const weighted = computeEffectiveStaleness(candidates, config.depthWeight);
-    // Sort by effective staleness descending
-    const ranked = [...weighted].sort((a, b) => b.effectiveStaleness - a.effectiveStaleness);
-    if (ranked.length === 0)
-        return { synthesized: false };
-    // Find the first candidate with actual changes (if skipUnchanged)
-    let winner = null;
-    for (const candidate of ranked) {
-        if (!acquireLock(candidate.node.metaPath))
-            continue;
-        const verifiedStale = await isStale(getScopePrefix(candidate.node), candidate.meta, watcher);
-        if (!verifiedStale && candidate.meta._generatedAt) {
-            // Bump _generatedAt so it doesn't win next cycle
-            const freshMeta = await readMetaJson(candidate.node.metaPath);
-            freshMeta._generatedAt = new Date().toISOString();
-            await writeFile(join(candidate.node.metaPath, 'meta.json'), JSON.stringify(freshMeta, null, 2));
-            releaseLock(candidate.node.metaPath);
-            if (config.skipUnchanged)
-                continue;
-            return { synthesized: false };
-        }
-        winner = candidate;
-        break;
-    }
-    if (!winner)
-        return { synthesized: false };
-    const node = winner.node;
-    try {
-        const currentMeta = await readMetaJson(node.metaPath);
-        return await synthesizeNode(node, currentMeta, config, executor, watcher, onProgress, logger);
-    }
-    finally {
-        // Step 13: Release lock
-        releaseLock(node.metaPath);
-    }
-}
-/**
- * Run a single synthesis cycle.
- *
- * 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 with a single result.
- */
-async function orchestrate(config, executor, watcher, targetPath, onProgress, logger) {
-    const result = await orchestrateOnce(config, executor, watcher, targetPath, onProgress, logger);
-    return [result];
-}
-
-/**
- * Pure phase-state transition functions.
- *
- * Implements every row of the §8 "Transitions and invalidation cascade" table.
- * No I/O — pure functions over PhaseState and documented inputs.
- *
- * @module phaseState/phaseTransitions
- */
-/**
- * Create a fresh (fully-complete) phase state.
- */
-function freshPhaseState() {
-    return { architect: 'fresh', builder: 'fresh', critic: 'fresh' };
-}
-/**
- * Create a phase state for a never-synthesized meta (all pending from architect).
- */
-function initialPhaseState() {
-    return { architect: 'pending', builder: 'stale', critic: 'stale' };
-}
-/**
- * Enforce the per-meta invariant: at most one phase is pending or running,
- * and it is the first non-fresh phase in pipeline order.
- *
- * Stale phases that become the first non-fresh phase are promoted to pending.
- */
-function enforceInvariant(state) {
-    const result = { ...state };
-    let foundNonFresh = false;
-    for (const phase of ['architect', 'builder', 'critic']) {
-        const s = result[phase];
-        if (s === 'fresh')
-            continue;
-        if (!foundNonFresh) {
-            foundNonFresh = true;
-            // First non-fresh: if stale, promote to pending
-            if (s === 'stale') {
-                result[phase] = 'pending';
-            }
-            // pending, running, failed stay as-is
-        }
-        else {
-            // Subsequent non-fresh: must not be pending or running
-            if (s === 'pending') {
-                result[phase] = 'stale';
-            }
-            // running in non-first position would be a bug, but don't mask it
-        }
-    }
-    return result;
-}
-// ── Phase success transitions ──────────────────────────────────────────
-/**
- * Architect completes successfully.
- * architect → fresh; builder → pending; critic → stale.
- */
-function architectSuccess(state) {
-    return enforceInvariant({
-        architect: 'fresh',
-        builder: state.builder === 'failed' ? 'failed' : 'pending',
-        critic: state.critic === 'fresh' ? 'stale' : state.critic,
-    });
-}
-/**
- * Builder completes successfully.
- * builder → fresh; critic → pending.
- */
-function builderSuccess(state) {
-    return enforceInvariant({
-        ...state,
-        builder: 'fresh',
-        critic: state.critic === 'failed' ? 'failed' : 'pending',
-    });
-}
-/**
- * Critic completes successfully.
- * critic → fresh. Meta becomes fully fresh.
- */
-function criticSuccess(state) {
-    return enforceInvariant({
-        ...state,
-        critic: 'fresh',
-    });
-}
-// ── Failure transition ─────────────────────────────────────────────────
-/**
- * A phase fails (error, timeout, or abort).
- * Target phase → failed; upstream and downstream unchanged.
- */
-function phaseFailed(state, phase) {
-    return enforceInvariant({
-        ...state,
-        [phase]: 'failed',
-    });
-}
-// ── Surgical retry ─────────────────────────────────────────────────────
-/**
- * Retry a failed phase: failed → pending.
- * Only valid when the phase is currently failed.
- */
-function retryPhase(state, phase) {
-    if (state[phase] !== 'failed')
-        return state;
-    return enforceInvariant({
-        ...state,
-        [phase]: 'pending',
-    });
-}
-/**
- * Retry all failed phases: each failed phase → pending.
- * Used by scheduler ticks and queue reads to auto-promote failed phases.
- */
-function retryAllFailed(state) {
-    let result = state;
-    for (const phase of ['architect', 'builder', 'critic']) {
-        if (result[phase] === 'failed') {
-            result = retryPhase(result, phase);
-        }
-    }
-    return result;
-}
-// ── Running transition ─────────────────────────────────────────────────
-/**
- * Mark a phase as running (scheduler picks it).
- */
-function phaseRunning(state, phase) {
-    return {
-        ...state,
-        [phase]: 'running',
-    };
-}
-// ── Query helpers ──────────────────────────────────────────────────────
-/**
- * Get the owed phase: first non-fresh phase in pipeline order, or null.
- */
-function getOwedPhase(state) {
-    for (const phase of ['architect', 'builder', 'critic']) {
-        if (state[phase] !== 'fresh')
-            return phase;
-    }
-    return null;
-}
-/**
- * Check if a meta is fully fresh (all phases fresh).
- */
-function isFullyFresh(state) {
-    return (state.architect === 'fresh' &&
-        state.builder === 'fresh' &&
-        state.critic === 'fresh');
-}
-/**
- * Get the scheduler priority band for a meta's owed phase.
- * 1 = critic (highest), 2 = builder, 3 = architect, null = fully fresh.
- */
-function getPriorityBand(state) {
-    const owed = getOwedPhase(state);
-    if (!owed)
-        return null;
-    if (owed === 'critic')
-        return 1;
-    if (owed === 'builder')
-        return 2;
-    return 3;
-}
-
-/**
- * Backward-compatible derivation of _phaseState from existing meta fields.
- *
- * When a meta is loaded from disk without _phaseState, this reconstructs
- * the phase state from _content, _builder, _state, _error.step, and
- * the architect-invalidating inputs.
- *
- * @module phaseState/derivePhaseState
- */
-/**
- * Derive _phaseState from existing meta fields.
- *
- * If the meta already has _phaseState, returns it as-is.
- *
- * Otherwise, reconstructs from available fields:
- * - Never-synthesized meta (no _content, no _builder): all phases start pending/stale.
- * - Errored meta: the failed phase is mapped from _error.step.
- * - Mid-cycle meta with cached _builder but no _content: builder pending.
- * - Fully-fresh meta: all phases fresh.
- * - Meta with stale architect inputs: architect pending, downstream stale.
- *
- * @param meta - The meta.json content.
- * @param inputs - Optional derivation inputs. If not provided, a simpler
- *   heuristic is used (no architect invalidation check).
- * @returns The derived PhaseState.
- */
-function derivePhaseState(meta, inputs) {
-    // Already has _phaseState — use it
-    if (meta._phaseState)
-        return meta._phaseState;
-    // Check for errors first — _error.step maps directly to failed phase
-    if (meta._error) {
-        const failedPhase = meta._error.step;
-        const state = freshPhaseState();
-        state[failedPhase] = 'failed';
-        // If architect failed and no _builder, downstream is stale
-        if (failedPhase === 'architect') {
-            if (!meta._builder) {
-                state.builder = 'stale';
-                state.critic = 'stale';
-            }
-        }
-        // If builder failed, critic is stale
-        if (failedPhase === 'builder') {
-            state.critic = 'stale';
-        }
-        return state;
-    }
-    // Never synthesized: no _content AND no _builder (and no error)
-    if (!meta._content && !meta._builder) {
-        return initialPhaseState();
-    }
-    // Check architect invalidation (when inputs are provided)
-    if (inputs) {
-        const architectInvalidated = inputs.structureChanged ||
-            inputs.steerChanged ||
-            inputs.architectChanged ||
-            inputs.crossRefsChanged ||
-            (meta._synthesisCount ?? 0) >= inputs.architectEvery;
-        if (architectInvalidated) {
-            return {
-                architect: 'pending',
-                builder: 'stale',
-                critic: 'stale',
-            };
+            }
         }
+        return { content, fields, ...(state !== undefined ? { state } : {}) };
     }
-    // Has _builder but no _content: builder is pending
-    if (meta._builder && !meta._content) {
-        return {
-            architect: 'fresh',
-            builder: 'pending',
-            critic: 'stale',
-        };
-    }
-    // Has _content but no _feedback: critic is pending
-    if (meta._content && !meta._feedback) {
-        return {
-            architect: 'fresh',
-            builder: 'fresh',
-            critic: 'pending',
-        };
+    catch {
+        return null;
     }
-    // Default: fully fresh
-    return freshPhaseState();
-}
-
-/**
- * Corpus-wide phase scheduler.
- *
- * Selects the highest-priority ready phase across all metas.
- * Priority: critic (band 1) \> builder (band 2) \> architect (band 3).
- * Tiebreak within band: weighted staleness (§3.9).
- *
- * @module phaseState/phaseScheduler
- */
-/**
- * Build phase candidates from listMetas entries.
- *
- * Derives phase state and auto-retries failed phases for each entry.
- * 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,
-    }));
-}
-/**
- * Rank all eligible phase candidates by priority.
- *
- * Filters to pending phases, computes effective staleness, and sorts by
- * band (ascending: critic first) then effective staleness (descending).
- *
- * Used by selectPhaseCandidate (returns first) and the queue route (returns all).
- */
-function rankPhaseCandidates(metas, depthWeight) {
-    // Filter to metas with a pending (scheduler-eligible) phase
-    const eligible = metas.filter((m) => {
-        if (m.locked)
-            return false;
-        if (m.disabled && !m.isOverride)
-            return false;
-        const owed = getOwedPhase(m.phaseState);
-        if (!owed)
-            return false;
-        return m.phaseState[owed] === 'pending';
-    });
-    if (eligible.length === 0)
-        return [];
-    // Compute effective staleness for tiebreaking
-    const withStaleness = computeEffectiveStaleness(eligible.map((m) => ({
-        node: m.node,
-        meta: m.meta,
-        actualStaleness: m.actualStaleness,
-    })), depthWeight);
-    // Build candidates with band info
-    const candidates = withStaleness.map((ws, i) => {
-        const m = eligible[i];
-        const owedPhase = getOwedPhase(m.phaseState);
-        return {
-            node: ws.node,
-            meta: ws.meta,
-            phaseState: m.phaseState,
-            owedPhase,
-            band: getPriorityBand(m.phaseState),
-            actualStaleness: ws.actualStaleness,
-            effectiveStaleness: ws.effectiveStaleness,
-        };
-    });
-    // Sort by band (ascending = critic first) then effective staleness (descending)
-    candidates.sort((a, b) => {
-        if (a.band !== b.band)
-            return a.band - b.band;
-        return b.effectiveStaleness - a.effectiveStaleness;
-    });
-    return candidates;
 }
 /**
- * Select the best phase candidate across the corpus.
+ * Parse critic output. The critic returns evaluation text.
  *
- * @param metas - Array of (node, meta, phaseState, stalenessSeconds) tuples.
- * @param depthWeight - Config depthWeight for staleness tiebreak.
- * @returns The winning candidate, or null if no phase is ready.
+ * @param output - Raw subprocess output.
+ * @returns The feedback string.
  */
-function selectPhaseCandidate(metas, depthWeight) {
-    return rankPhaseCandidates(metas, depthWeight)[0] ?? null;
+function parseCriticOutput(output) {
+    return output.trim();
 }
 
 /**
@@ -11105,7 +10716,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) {
@@ -11780,46 +11391,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',
-        },
     ];
 }
 /**
@@ -12063,13 +11634,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. */
@@ -12186,8 +11759,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;
@@ -12558,7 +12131,7 @@ function registerMetasUpdateRoute(app, deps) {
         const metaDir = resolveMetaDir(targetPath);
         let meta;
         try {
-            meta = (await readMetaJson(metaDir));
+            meta = await readMetaJson(metaDir);
         }
         catch {
             return reply.status(404).send({
@@ -12612,11 +12185,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({
@@ -12636,40 +12209,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);
@@ -12694,30 +12251,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: {
@@ -12791,8 +12324,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,
@@ -12987,7 +12520,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),
@@ -13001,7 +12534,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);
@@ -13010,7 +12543,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) {
@@ -13073,7 +12606,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);
@@ -13110,7 +12643,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({
@@ -13118,20 +12651,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',
@@ -13232,6 +12760,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;
@@ -13407,8 +12947,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,
@@ -13416,6 +12957,8 @@ async function startService(config, configPath) {
         watcher,
         scheduler,
         stats,
+        cache,
+        ready: false,
         executor,
         configPath,
     };
@@ -13466,6 +13009,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)');
@@ -13529,9 +13075,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({
@@ -13578,11 +13128,11 @@ async function startService(config, configPath) {
  * Parsed jeeves-meta component descriptor.
  */
 const metaDescriptor = jeevesComponentDescriptorSchema.parse({
-    name: 'meta',
+    name: META_COMPONENT.name,
     version: SERVICE_VERSION,
-    servicePackage: '@karmaniverous/jeeves-meta',
-    pluginPackage: '@karmaniverous/jeeves-meta-openclaw',
-    defaultPort: 1938,
+    servicePackage: META_COMPONENT.servicePackage,
+    pluginPackage: META_COMPONENT.pluginPackage,
+    defaultPort: META_COMPONENT.defaultPort,
     // The runtime Zod custom validator only checks for a .parse() method.
     // Use unknown cast to bridge the Zod v4 (service) → v3 (core SDK) type gap.
     configSchema: serviceConfigSchema,
@@ -13613,4 +13163,121 @@ const metaDescriptor = jeevesComponentDescriptorSchema.parse({
     customCliCommands: registerCustomCliCommands,
 });
 
-export { DEFAULT_PORT, DEFAULT_PORT_STR, GatewayExecutor, HttpWatcherClient, MAX_STALENESS_SECONDS, ProgressReporter, RESTART_REQUIRED_FIELDS, RuleRegistrar, SERVICE_NAME, SERVICE_VERSION, Scheduler, SynthesisQueue, acquireLock, actualStaleness, buildArchitectTask, buildBuilderTask, buildContextPackage, buildCriticTask, buildOwnershipTree, cleanupStaleLocks, computeEffectiveStaleness, computeEma, computeStructureHash, createLogger, createServer, createSnapshot, discoverMetas, filterInScope, findNode, formatProgressEvent, getScopePrefix, hasSteerChanged, isArchitectTriggered, isLocked, isStale, listArchiveFiles, listMetas, loadServiceConfig, mergeAndWrite, metaConfigSchema, metaDescriptor, metaErrorSchema, metaJsonSchema, migrateConfigPath, normalizePath, orchestrate, orchestratePhase, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, pruneArchive, readLatestArchive, readLockState, registerCustomCliCommands, registerRoutes, registerShutdownHandlers, releaseLock, resolveConfigPath, resolveMetaDir, runArchitect, runBuilder, runCritic, selectCandidate, serviceConfigSchema, sleepAsync as sleep, startService, toMetaError, verifyRuleApplication };
+/**
+ * Exponential moving average helper for token tracking.
+ *
+ * @module ema
+ */
+const DEFAULT_DECAY = 0.3;
+/**
+ * Compute exponential moving average.
+ *
+ * @param current - New observation.
+ * @param previous - Previous EMA value, or undefined for first observation.
+ * @param decay - Decay factor (0-1). Higher = more weight on new value. Default 0.3.
+ * @returns Updated EMA.
+ */
+function computeEma(current, previous, decay = DEFAULT_DECAY) {
+    if (previous === undefined)
+        return current;
+    return decay * current + (1 - decay) * previous;
+}
+
+/**
+ * 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. 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();
+
+export { DEFAULT_PORT, DEFAULT_PORT_STR, GatewayExecutor, HttpWatcherClient, MAX_STALENESS_SECONDS, ProgressReporter, RESTART_REQUIRED_FIELDS, RuleRegistrar, SERVICE_NAME, SERVICE_VERSION, Scheduler, SynthesisQueue, acquireLock, actualStaleness, buildArchitectTask, buildBuilderTask, buildContextPackage, buildCriticTask, buildOwnershipTree, cleanupStaleLocks, computeEffectiveStaleness, computeEma, computeStructureHash, createLogger, createServer, createSnapshot, discoverMetas, filterInScope, findNode, formatProgressEvent, getScopePrefix, hasSteerChanged, isArchitectTriggered, isLocked, isStale, listArchiveFiles, listMetas, loadServiceConfig, metaConfigSchema, metaDescriptor, metaErrorSchema, metaJsonSchema, migrateConfigPath, normalizePath, orchestratePhase, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, pruneArchive, readLatestArchive, readLockState, registerCustomCliCommands, registerRoutes, registerShutdownHandlers, releaseLock, resolveConfigPath, resolveMetaDir, runArchitect, runBuilder, runCritic, serviceConfigSchema, sleepAsync as sleep, startService, toMetaError, verifyRuleApplication };