@karmaniverous/jeeves-meta 0.15.3 → 0.15.4

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

@@ -8418,222 +8418,6 @@ function sleepAsync(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
 
-/**
- * Shared live config hot-reload support.
- *
- * Used by both file-watch reloads in bootstrap and POST /config/apply
- * via the component descriptor's onConfigApply callback.
- *
- * @module configHotReload
- */
-/**
- * Fields that require a service restart to take effect.
- *
- * Shared between the descriptor's `onConfigApply` and the file-watcher
- * hot-reload in `bootstrap.ts`.
- */
-const RESTART_REQUIRED_FIELDS = [
-    'port',
-    'watcherUrl',
-    'gatewayUrl',
-    'gatewayApiKey',
-    'defaultArchitect',
-    'defaultCritic',
-];
-let runtime = null;
-/** Register the active service runtime for config-apply hot reload. */
-function registerConfigHotReloadRuntime(nextRuntime) {
-    runtime = nextRuntime;
-}
-/** Apply hot-reloadable config changes to the live shared config object. */
-function applyHotReloadedConfig(newConfig) {
-    if (!runtime)
-        return;
-    const { config, logger, scheduler } = runtime;
-    for (const field of RESTART_REQUIRED_FIELDS) {
-        const oldVal = config[field];
-        const nextVal = newConfig[field];
-        if (oldVal !== nextVal) {
-            logger.warn({ field, oldValue: oldVal, newValue: nextVal }, 'Config field changed but requires restart to take effect');
-        }
-    }
-    if (newConfig.schedule !== config.schedule) {
-        scheduler?.updateSchedule(newConfig.schedule);
-        config.schedule = newConfig.schedule;
-        logger.info({ schedule: newConfig.schedule }, 'Schedule hot-reloaded');
-    }
-    if (newConfig.logging.level !== config.logging.level) {
-        logger.level = newConfig.logging.level;
-        config.logging.level = newConfig.logging.level;
-        logger.info({ level: newConfig.logging.level }, 'Log level hot-reloaded');
-    }
-    const restartSet = new Set(RESTART_REQUIRED_FIELDS);
-    for (const key of Object.keys(newConfig)) {
-        if (restartSet.has(key) || key === 'logging' || key === 'schedule') {
-            continue;
-        }
-        const oldVal = config[key];
-        const nextVal = newConfig[key];
-        if (JSON.stringify(oldVal) !== JSON.stringify(nextVal)) {
-            config[key] = nextVal;
-            logger.info({ field: key }, 'Config field hot-reloaded');
-        }
-    }
-}
-
-/**
- * Zod schema for jeeves-meta service configuration.
- *
- * The service config is a strict superset of the core (library-compatible) meta config.
- *
- * @module schema/config
- */
-/** Zod schema for the core (library-compatible) meta configuration. */
-const metaConfigSchema = z.object({
-    /** Watcher service base URL. */
-    watcherUrl: z.url(),
-    /** OpenClaw gateway base URL for subprocess spawning. */
-    gatewayUrl: z.url().default('http://127.0.0.1:18789'),
-    /** Optional API key for gateway authentication. */
-    gatewayApiKey: z.string().optional(),
-    /** Run architect every N cycles (per meta). */
-    architectEvery: z.number().int().min(1).default(10),
-    /** Exponent for depth weighting in staleness formula. */
-    depthWeight: z.number().min(0).default(0.5),
-    /** Maximum archive snapshots to retain per meta. */
-    maxArchive: z.number().int().min(1).default(20),
-    /** Maximum lines of context to include in subprocess prompts. */
-    maxLines: z.number().int().min(50).default(500),
-    /** Architect subprocess timeout in seconds. */
-    architectTimeout: z.number().int().min(30).default(180),
-    /** Builder subprocess timeout in seconds. */
-    builderTimeout: z.number().int().min(60).default(360),
-    /** Critic subprocess timeout in seconds. */
-    criticTimeout: z.number().int().min(30).default(240),
-    /** Thinking level for spawned synthesis sessions. */
-    thinking: z.string().default('low'),
-    /** Resolved architect system prompt text. Falls back to built-in default. */
-    defaultArchitect: z.string().optional(),
-    /** Resolved critic system prompt text. Falls back to built-in default. */
-    defaultCritic: z.string().optional(),
-    /** Skip unchanged candidates, bump _generatedAt. */
-    skipUnchanged: z.boolean().default(true),
-    /** Watcher metadata properties applied to live .meta/meta.json files. */
-    metaProperty: z.record(z.string(), z.unknown()).default({ _meta: 'current' }),
-    /** Watcher metadata properties applied to archive snapshots. */
-    metaArchiveProperty: z
-        .record(z.string(), z.unknown())
-        .default({ _meta: 'archive' }),
-});
-/** Zod schema for logging configuration. */
-const loggingSchema = z.object({
-    /** Log level. */
-    level: z.string().default('info'),
-    /** Optional file path for log output. */
-    file: z.string().optional(),
-});
-/** Zod schema for a single auto-seed policy rule. */
-const autoSeedRuleSchema = z.object({
-    /** Glob pattern matched against watcher walk results. */
-    match: z.string(),
-    /** Optional steering prompt for seeded metas. */
-    steer: z.string().optional(),
-    /** Optional cross-references for seeded metas. */
-    crossRefs: z.array(z.string()).optional(),
-});
-/** Zod schema for jeeves-meta service configuration (superset of MetaConfig). */
-const serviceConfigSchema = metaConfigSchema.extend({
-    /** HTTP port for the service (default: 1938). */
-    port: z.number().int().min(1).max(65535).default(1938),
-    /** Cron schedule for synthesis cycles (default: every 30 min). */
-    schedule: z.string().default('*/30 * * * *'),
-    /** Messaging channel name (e.g. 'slack'). Legacy: also used as target if reportTarget is unset. */
-    reportChannel: z.string().optional(),
-    /** Channel/user ID to send progress messages to. */
-    reportTarget: z.string().optional(),
-    /** Optional base URL for the service, used to construct entity links in progress reports. */
-    serverBaseUrl: z.string().optional(),
-    /** Interval in ms for periodic watcher health check. 0 = disabled. Default: 60000. */
-    watcherHealthIntervalMs: z.number().int().min(0).default(60_000),
-    /** Logging configuration. */
-    logging: loggingSchema.default(() => loggingSchema.parse({})),
-    /**
-     * Auto-seed policy: declarative rules for auto-creating .meta/ directories.
-     * Rules are evaluated in order; last match wins for steer/crossRefs.
-     */
-    autoSeed: z.array(autoSeedRuleSchema).optional().default([]),
-});
-
-/**
- * Load and resolve jeeves-meta service config.
- *
- * Supports \@file: indirection and environment-variable substitution (dollar-brace pattern).
- *
- * @module configLoader
- */
-/**
- * Deep-walk a value, replacing `\${VAR\}` patterns with process.env values.
- *
- * @param value - Arbitrary JSON-compatible value.
- * @returns Value with env-var placeholders resolved.
- */
-function substituteEnvVars(value) {
-    if (typeof value === 'string') {
-        return value.replace(/\$\{([^}]+)\}/g, (_match, name) => {
-            const envVal = process.env[name];
-            if (envVal === undefined) {
-                throw new Error(`Environment variable ${name} is not set`);
-            }
-            return envVal;
-        });
-    }
-    if (Array.isArray(value)) {
-        return value.map(substituteEnvVars);
-    }
-    if (value !== null && typeof value === 'object') {
-        const result = {};
-        for (const [key, val] of Object.entries(value)) {
-            result[key] = substituteEnvVars(val);
-        }
-        return result;
-    }
-    return value;
-}
-/**
- * Resolve \@file: references in a config value.
- *
- * @param value - String value that may start with "\@file:".
- * @param baseDir - Base directory for resolving relative paths.
- * @returns The resolved string (file contents or original value).
- */
-function resolveFileRef(value, baseDir) {
-    if (!value.startsWith('@file:'))
-        return value;
-    const filePath = join(baseDir, value.slice(6));
-    return readFileSync(filePath, 'utf8');
-}
-/**
- * Load service config from a JSON file.
- *
- * Resolves \@file: references for defaultArchitect and defaultCritic,
- * and substitutes environment-variable placeholders throughout.
- *
- * @param configPath - Path to config JSON file.
- * @returns Validated ServiceConfig.
- */
-function loadServiceConfig(configPath) {
-    const rawText = readFileSync(configPath, 'utf8');
-    const raw = substituteEnvVars(JSON.parse(rawText));
-    const baseDir = dirname(configPath);
-    if (typeof raw['defaultArchitect'] === 'string') {
-        raw['defaultArchitect'] = resolveFileRef(raw['defaultArchitect'], baseDir);
-    }
-    if (typeof raw['defaultCritic'] === 'string') {
-        raw['defaultCritic'] = resolveFileRef(raw['defaultCritic'], baseDir);
-    }
-    return serviceConfigSchema.parse(raw);
-}
-
 /**
  * Compute summary statistics from an array of MetaEntry objects.
  *
@@ -9290,6 +9074,263 @@ function getDeltaFiles(generatedAt, scopeFiles) {
     return filterModifiedAfter(scopeFiles, new Date(generatedAt).getTime());
 }
 
+/**
+ * In-memory cache for listMetas results with TTL and concurrent refresh guard.
+ *
+ * @module cache
+ */
+const TTL_MS = 60_000;
+/**
+ * Caches listMetas results to avoid expensive repeated filesystem walks.
+ * Supports concurrent refresh coalescing and manual invalidation.
+ */
+class MetaCache {
+    result = null;
+    updatedAt = 0;
+    refreshPromise = null;
+    /** Get cached result or refresh if stale. */
+    async get(config, watcher) {
+        if (this.result && Date.now() - this.updatedAt < TTL_MS) {
+            return this.result;
+        }
+        return this.refresh(config, watcher);
+    }
+    /** Force-expire the cache so next get() triggers a refresh. */
+    invalidate() {
+        this.updatedAt = 0;
+    }
+    async refresh(config, watcher) {
+        if (this.refreshPromise)
+            return this.refreshPromise;
+        this.refreshPromise = listMetas(config, watcher)
+            .then((result) => {
+            this.result = result;
+            this.updatedAt = Date.now();
+            return result;
+        })
+            .finally(() => {
+            this.refreshPromise = null;
+        });
+        return this.refreshPromise;
+    }
+}
+
+/**
+ * Shared live config hot-reload support.
+ *
+ * Used by both file-watch reloads in bootstrap and POST /config/apply
+ * via the component descriptor's onConfigApply callback.
+ *
+ * @module configHotReload
+ */
+/**
+ * Fields that require a service restart to take effect.
+ *
+ * Shared between the descriptor's `onConfigApply` and the file-watcher
+ * hot-reload in `bootstrap.ts`.
+ */
+const RESTART_REQUIRED_FIELDS = [
+    'port',
+    'watcherUrl',
+    'gatewayUrl',
+    'gatewayApiKey',
+    'defaultArchitect',
+    'defaultCritic',
+];
+let runtime = null;
+/** Register the active service runtime for config-apply hot reload. */
+function registerConfigHotReloadRuntime(nextRuntime) {
+    runtime = nextRuntime;
+}
+/** Apply hot-reloadable config changes to the live shared config object. */
+function applyHotReloadedConfig(newConfig) {
+    if (!runtime)
+        return;
+    const { config, logger, scheduler } = runtime;
+    for (const field of RESTART_REQUIRED_FIELDS) {
+        const oldVal = config[field];
+        const nextVal = newConfig[field];
+        if (oldVal !== nextVal) {
+            logger.warn({ field, oldValue: oldVal, newValue: nextVal }, 'Config field changed but requires restart to take effect');
+        }
+    }
+    if (newConfig.schedule !== config.schedule) {
+        scheduler?.updateSchedule(newConfig.schedule);
+        config.schedule = newConfig.schedule;
+        logger.info({ schedule: newConfig.schedule }, 'Schedule hot-reloaded');
+    }
+    if (newConfig.logging.level !== config.logging.level) {
+        logger.level = newConfig.logging.level;
+        config.logging.level = newConfig.logging.level;
+        logger.info({ level: newConfig.logging.level }, 'Log level hot-reloaded');
+    }
+    const restartSet = new Set(RESTART_REQUIRED_FIELDS);
+    for (const key of Object.keys(newConfig)) {
+        if (restartSet.has(key) || key === 'logging' || key === 'schedule') {
+            continue;
+        }
+        const oldVal = config[key];
+        const nextVal = newConfig[key];
+        if (JSON.stringify(oldVal) !== JSON.stringify(nextVal)) {
+            config[key] = nextVal;
+            logger.info({ field: key }, 'Config field hot-reloaded');
+        }
+    }
+}
+
+/**
+ * Zod schema for jeeves-meta service configuration.
+ *
+ * The service config is a strict superset of the core (library-compatible) meta config.
+ *
+ * @module schema/config
+ */
+/** Zod schema for the core (library-compatible) meta configuration. */
+const metaConfigSchema = z.object({
+    /** Watcher service base URL. */
+    watcherUrl: z.url(),
+    /** OpenClaw gateway base URL for subprocess spawning. */
+    gatewayUrl: z.url().default('http://127.0.0.1:18789'),
+    /** Optional API key for gateway authentication. */
+    gatewayApiKey: z.string().optional(),
+    /** Run architect every N cycles (per meta). */
+    architectEvery: z.number().int().min(1).default(10),
+    /** Exponent for depth weighting in staleness formula. */
+    depthWeight: z.number().min(0).default(0.5),
+    /** Maximum archive snapshots to retain per meta. */
+    maxArchive: z.number().int().min(1).default(20),
+    /** Maximum lines of context to include in subprocess prompts. */
+    maxLines: z.number().int().min(50).default(500),
+    /** Architect subprocess timeout in seconds. */
+    architectTimeout: z.number().int().min(30).default(180),
+    /** Builder subprocess timeout in seconds. */
+    builderTimeout: z.number().int().min(60).default(360),
+    /** Critic subprocess timeout in seconds. */
+    criticTimeout: z.number().int().min(30).default(240),
+    /** Thinking level for spawned synthesis sessions. */
+    thinking: z.string().default('low'),
+    /** Resolved architect system prompt text. Falls back to built-in default. */
+    defaultArchitect: z.string().optional(),
+    /** Resolved critic system prompt text. Falls back to built-in default. */
+    defaultCritic: z.string().optional(),
+    /** Skip unchanged candidates, bump _generatedAt. */
+    skipUnchanged: z.boolean().default(true),
+    /** Watcher metadata properties applied to live .meta/meta.json files. */
+    metaProperty: z.record(z.string(), z.unknown()).default({ _meta: 'current' }),
+    /** Watcher metadata properties applied to archive snapshots. */
+    metaArchiveProperty: z
+        .record(z.string(), z.unknown())
+        .default({ _meta: 'archive' }),
+});
+/** Zod schema for logging configuration. */
+const loggingSchema = z.object({
+    /** Log level. */
+    level: z.string().default('info'),
+    /** Optional file path for log output. */
+    file: z.string().optional(),
+});
+/** Zod schema for a single auto-seed policy rule. */
+const autoSeedRuleSchema = z.object({
+    /** Glob pattern matched against watcher walk results. */
+    match: z.string(),
+    /** Optional steering prompt for seeded metas. */
+    steer: z.string().optional(),
+    /** Optional cross-references for seeded metas. */
+    crossRefs: z.array(z.string()).optional(),
+});
+/** Zod schema for jeeves-meta service configuration (superset of MetaConfig). */
+const serviceConfigSchema = metaConfigSchema.extend({
+    /** HTTP port for the service (default: 1938). */
+    port: z.number().int().min(1).max(65535).default(1938),
+    /** Cron schedule for synthesis cycles (default: every 30 min). */
+    schedule: z.string().default('*/30 * * * *'),
+    /** Messaging channel name (e.g. 'slack'). Legacy: also used as target if reportTarget is unset. */
+    reportChannel: z.string().optional(),
+    /** Channel/user ID to send progress messages to. */
+    reportTarget: z.string().optional(),
+    /** Optional base URL for the service, used to construct entity links in progress reports. */
+    serverBaseUrl: z.string().optional(),
+    /** Interval in ms for periodic watcher health check. 0 = disabled. Default: 60000. */
+    watcherHealthIntervalMs: z.number().int().min(0).default(60_000),
+    /** Logging configuration. */
+    logging: loggingSchema.default(() => loggingSchema.parse({})),
+    /**
+     * Auto-seed policy: declarative rules for auto-creating .meta/ directories.
+     * Rules are evaluated in order; last match wins for steer/crossRefs.
+     */
+    autoSeed: z.array(autoSeedRuleSchema).optional().default([]),
+});
+
+/**
+ * Load and resolve jeeves-meta service config.
+ *
+ * Supports \@file: indirection and environment-variable substitution (dollar-brace pattern).
+ *
+ * @module configLoader
+ */
+/**
+ * Deep-walk a value, replacing `\${VAR\}` patterns with process.env values.
+ *
+ * @param value - Arbitrary JSON-compatible value.
+ * @returns Value with env-var placeholders resolved.
+ */
+function substituteEnvVars(value) {
+    if (typeof value === 'string') {
+        return value.replace(/\$\{([^}]+)\}/g, (_match, name) => {
+            const envVal = process.env[name];
+            if (envVal === undefined) {
+                throw new Error(`Environment variable ${name} is not set`);
+            }
+            return envVal;
+        });
+    }
+    if (Array.isArray(value)) {
+        return value.map(substituteEnvVars);
+    }
+    if (value !== null && typeof value === 'object') {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = substituteEnvVars(val);
+        }
+        return result;
+    }
+    return value;
+}
+/**
+ * Resolve \@file: references in a config value.
+ *
+ * @param value - String value that may start with "\@file:".
+ * @param baseDir - Base directory for resolving relative paths.
+ * @returns The resolved string (file contents or original value).
+ */
+function resolveFileRef(value, baseDir) {
+    if (!value.startsWith('@file:'))
+        return value;
+    const filePath = join(baseDir, value.slice(6));
+    return readFileSync(filePath, 'utf8');
+}
+/**
+ * Load service config from a JSON file.
+ *
+ * Resolves \@file: references for defaultArchitect and defaultCritic,
+ * and substitutes environment-variable placeholders throughout.
+ *
+ * @param configPath - Path to config JSON file.
+ * @returns Validated ServiceConfig.
+ */
+function loadServiceConfig(configPath) {
+    const rawText = readFileSync(configPath, 'utf8');
+    const raw = substituteEnvVars(JSON.parse(rawText));
+    const baseDir = dirname(configPath);
+    if (typeof raw['defaultArchitect'] === 'string') {
+        raw['defaultArchitect'] = resolveFileRef(raw['defaultArchitect'], baseDir);
+    }
+    if (typeof raw['defaultCritic'] === 'string') {
+        raw['defaultCritic'] = resolveFileRef(raw['defaultCritic'], baseDir);
+    }
+    return serviceConfigSchema.parse(raw);
+}
+
 /**
  * Error thrown when a spawned subprocess is aborted via AbortController.
  *
@@ -9388,21 +9429,29 @@ class GatewayExecutor {
         }
         return data;
     }
-    /** Look up totalTokens for a session via sessions_list. */
-    async getSessionTokens(sessionKey) {
+    /** Look up session metadata (tokens, completion status) via sessions_list. */
+    async getSessionInfo(sessionKey) {
         try {
             const result = await this.invoke('sessions_list', {
-                limit: 20,
+                limit: 200,
                 messageLimit: 0,
             });
             const sessions = (result.result?.details?.sessions ??
                 result.result?.sessions ??
                 []);
             const match = sessions.find((s) => s.key === sessionKey);
-            return match?.totalTokens ?? undefined;
+            if (!match) {
+                // Session absent from list — likely cleaned up after completion.
+                // With limit=200 this is reliable; a false positive here only
+                // means we read the output file slightly early (still correct
+                // if the file exists).
+                return { completed: true };
+            }
+            const done = match.status === 'completed' || match.status === 'done';
+            return { tokens: match.totalTokens, completed: done };
         }
         catch {
-            return undefined;
+            return { completed: false };
         }
     }
     /** Whether this executor has been aborted by the operator. */
@@ -9468,48 +9517,53 @@ class GatewayExecutor {
                     historyResult.result?.messages ??
                     [];
                 const msgArray = messages;
+                // Check 1: terminal stop reason in history
+                let historyDone = false;
                 if (msgArray.length > 0) {
                     const lastMsg = msgArray[msgArray.length - 1];
-                    // Complete when last message is assistant with a terminal stop reason
                     if (lastMsg.role === 'assistant' &&
                         lastMsg.stopReason &&
                         lastMsg.stopReason !== 'toolUse' &&
                         lastMsg.stopReason !== 'error') {
-                        // Fetch token usage from session metadata
-                        const tokens = await this.getSessionTokens(sessionKey);
-                        // Read output from file (sub-agent wrote it via Write tool)
-                        if (existsSync(outputPath)) {
+                        historyDone = true;
+                    }
+                }
+                // Check 2: session completion status via sessions_list
+                const sessionInfo = await this.getSessionInfo(sessionKey);
+                if (historyDone || sessionInfo.completed) {
+                    const tokens = sessionInfo.tokens;
+                    // Read output from file (sub-agent wrote it via Write tool)
+                    if (existsSync(outputPath)) {
+                        try {
+                            const output = readFileSync(outputPath, 'utf8');
+                            return { output, tokens };
+                        }
+                        finally {
                             try {
-                                const output = readFileSync(outputPath, 'utf8');
-                                return { output, tokens };
+                                unlinkSync(outputPath);
                             }
-                            finally {
-                                try {
-                                    unlinkSync(outputPath);
-                                }
-                                catch {
-                                    /* cleanup best-effort */
-                                }
+                            catch {
+                                /* cleanup best-effort */
                             }
                         }
-                        // Fallback: extract from message content if file wasn't written
-                        for (let i = msgArray.length - 1; i >= 0; i--) {
-                            const msg = msgArray[i];
-                            if (msg.role === 'assistant' && msg.content) {
-                                const text = typeof msg.content === 'string'
+                    }
+                    // Fallback: extract from message content if file wasn't written
+                    for (let i = msgArray.length - 1; i >= 0; i--) {
+                        const msg = msgArray[i];
+                        if (msg.role === 'assistant' && msg.content) {
+                            const text = typeof msg.content === 'string'
+                                ? msg.content
+                                : Array.isArray(msg.content)
                                     ? msg.content
-                                    : Array.isArray(msg.content)
-                                        ? msg.content
-                                            .filter((b) => b.type === 'text' && b.text)
-                                            .map((b) => b.text)
-                                            .join('\n')
-                                        : '';
-                                if (text)
-                                    return { output: text, tokens };
-                            }
+                                        .filter((b) => b.type === 'text' && b.text)
+                                        .map((b) => b.text)
+                                        .join('\n')
+                                    : '';
+                            if (text)
+                                return { output: text, tokens };
                         }
-                        return { output: '', tokens };
                     }
+                    return { output: '', tokens };
                 }
             }
             catch {
@@ -9872,6 +9926,7 @@ async function buildContextPackage(node, meta, watcher, logger) {
  *
  * @module orchestrator/buildTask
  */
+Handlebars.registerHelper('gt', (a, b) => a > b);
 /** Build the template context from synthesis inputs. */
 function buildTemplateContext(ctx, meta, config) {
     return {
@@ -10026,134 +10081,6 @@ function buildCriticTask(ctx, meta, config) {
     return compileTemplate(sections.join('\n'), buildTemplateContext(ctx, meta, config));
 }
 
-/**
- * Structured error from a synthesis step failure.
- *
- * @module schema/error
- */
-/** Zod schema for synthesis step errors. */
-const metaErrorSchema = z.object({
-    /** Which step failed: 'architect', 'builder', or 'critic'. */
-    step: z.enum(['architect', 'builder', 'critic']),
-    /** Error classification code. */
-    code: z.string(),
-    /** Human-readable error message. */
-    message: z.string(),
-});
-
-/**
- * Zod schema for .meta/meta.json files.
- *
- * Reserved properties are underscore-prefixed and engine-managed.
- * All other keys are open schema (builder output).
- *
- * @module schema/meta
- */
-/** Valid states for a synthesis phase. */
-const phaseStatuses = [
-    'fresh',
-    'stale',
-    'pending',
-    'running',
-    'failed',
-];
-/** Zod schema for a per-phase status value. */
-const phaseStatusSchema = z.enum(phaseStatuses);
-/** Zod schema for the per-meta phase state record. */
-const phaseStateSchema = z.object({
-    architect: phaseStatusSchema,
-    builder: phaseStatusSchema,
-    critic: phaseStatusSchema,
-});
-/** Zod schema for the reserved (underscore-prefixed) meta.json properties. */
-z
-    .object({
-    /** Stable identity. Auto-generated on first synthesis if not provided. */
-    _id: z.uuid().optional(),
-    /** Human-provided steering prompt. Optional. */
-    _steer: z.string().optional(),
-    /**
-     * Explicit cross-references to other meta owner paths.
-     * Referenced metas' _content is included as architect/builder context.
-     */
-    _crossRefs: z.array(z.string()).optional(),
-    /** Architect system prompt used this turn. Defaults from config. */
-    _architect: z.string().optional(),
-    /**
-     * Task brief generated by the architect. Cached and reused across cycles;
-     * regenerated only when triggered.
-     */
-    _builder: z.string().optional(),
-    /** Critic system prompt used this turn. Defaults from config. */
-    _critic: z.string().optional(),
-    /** Timestamp of last synthesis. ISO 8601. */
-    _generatedAt: z.iso.datetime().optional(),
-    /** Narrative synthesis output. Rendered by watcher for embedding. */
-    _content: z.string().optional(),
-    /**
-     * Hash of sorted file listing in scope. Detects directory structure
-     * changes that trigger an architect re-run.
-     */
-    _structureHash: z.string().optional(),
-    /**
-     * Cycles since last architect run. Reset to 0 when architect runs.
-     * Used with architectEvery to trigger periodic re-prompting.
-     */
-    _synthesisCount: z.number().int().min(0).optional(),
-    /** Critic evaluation of the last synthesis. */
-    _feedback: z.string().optional(),
-    /**
-     * Present and true on archive snapshots. Distinguishes live vs. archived
-     * metas.
-     */
-    _archived: z.boolean().optional(),
-    /** Timestamp when this snapshot was archived. ISO 8601. */
-    _archivedAt: z.iso.datetime().optional(),
-    /**
-     * Scheduling priority. Higher = updates more often. Negative allowed;
-     * normalized to min 0 at scheduling time.
-     */
-    _depth: z.number().optional(),
-    /**
-     * Emphasis multiplier for depth weighting in scheduling.
-     * Default 1. Higher values increase this meta's scheduling priority
-     * relative to its depth. Set to 0.5 to halve the depth effect,
-     * 2 to double it, 0 to ignore depth entirely for this meta.
-     */
-    _emphasis: z.number().min(0).optional(),
-    /** Token count from last architect subprocess call. */
-    _architectTokens: z.number().int().optional(),
-    /** Token count from last builder subprocess call. */
-    _builderTokens: z.number().int().optional(),
-    /** Token count from last critic subprocess call. */
-    _criticTokens: z.number().int().optional(),
-    /** Exponential moving average of architect token usage (decay 0.3). */
-    _architectTokensAvg: z.number().optional(),
-    /** Exponential moving average of builder token usage (decay 0.3). */
-    _builderTokensAvg: z.number().optional(),
-    /** Exponential moving average of critic token usage (decay 0.3). */
-    _criticTokensAvg: z.number().optional(),
-    /**
-     * Opaque state carried across synthesis cycles for progressive work.
-     * Set by the builder, passed back as context on next cycle.
-     */
-    _state: z.unknown().optional(),
-    /**
-     * Structured error from last cycle. Present when a step failed.
-     * Cleared on successful cycle.
-     */
-    _error: metaErrorSchema.optional(),
-    /** When true, this meta is skipped during staleness scheduling. Manual trigger still works. */
-    _disabled: z.boolean().optional(),
-    /**
-     * Per-phase state machine record. Engine-managed.
-     * Keyed by phase name (architect, builder, critic) with status values.
-     * Persisted to survive ticks; derived on first load for back-compat.
-     */
-    _phaseState: phaseStateSchema.optional(),
-})
-    .loose();
-
 /**
  * Build a minimal MetaNode from a known meta path using watcher walk.
  *
@@ -10215,222 +10142,6 @@ async function buildMinimalNode(metaPath, watcher) {
     return node;
 }
 
-/**
- * Weighted staleness formula for candidate selection.
- *
- * effectiveStaleness = actualStaleness * (normalizedDepth + 1) ^ (depthWeight * emphasis)
- *
- * @module scheduling/weightedFormula
- */
-/**
- * Compute effective staleness for a set of candidates.
- *
- * Normalizes depths so the minimum becomes 0, then applies the formula:
- * effectiveStaleness = actualStaleness * (normalizedDepth + 1) ^ (depthWeight * emphasis)
- *
- * Per-meta _emphasis (default 1) multiplies depthWeight, allowing individual
- * metas to tune how much their tree position affects scheduling.
- *
- * @param candidates - Array of \{ node, meta, actualStaleness \}.
- * @param depthWeight - Exponent for depth weighting (0 = pure staleness).
- * @returns Same array with effectiveStaleness computed.
- */
-function computeEffectiveStaleness(candidates, depthWeight) {
-    if (candidates.length === 0)
-        return [];
-    // Get depth for each candidate: use _depth override or tree depth
-    const depths = candidates.map((c) => c.meta._depth ?? c.node.treeDepth);
-    // Normalize: shift so minimum becomes 0
-    const minDepth = Math.min(...depths);
-    const normalizedDepths = depths.map((d) => Math.max(0, d - minDepth));
-    return candidates.map((c, i) => {
-        const emphasis = c.meta._emphasis ?? 1;
-        return {
-            ...c,
-            effectiveStaleness: c.actualStaleness *
-                Math.pow(normalizedDepths[i] + 1, depthWeight * emphasis),
-        };
-    });
-}
-
-/**
- * Select the best synthesis candidate from stale metas.
- *
- * Picks the meta with highest effective staleness.
- *
- * @module scheduling/selectCandidate
- */
-/**
- * Select the candidate with the highest effective staleness.
- *
- * @param candidates - Array of candidates with computed effective staleness.
- * @returns The winning candidate, or null if no candidates.
- */
-function selectCandidate(candidates) {
-    if (candidates.length === 0)
-        return null;
-    let best = candidates[0];
-    for (let i = 1; i < candidates.length; i++) {
-        if (candidates[i].effectiveStaleness > best.effectiveStaleness) {
-            best = candidates[i];
-        }
-    }
-    return best;
-}
-/**
- * Extract stale candidates from a list and return the stalest path.
- *
- * Consolidates the repeated pattern of:
- *   filter → computeEffectiveStaleness → selectCandidate → return path
- *
- * @param candidates - Array with node, meta, and stalenessSeconds.
- * @param depthWeight - Depth weighting exponent from config.
- * @returns The stalest candidate's metaPath, or null if none are stale.
- */
-function discoverStalestPath(candidates, depthWeight) {
-    const weighted = computeEffectiveStaleness(candidates, depthWeight);
-    const winner = selectCandidate(weighted);
-    return winner?.node.metaPath ?? null;
-}
-
-/**
- * Shared error utilities.
- *
- * @module errors
- */
-/**
- * Wrap an unknown caught value into a MetaError.
- *
- * @param step - Which synthesis step failed.
- * @param err - The caught error value.
- * @param code - Error classification code.
- * @returns A structured MetaError.
- */
-function toMetaError(step, err, code = 'FAILED') {
-    return {
-        step,
-        code,
-        message: err instanceof Error ? err.message : String(err),
-    };
-}
-
-/**
- * Compute a structure hash from a sorted file listing.
- *
- * Used to detect when directory structure changes, triggering
- * an architect re-run.
- *
- * @module structureHash
- */
-/**
- * Compute a SHA-256 hash of a sorted file listing.
- *
- * @param filePaths - Array of file paths in scope.
- * @returns Hex-encoded SHA-256 hash of the sorted, newline-joined paths.
- */
-function computeStructureHash(filePaths) {
-    const sorted = [...filePaths].sort();
-    const content = sorted.join('\n');
-    return createHash('sha256').update(content).digest('hex');
-}
-
-/**
- * Parse subprocess outputs for each synthesis step.
- *
- * - Architect: returns text \> _builder
- * - Builder: returns JSON \> _content + structured fields
- * - Critic: returns text \> _feedback
- *
- * @module orchestrator/parseOutput
- */
-/**
- * Parse architect output. The architect returns a task brief as text.
- *
- * @param output - Raw subprocess output.
- * @returns The task brief string.
- */
-function parseArchitectOutput(output) {
-    return output.trim();
-}
-/**
- * Parse builder output. The builder returns JSON with _content and optional fields.
- *
- * Attempts JSON parse first. If that fails, treats the entire output as _content.
- *
- * @param output - Raw subprocess output.
- * @returns Parsed builder output with content and structured fields.
- */
-function parseBuilderOutput(output) {
-    const trimmed = output.trim();
-    // Strategy 1: Try to parse the entire output as JSON directly
-    const direct = tryParseJson(trimmed);
-    if (direct)
-        return direct;
-    // Strategy 2: Try all fenced code blocks (last match first — models often narrate then output)
-    const fencePattern = /```(?:json)?\s*([\s\S]*?)```/g;
-    const fenceMatches = [];
-    let match;
-    while ((match = fencePattern.exec(trimmed)) !== null) {
-        fenceMatches.push(match[1].trim());
-    }
-    // Try last fence first (most likely to be the actual output)
-    for (let i = fenceMatches.length - 1; i >= 0; i--) {
-        const result = tryParseJson(fenceMatches[i]);
-        if (result)
-            return result;
-    }
-    // Strategy 3: Find outermost { ... } braces
-    const firstBrace = trimmed.indexOf('{');
-    const lastBrace = trimmed.lastIndexOf('}');
-    if (firstBrace !== -1 && lastBrace > firstBrace) {
-        const result = tryParseJson(trimmed.substring(firstBrace, lastBrace + 1));
-        if (result)
-            return result;
-    }
-    // Fallback: treat entire output as content
-    return { content: trimmed, fields: {} };
-}
-/** Try to parse a string as JSON and extract builder output fields. */
-function tryParseJson(str) {
-    try {
-        const raw = JSON.parse(str);
-        if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
-            return null;
-        }
-        const parsed = raw;
-        // Extract _content
-        const content = typeof parsed['_content'] === 'string'
-            ? parsed['_content']
-            : typeof parsed['content'] === 'string'
-                ? parsed['content']
-                : null;
-        if (content === null)
-            return null;
-        // Extract _state (the ONLY underscore key the builder is allowed to set)
-        const state = '_state' in parsed ? parsed['_state'] : undefined;
-        // Extract non-underscore fields
-        const fields = {};
-        for (const [key, value] of Object.entries(parsed)) {
-            if (!key.startsWith('_') && key !== 'content') {
-                fields[key] = value;
-            }
-        }
-        return { content, fields, ...(state !== undefined ? { state } : {}) };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Parse critic output. The critic returns evaluation text.
- *
- * @param output - Raw subprocess output.
- * @returns The feedback string.
- */
-function parseCriticOutput(output) {
-    return output.trim();
-}
-
 /**
  * Pure phase-state transition functions.
  *
@@ -10480,7 +10191,42 @@ function enforceInvariant(state) {
             // running in non-first position would be a bug, but don't mask it
         }
     }
-    return result;
+    return result;
+}
+// ── Invalidation cascades ──────────────────────────────────────────────
+/**
+ * Architect invalidated: architect → pending; builder, critic → stale.
+ * Triggers: _structureHash change, _steer change, _architect change,
+ * _crossRefs declaration change, _synthesisCount \>= architectEvery.
+ */
+function invalidateArchitect(state) {
+    return enforceInvariant({
+        architect: state.architect === 'failed' ? 'failed' : 'pending',
+        builder: state.builder === 'fresh' ? 'stale' : state.builder,
+        critic: state.critic === 'fresh' ? 'stale' : state.critic,
+    });
+}
+/**
+ * Builder invalidated (scope mtime or cross-ref _content change):
+ * builder → pending; critic → stale.
+ * Only applies when architect is fresh; otherwise, builder stays stale.
+ */
+function invalidateBuilder(state) {
+    if (state.architect !== 'fresh') {
+        // Architect is not fresh — builder stays stale (or whatever it is)
+        return enforceInvariant({
+            ...state,
+            builder: state.builder === 'fresh' || state.builder === 'stale'
+                ? 'stale'
+                : state.builder,
+            critic: state.critic === 'fresh' ? 'stale' : state.critic,
+        });
+    }
+    return enforceInvariant({
+        ...state,
+        builder: state.builder === 'failed' ? 'failed' : 'pending',
+        critic: state.critic === 'fresh' ? 'stale' : state.critic,
+    });
 }
 // ── Phase success transitions ──────────────────────────────────────────
 /**
@@ -10650,7 +10396,9 @@ function derivePhaseState(meta, inputs) {
     }
     // Check architect invalidation (when inputs are provided)
     if (inputs) {
-        const architectInvalidated = inputs.structureChanged ||
+        // Progressive metas: structure changes invalidate builder, not architect
+        const structureInvalidatesArchitect = inputs.structureChanged && meta._state === undefined;
+        const architectInvalidated = structureInvalidatesArchitect ||
             inputs.steerChanged ||
             inputs.architectChanged ||
             inputs.crossRefsChanged ||
@@ -10662,6 +10410,14 @@ function derivePhaseState(meta, inputs) {
                 critic: 'stale',
             };
         }
+        // Progressive meta with structure change: builder-only invalidation
+        if (inputs.structureChanged && meta._state !== undefined) {
+            return {
+                architect: 'fresh',
+                builder: 'pending',
+                critic: 'stale',
+            };
+        }
     }
     // Has _builder but no _content: builder is pending
     if (meta._builder && !meta._content) {
@@ -10683,6 +10439,154 @@ function derivePhaseState(meta, inputs) {
     return freshPhaseState();
 }
 
+/**
+ * Compute a structure hash from a sorted file listing.
+ *
+ * Used to detect when directory structure changes, triggering
+ * an architect re-run.
+ *
+ * @module structureHash
+ */
+/**
+ * Compute a SHA-256 hash of a sorted file listing.
+ *
+ * @param filePaths - Array of file paths in scope.
+ * @returns Hex-encoded SHA-256 hash of the sorted, newline-joined paths.
+ */
+function computeStructureHash(filePaths) {
+    const sorted = [...filePaths].sort();
+    const content = sorted.join('\n');
+    return createHash('sha256').update(content).digest('hex');
+}
+
+/**
+ * Per-tick invalidation pass.
+ *
+ * Computes architect-invalidating and builder-invalidating inputs for a meta,
+ * then applies the cascade to update _phaseState.
+ *
+ * @module phaseState/invalidate
+ */
+/**
+ * Compute invalidation inputs and apply cascade for a single meta.
+ *
+ * @param meta - Current meta.json content with existing _phaseState.
+ * @param scopeFiles - Sorted file list from scope.
+ * @param config - MetaConfig for architectEvery.
+ * @param node - MetaNode for archive access.
+ * @param crossRefMetas - Map of cross-ref owner paths to their current _content.
+ * @param archiveCrossRefContent - Map of cross-ref owner paths to their archived _content.
+ * @returns Updated phase state and invalidation details.
+ */
+async function computeInvalidation(meta, scopeFiles, config, node, crossRefMetas, archiveCrossRefContent) {
+    let phaseState = meta._phaseState ?? {
+        architect: 'fresh',
+        builder: 'fresh',
+        critic: 'fresh',
+    };
+    // ── Architect-level inputs ──
+    const structureHash = computeStructureHash(scopeFiles);
+    const structureChanged = structureHash !== meta._structureHash;
+    const latestArchive = await readLatestArchive(node.metaPath);
+    const steerChanged = hasSteerChanged(meta._steer, latestArchive?._steer, Boolean(latestArchive));
+    // _architect change: compare current vs. archive
+    const architectChanged = latestArchive
+        ? (meta._architect ?? '') !== (latestArchive._architect ?? '')
+        : Boolean(meta._architect);
+    // _crossRefs declaration change
+    const currentRefs = (meta._crossRefs ?? []).slice().sort().join(',');
+    const archiveRefs = (latestArchive?._crossRefs ?? [])
+        .slice()
+        .sort()
+        .join(',');
+    const crossRefsDeclChanged = latestArchive
+        ? currentRefs !== archiveRefs
+        : currentRefs.length > 0;
+    const architectInvalidators = [];
+    if (structureChanged) {
+        if (meta._state !== undefined) {
+            // Progressive entity: new files → builder only (cursor handles incremental)
+            phaseState = invalidateBuilder(phaseState);
+        }
+        else {
+            architectInvalidators.push('structureHash');
+        }
+    }
+    if (steerChanged)
+        architectInvalidators.push('steer');
+    if (architectChanged)
+        architectInvalidators.push('_architect');
+    if (crossRefsDeclChanged)
+        architectInvalidators.push('_crossRefs');
+    if ((meta._synthesisCount ?? 0) >= config.architectEvery) {
+        architectInvalidators.push('architectEvery');
+    }
+    // First-run check: no _builder means architect must run
+    const firstRun = !meta._builder;
+    if (architectInvalidators.length > 0 || firstRun) {
+        phaseState = invalidateArchitect(phaseState);
+    }
+    // ── Builder-level inputs ──
+    // Scope file mtime check — if any file newer than _generatedAt
+    const scopeMtimeMax = null;
+    // Note: actual mtime check is done by the caller or via isStale;
+    // here we just detect cross-ref content changes for the cascade.
+    // Cross-ref _content change (builder-invalidating)
+    let crossRefContentChanged = false;
+    return {
+        phaseState,
+        architectInvalidators,
+        stalenessInputs: {
+            structureHash,
+            steerChanged,
+            architectChanged,
+            crossRefsDeclChanged,
+            scopeMtimeMax,
+            crossRefContentChanged,
+        },
+        structureHash,
+        steerChanged,
+    };
+}
+
+/**
+ * Weighted staleness formula for candidate selection.
+ *
+ * effectiveStaleness = actualStaleness * (normalizedDepth + 1) ^ (depthWeight * emphasis)
+ *
+ * @module scheduling/weightedFormula
+ */
+/**
+ * Compute effective staleness for a set of candidates.
+ *
+ * Normalizes depths so the minimum becomes 0, then applies the formula:
+ * effectiveStaleness = actualStaleness * (normalizedDepth + 1) ^ (depthWeight * emphasis)
+ *
+ * Per-meta _emphasis (default 1) multiplies depthWeight, allowing individual
+ * metas to tune how much their tree position affects scheduling.
+ *
+ * @param candidates - Array of \{ node, meta, actualStaleness \}.
+ * @param depthWeight - Exponent for depth weighting (0 = pure staleness).
+ * @returns Same array with effectiveStaleness computed.
+ */
+function computeEffectiveStaleness(candidates, depthWeight) {
+    if (candidates.length === 0)
+        return [];
+    // Get depth for each candidate: use _depth override or tree depth
+    const depths = candidates.map((c) => c.meta._depth ?? c.node.treeDepth);
+    // Normalize: shift so minimum becomes 0
+    const minDepth = Math.min(...depths);
+    const normalizedDepths = depths.map((d) => Math.max(0, d - minDepth));
+    return candidates.map((c, i) => {
+        const emphasis = c.meta._emphasis ?? 1;
+        return {
+            ...c,
+            effectiveStaleness: c.actualStaleness *
+                Math.pow(normalizedDepths[i] + 1, depthWeight * emphasis),
+        };
+    });
+}
+
 /**
  * Corpus-wide phase scheduler.
  *
@@ -10695,18 +10599,30 @@ function derivePhaseState(meta, inputs) {
 /**
  * Build phase candidates from listMetas entries.
  *
- * Derives phase state and auto-retries failed phases for each entry.
+ * Derives phase state, auto-retries failed phases, and applies Tier 1
+ * cheap-invalidation (no I/O) for metas with persisted _phaseState.
  * Used by orchestratePhase, queue route, and status route.
  */
-function buildPhaseCandidates(entries) {
-    return entries.map((entry) => ({
-        node: entry.node,
-        meta: entry.meta,
-        phaseState: retryAllFailed(derivePhaseState(entry.meta)),
-        actualStaleness: entry.stalenessSeconds,
-        locked: entry.locked,
-        disabled: entry.disabled,
-    }));
+function buildPhaseCandidates(entries, architectEvery) {
+    return entries.map((entry) => {
+        let ps = retryAllFailed(derivePhaseState(entry.meta));
+        // Tier 1 cheap invalidation for metas with persisted _phaseState
+        if (entry.meta._phaseState) {
+            const needsArchitect = !entry.meta._builder ||
+                (entry.meta._synthesisCount ?? 0) >= architectEvery;
+            if (needsArchitect && ps.architect === 'fresh') {
+                ps = { architect: 'pending', builder: 'stale', critic: 'stale' };
+            }
+        }
+        return {
+            node: entry.node,
+            meta: entry.meta,
+            phaseState: ps,
+            actualStaleness: entry.stalenessSeconds,
+            locked: entry.locked,
+            disabled: entry.disabled,
+        };
+    });
 }
 /**
  * Rank all eligible phase candidates by priority.
@@ -10769,6 +10685,124 @@ function selectPhaseCandidate(metas, depthWeight) {
     return rankPhaseCandidates(metas, depthWeight)[0] ?? null;
 }
 
+/**
+ * Shared error utilities.
+ *
+ * @module errors
+ */
+/**
+ * Wrap an unknown caught value into a MetaError.
+ *
+ * @param step - Which synthesis step failed.
+ * @param err - The caught error value.
+ * @param code - Error classification code.
+ * @returns A structured MetaError.
+ */
+function toMetaError(step, err, code = 'FAILED') {
+    return {
+        step,
+        code,
+        message: err instanceof Error ? err.message : String(err),
+    };
+}
+
+/**
+ * Parse subprocess outputs for each synthesis step.
+ *
+ * - Architect: returns text \> _builder
+ * - Builder: returns JSON \> _content + structured fields
+ * - Critic: returns text \> _feedback
+ *
+ * @module orchestrator/parseOutput
+ */
+/**
+ * Parse architect output. The architect returns a task brief as text.
+ *
+ * @param output - Raw subprocess output.
+ * @returns The task brief string.
+ */
+function parseArchitectOutput(output) {
+    return output.trim();
+}
+/**
+ * Parse builder output. The builder returns JSON with _content and optional fields.
+ *
+ * Attempts JSON parse first. If that fails, treats the entire output as _content.
+ *
+ * @param output - Raw subprocess output.
+ * @returns Parsed builder output with content and structured fields.
+ */
+function parseBuilderOutput(output) {
+    const trimmed = output.trim();
+    // Strategy 1: Try to parse the entire output as JSON directly
+    const direct = tryParseJson(trimmed);
+    if (direct)
+        return direct;
+    // Strategy 2: Try all fenced code blocks (last match first — models often narrate then output)
+    const fencePattern = /```(?:json)?\s*([\s\S]*?)```/g;
+    const fenceMatches = [];
+    let match;
+    while ((match = fencePattern.exec(trimmed)) !== null) {
+        fenceMatches.push(match[1].trim());
+    }
+    // Try last fence first (most likely to be the actual output)
+    for (let i = fenceMatches.length - 1; i >= 0; i--) {
+        const result = tryParseJson(fenceMatches[i]);
+        if (result)
+            return result;
+    }
+    // Strategy 3: Find outermost { ... } braces
+    const firstBrace = trimmed.indexOf('{');
+    const lastBrace = trimmed.lastIndexOf('}');
+    if (firstBrace !== -1 && lastBrace > firstBrace) {
+        const result = tryParseJson(trimmed.substring(firstBrace, lastBrace + 1));
+        if (result)
+            return result;
+    }
+    // Fallback: treat entire output as content
+    return { content: trimmed, fields: {} };
+}
+/** Try to parse a string as JSON and extract builder output fields. */
+function tryParseJson(str) {
+    try {
+        const raw = JSON.parse(str);
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+            return null;
+        }
+        const parsed = raw;
+        // Extract _content
+        const content = typeof parsed['_content'] === 'string'
+            ? parsed['_content']
+            : typeof parsed['content'] === 'string'
+                ? parsed['content']
+                : null;
+        if (content === null)
+            return null;
+        // Extract _state (the ONLY underscore key the builder is allowed to set)
+        const state = '_state' in parsed ? parsed['_state'] : undefined;
+        // Extract non-underscore fields
+        const fields = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (!key.startsWith('_') && key !== 'content') {
+                fields[key] = value;
+            }
+        }
+        return { content, fields, ...(state !== undefined ? { state } : {}) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse critic output. The critic returns evaluation text.
+ *
+ * @param output - Raw subprocess output.
+ * @returns The feedback string.
+ */
+function parseCriticOutput(output) {
+    return output.trim();
+}
+
 /**
  * Per-phase executors for the phase-state machine.
  *
@@ -11027,7 +11061,7 @@ async function orchestratePhase(config, executor, watcher, targetPath, onProgres
     if (metaResult.entries.length === 0)
         return { executed: false };
     // Build candidates with phase state (including invalidation + auto-retry)
-    const candidates = buildPhaseCandidates(metaResult.entries);
+    const candidates = buildPhaseCandidates(metaResult.entries, config.architectEvery);
     // Select best phase candidate
     const winner = selectPhaseCandidate(candidates, config.depthWeight);
     if (!winner) {
@@ -11702,46 +11736,6 @@ function buildMetaRules(config) {
             },
             renderAs: 'md',
         },
-        {
-            name: 'meta-config',
-            description: 'jeeves-meta configuration file',
-            match: {
-                properties: {
-                    file: {
-                        properties: {
-                            path: {
-                                type: 'string',
-                                glob: '**/jeeves-meta{.config.json,/config.json}',
-                            },
-                        },
-                    },
-                },
-            },
-            schema: ['base', { properties: { domains: { set: ['meta-config'] } } }],
-            render: {
-                frontmatter: [
-                    'watcherUrl',
-                    'gatewayUrl',
-                    'architectEvery',
-                    'depthWeight',
-                    'maxArchive',
-                    'maxLines',
-                ],
-                body: [
-                    {
-                        path: 'json.defaultArchitect',
-                        heading: 2,
-                        label: 'Default Architect Prompt',
-                    },
-                    {
-                        path: 'json.defaultCritic',
-                        heading: 2,
-                        label: 'Default Critic Prompt',
-                    },
-                ],
-            },
-            renderAs: 'md',
-        },
     ];
 }
 /**
@@ -11985,13 +11979,15 @@ class Scheduler {
     queue;
     logger;
     watcher;
+    cache;
     registrar = null;
     currentExpression;
-    constructor(config, queue, logger, watcher) {
+    constructor(config, queue, logger, watcher, cache) {
         this.config = config;
         this.queue = queue;
         this.logger = logger;
         this.watcher = watcher;
+        this.cache = cache;
         this.currentExpression = config.schedule;
     }
     /** Set the rule registrar for watcher restart detection. */
@@ -12108,8 +12104,8 @@ class Scheduler {
      */
     async discoverNextPhase() {
         try {
-            const result = await listMetas(this.config, this.watcher);
-            const candidates = buildPhaseCandidates(result.entries);
+            const result = await this.cache.get(this.config, this.watcher);
+            const candidates = buildPhaseCandidates(result.entries, this.config.architectEvery);
             const winner = selectPhaseCandidate(candidates, this.config.depthWeight);
             if (!winner)
                 return null;
@@ -12534,11 +12530,11 @@ function registerMetasUpdateRoute(app, deps) {
  */
 function registerPreviewRoute(app, deps) {
     app.get('/preview', async (request, reply) => {
-        const { config, watcher } = deps;
+        const { config, watcher, cache } = deps;
         const query = request.query;
         let result;
         try {
-            result = await listMetas(config, watcher);
+            result = await cache.get(config, watcher);
         }
         catch {
             return reply.status(503).send({
@@ -12558,40 +12554,24 @@ function registerPreviewRoute(app, deps) {
             }
         }
         else {
-            // Select stalest candidate
-            const stale = result.entries
-                .filter((e) => e.stalenessSeconds > 0)
-                .map((e) => ({
-                node: e.node,
-                meta: e.meta,
-                actualStaleness: e.stalenessSeconds,
-            }));
-            const stalestPath = discoverStalestPath(stale, config.depthWeight);
-            if (!stalestPath) {
+            // Select best phase candidate
+            const candidates = buildPhaseCandidates(result.entries, config.architectEvery);
+            const winner = selectPhaseCandidate(candidates, config.depthWeight);
+            if (!winner) {
                 return { message: 'No stale metas found. Nothing to synthesize.' };
             }
-            targetNode = findNode(result.tree, stalestPath);
+            targetNode = findNode(result.tree, winner.node.metaPath);
         }
         const meta = await readMetaJson(targetNode.metaPath);
         // Scope files
         const { scopeFiles } = await getScopeFiles(targetNode, watcher);
-        const structureHash = computeStructureHash(scopeFiles);
+        // Compute invalidation inputs (DRY: reuse phaseState/invalidate logic)
+        const invalidation = await computeInvalidation(meta, scopeFiles, config, targetNode);
+        const { architectInvalidators, stalenessInputs } = invalidation;
+        const { structureHash } = invalidation;
         const structureChanged = structureHash !== meta._structureHash;
-        const latestArchive = await readLatestArchive(targetNode.metaPath);
-        const steerChanged = hasSteerChanged(meta._steer, latestArchive?._steer, Boolean(latestArchive));
-        // _architect change detection
-        const architectChanged = latestArchive
-            ? (meta._architect ?? '') !== (latestArchive._architect ?? '')
-            : Boolean(meta._architect);
-        // _crossRefs declaration change detection
-        const currentRefs = (meta._crossRefs ?? []).slice().sort().join(',');
-        const archiveRefs = (latestArchive?._crossRefs ?? [])
-            .slice()
-            .sort()
-            .join(',');
-        const crossRefsDeclChanged = latestArchive
-            ? currentRefs !== archiveRefs
-            : currentRefs.length > 0;
+        const { steerChanged } = invalidation;
+        const { architectChanged, crossRefsDeclChanged } = stalenessInputs;
         const architectTriggered = isArchitectTriggered(meta, structureChanged, steerChanged, config.architectEvery);
         // Delta files
         const deltaFiles = getDeltaFiles(meta._generatedAt, scopeFiles);
@@ -12616,30 +12596,6 @@ function registerPreviewRoute(app, deps) {
         });
         const owedPhase = getOwedPhase(phaseState);
         const priorityBand = getPriorityBand(phaseState);
-        // Architect invalidators
-        const architectInvalidators = [];
-        if (owedPhase === 'architect') {
-            if (structureChanged)
-                architectInvalidators.push('structureHash');
-            if (steerChanged)
-                architectInvalidators.push('steer');
-            if (architectChanged)
-                architectInvalidators.push('_architect');
-            if (crossRefsDeclChanged)
-                architectInvalidators.push('_crossRefs');
-            if ((meta._synthesisCount ?? 0) >= config.architectEvery) {
-                architectInvalidators.push('architectEvery');
-            }
-        }
-        // Staleness inputs
-        const stalenessInputs = {
-            structureHash,
-            steerChanged,
-            architectChanged,
-            crossRefsDeclChanged,
-            scopeMtimeMax: null,
-            crossRefContentChanged: false,
-        };
         return {
             path: targetNode.metaPath,
             staleness: {
@@ -12713,8 +12669,8 @@ function registerQueueRoutes(app, deps) {
         // ranked by scheduler priority (computed on read, not persisted)
         let automatic = [];
         try {
-            const metaResult = await listMetas(deps.config, deps.watcher);
-            const candidates = buildPhaseCandidates(metaResult.entries);
+            const metaResult = await deps.cache.get(deps.config, deps.watcher);
+            const candidates = buildPhaseCandidates(metaResult.entries, deps.config.architectEvery);
             const ranked = rankPhaseCandidates(candidates, deps.config.depthWeight);
             automatic = ranked.map((c) => ({
                 path: c.node.metaPath,
@@ -12937,7 +12893,7 @@ function registerStatusRoute(app, deps) {
         name: SERVICE_NAME,
         version: SERVICE_VERSION,
         getHealth: async () => {
-            const { config, queue, scheduler, stats, watcher } = deps;
+            const { config, queue, scheduler, stats, watcher, cache } = deps;
             // On-demand dependency checks
             const [watcherHealth, gatewayHealth] = await Promise.all([
                 checkWatcher(config.watcherUrl),
@@ -12951,7 +12907,7 @@ function registerStatusRoute(app, deps) {
             };
             let nextPhase = null;
             try {
-                const metaResult = await listMetas(config, watcher);
+                const metaResult = await cache.get(config, watcher);
                 // Count raw phase states (before retry) for display
                 for (const entry of metaResult.entries) {
                     const ps = derivePhaseState(entry.meta);
@@ -12960,7 +12916,7 @@ function registerStatusRoute(app, deps) {
                     }
                 }
                 // Build candidates (with auto-retry) for scheduling
-                const candidates = buildPhaseCandidates(metaResult.entries);
+                const candidates = buildPhaseCandidates(metaResult.entries, config.architectEvery);
                 // Find next phase candidate
                 const winner = selectPhaseCandidate(candidates, config.depthWeight);
                 if (winner) {
@@ -13023,7 +12979,7 @@ const synthesizeBodySchema = z.object({
 function registerSynthesizeRoute(app, deps) {
     app.post('/synthesize', async (request, reply) => {
         const body = synthesizeBodySchema.parse(request.body);
-        const { config, watcher, queue } = deps;
+        const { config, watcher, queue, cache } = deps;
         if (body.path) {
             // Path-targeted trigger: create override entry
             const targetPath = resolveMetaDir(body.path);
@@ -13060,7 +13016,7 @@ function registerSynthesizeRoute(app, deps) {
         // Corpus-wide trigger: discover stalest candidate
         let result;
         try {
-            result = await listMetas(config, watcher);
+            result = await cache.get(config, watcher);
         }
         catch {
             return reply.status(503).send({
@@ -13068,20 +13024,15 @@ function registerSynthesizeRoute(app, deps) {
                 message: 'Watcher unreachable — cannot discover candidates',
             });
         }
-        const stale = result.entries
-            .filter((e) => e.stalenessSeconds > 0 && !e.disabled)
-            .map((e) => ({
-            node: e.node,
-            meta: e.meta,
-            actualStaleness: e.stalenessSeconds,
-        }));
-        const stalest = discoverStalestPath(stale, config.depthWeight);
-        if (!stalest) {
+        const candidates = buildPhaseCandidates(result.entries, config.architectEvery);
+        const winner = selectPhaseCandidate(candidates, config.depthWeight);
+        if (!winner) {
             return reply.code(200).send({
                 status: 'skipped',
                 message: 'No stale metas found. Nothing to synthesize.',
             });
         }
+        const stalest = winner.node.metaPath;
         const enqueueResult = queue.enqueue(stalest);
         return reply.code(202).send({
             status: 'accepted',
@@ -13182,6 +13133,18 @@ function createServer(options) {
     // Fastify 5 requires `loggerInstance` for external pino loggers
     const app = Fastify({
         loggerInstance: options.logger,
+        requestTimeout: 30_000,
+    });
+    // Readiness gate: return 503 while service is initializing
+    app.addHook('onRequest', async (request, reply) => {
+        if (options.deps.ready)
+            return;
+        const url = request.url;
+        if (url === '/config' || url.startsWith('/config/apply'))
+            return;
+        return reply
+            .status(503)
+            .send({ status: 'starting', message: 'Service initializing' });
     });
     registerRoutes(app, options.deps);
     return app;
@@ -13357,8 +13320,9 @@ async function startService(config, configPath) {
         lastCycleAt: null,
     };
     const queue = new SynthesisQueue(logger);
+    const cache = new MetaCache();
     // Scheduler (needs watcher for discovery)
-    const scheduler = new Scheduler(config, queue, logger, watcher);
+    const scheduler = new Scheduler(config, queue, logger, watcher, cache);
     const routeDeps = {
         config,
         logger,
@@ -13366,6 +13330,8 @@ async function startService(config, configPath) {
         watcher,
         scheduler,
         stats,
+        cache,
+        ready: false,
         executor,
         configPath,
     };
@@ -13416,6 +13382,9 @@ async function startService(config, configPath) {
                 }
                 await progress.report(evt);
             }, logger);
+            // Invalidate cache only when a phase was actually executed
+            if (result.executed)
+                cache.invalidate();
             const durationMs = Date.now() - startMs;
             if (!result.executed) {
                 logger.debug({ path: ownerPath }, 'Phase skipped (fully fresh or locked)');
@@ -13479,9 +13448,13 @@ async function startService(config, configPath) {
     scheduler.setRegistrar(registrar);
     routeDeps.registrar = registrar;
     void registrar.register().then(() => {
+        routeDeps.ready = true;
         if (registrar.isRegistered) {
             void verifyRuleApplication(watcher, logger);
         }
+    }, () => {
+        // Registration failed after max retries — mark ready anyway
+        routeDeps.ready = true;
     });
     // Periodic watcher health check (independent of scheduler)
     const healthCheck = new WatcherHealthCheck({