@karmaniverous/jeeves-meta 0.4.0 → 0.4.2

package/dist/index.js

@@ -1,7 +1,9 @@
-import { readdirSync, unlinkSync, readFileSync, mkdirSync, writeFileSync, existsSync, copyFileSync, watchFile } from 'node:fs';
-import { join, dirname, relative } from 'node:path';
+import { readdirSync, unlinkSync, readFileSync, mkdirSync, writeFileSync, existsSync, statSync, copyFileSync, watchFile } from 'node:fs';
+import { join, dirname, resolve, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
 import { createHash, randomUUID } from 'node:crypto';
+import { tmpdir } from 'node:os';
 import pino from 'pino';
 import { Cron } from 'croner';
 import Fastify from 'fastify';
@@ -102,6 +104,42 @@ function createSnapshot(metaPath, meta) {
     return archiveFile;
 }
 
+/**
+ * Shared constants for the jeeves-meta service package.
+ *
+ * @module constants
+ */
+/** Default HTTP port for the jeeves-meta service. */
+const DEFAULT_PORT = 1938;
+/** Default port as a string (for Commander CLI defaults). */
+const DEFAULT_PORT_STR = String(DEFAULT_PORT);
+/** Service name identifier. */
+const SERVICE_NAME = 'jeeves-meta';
+/** Service version, read from package.json at startup. */
+const SERVICE_VERSION = (() => {
+    try {
+        const dir = dirname(fileURLToPath(import.meta.url));
+        // Walk up to find package.json (works from src/ or dist/)
+        for (const candidate of [
+            resolve(dir, '..', 'package.json'),
+            resolve(dir, '..', '..', 'package.json'),
+        ]) {
+            try {
+                const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (pkg.version)
+                    return pkg.version;
+            }
+            catch {
+                // try next candidate
+            }
+        }
+        return 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+})();
+
 /**
  * Zod schema for jeeves-meta service configuration.
  *
@@ -285,14 +323,29 @@ function normalizePath(p) {
  * @param params - Base scan parameters (cursor is managed internally).
  * @returns All matching files across all pages.
  */
-async function paginatedScan(watcher, params) {
+async function paginatedScan(watcher, params, logger) {
     const allFiles = [];
     let cursor;
+    let pageCount = 0;
+    const start = Date.now();
     do {
+        const pageStart = Date.now();
         const result = await watcher.scan({ ...params, cursor });
         allFiles.push(...result.files);
+        pageCount++;
+        logger?.debug({
+            page: pageCount,
+            files: result.files.length,
+            pageMs: Date.now() - pageStart,
+            hasNext: Boolean(result.next),
+        }, 'paginatedScan page');
         cursor = result.next;
     } while (cursor);
+    logger?.debug({
+        pages: pageCount,
+        totalFiles: allFiles.length,
+        totalMs: Date.now() - start,
+    }, 'paginatedScan complete');
     return allFiles;
 }
 
@@ -359,12 +412,9 @@ function buildMetaFilter(config) {
  * @param watcher - WatcherClient for scan queries.
  * @returns Array of normalized .meta/ directory paths.
  */
-async function discoverMetas(config, watcher) {
+async function discoverMetas(config, watcher, logger) {
     const filter = buildMetaFilter(config);
-    const scanFiles = await paginatedScan(watcher, {
-        filter,
-        fields: ['file_path'],
-    });
+    const scanFiles = await paginatedScan(watcher, { filter, fields: ['file_path'] }, logger);
     // Deduplicate by .meta/ directory path (handles multi-chunk files)
     const seen = new Set();
     const metaPaths = [];
@@ -592,6 +642,8 @@ function findNode(tree, targetPath) {
  *
  * @module discovery/listMetas
  */
+/** Maximum staleness for never-synthesized metas (1 year in seconds). */
+const MAX_STALENESS_SECONDS$1 = 365 * 86_400;
 /**
  * Discover, deduplicate, and enrich all metas.
  *
@@ -603,9 +655,9 @@ function findNode(tree, targetPath) {
  * @param watcher - Watcher HTTP client for discovery.
  * @returns Enriched meta list with summary statistics and ownership tree.
  */
-async function listMetas(config, watcher) {
+async function listMetas(config, watcher, logger) {
     // Step 1: Discover deduplicated meta paths via watcher scan
-    const metaPaths = await discoverMetas(config, watcher);
+    const metaPaths = await discoverMetas(config, watcher, logger);
     // Step 2: Build ownership tree
     const tree = buildOwnershipTree(metaPaths);
     // Step 3: Read and enrich each meta from disk
@@ -638,7 +690,7 @@ async function listMetas(config, watcher) {
         // Compute staleness
         let stalenessSeconds;
         if (neverSynth) {
-            stalenessSeconds = Infinity;
+            stalenessSeconds = MAX_STALENESS_SECONDS$1;
         }
         else {
             const genAt = new Date(meta._generatedAt).getTime();
@@ -669,11 +721,7 @@ async function listMetas(config, watcher) {
         }
         // Track stalest (effective staleness for scheduling)
         const depthFactor = Math.pow(1 + config.depthWeight, depth);
-        const effectiveStaleness = (stalenessSeconds === Infinity
-            ? Number.MAX_SAFE_INTEGER
-            : stalenessSeconds) *
-            depthFactor *
-            emphasis;
+        const effectiveStaleness = stalenessSeconds * depthFactor * emphasis;
         if (effectiveStaleness > stalestEffective) {
             stalestEffective = effectiveStaleness;
             stalestPath = node.metaPath;
@@ -715,22 +763,83 @@ async function listMetas(config, watcher) {
     };
 }
 
+/**
+ * Recursive filesystem walker for file enumeration.
+ *
+ * Replaces paginated watcher scans for scope/delta/staleness checks.
+ * Returns normalized forward-slash paths.
+ *
+ * @module walkFiles
+ */
+/** Default directory names to always skip. */
+const DEFAULT_SKIP = new Set([
+    'node_modules',
+    '.git',
+    '.rollup.cache',
+    'dist',
+    'Thumbs.db',
+]);
+/**
+ * Recursively walk a directory and return all file paths.
+ *
+ * @param root - Root directory to walk.
+ * @param options - Walk options.
+ * @returns Array of normalized file paths.
+ */
+function walkFiles(root, options) {
+    const exclude = new Set([...DEFAULT_SKIP, ...(options?.exclude ?? [])]);
+    const modifiedAfter = options?.modifiedAfter;
+    const maxDepth = options?.maxDepth ?? 50;
+    const results = [];
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // Permission errors, missing dirs — skip
+        }
+        for (const entry of entries) {
+            if (exclude.has(entry.name))
+                continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath, depth + 1);
+            }
+            else if (entry.isFile()) {
+                if (modifiedAfter !== undefined) {
+                    try {
+                        const stat = statSync(fullPath);
+                        if (Math.floor(stat.mtimeMs / 1000) <= modifiedAfter)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                results.push(normalizePath(fullPath));
+            }
+        }
+    }
+    walk(root, 0);
+    return results;
+}
+
 /**
  * Compute the file scope owned by a meta node.
  *
- * A meta owns: parent dir + all descendants, minus child .meta/ subtrees.
- * For child subtrees, it consumes the child's .meta/meta.json as a rollup input.
+ * A meta owns: parent dir + all descendants, minus:
+ * - Its own .meta/ subtree (outputs, not inputs)
+ * - Child meta ownerPath subtrees (except their .meta/meta.json for rollups)
+ *
+ * Uses filesystem walks instead of watcher scans for performance.
  *
  * @module discovery/scope
  */
 /**
  * Get the scope path prefix for a meta node.
- *
- * This is the ownerPath — all files under this path are in scope,
- * except subtrees owned by child metas.
- *
- * @param node - The meta node to compute scope for.
- * @returns The scope path prefix.
  */
 function getScopePrefix(node) {
     return node.ownerPath;
@@ -738,47 +847,39 @@ function getScopePrefix(node) {
 /**
  * Filter a list of file paths to only those in scope for a meta node.
  *
- * Includes files under ownerPath, excludes files under child meta ownerPaths,
- * but includes child .meta/meta.json files as rollup inputs.
+ * Excludes:
+ * - The node's own .meta/ subtree (synthesis outputs are not scope inputs)
+ * - Child meta ownerPath subtrees (except child .meta/meta.json for rollups)
  *
- * @param node - The meta node.
- * @param files - Array of file paths to filter.
- * @returns Filtered array of in-scope file paths.
+ * walkFiles already returns normalized forward-slash paths.
  */
 function filterInScope(node, files) {
     const prefix = node.ownerPath + '/';
+    const ownMetaPrefix = node.metaPath + '/';
     const exclusions = node.children.map((c) => c.ownerPath + '/');
     const childMetaJsons = new Set(node.children.map((c) => c.metaPath + '/meta.json'));
     return files.filter((f) => {
-        const normalized = f.split('\\').join('/');
         // Must be under ownerPath
-        if (!normalized.startsWith(prefix) && normalized !== node.ownerPath)
+        if (!f.startsWith(prefix) && f !== node.ownerPath)
+            return false;
+        // Exclude own .meta/ subtree (outputs are not inputs)
+        if (f.startsWith(ownMetaPrefix))
             return false;
         // Check if under a child meta's subtree
         for (const excl of exclusions) {
-            if (normalized.startsWith(excl)) {
+            if (f.startsWith(excl)) {
                 // Exception: child meta.json files are included as rollup inputs
-                return childMetaJsons.has(normalized);
+                return childMetaJsons.has(f);
             }
         }
         return true;
     });
 }
 /**
- * Get all files in scope for a meta node via watcher scan.
- *
- * Scans the owner path prefix and filters out child meta subtrees,
- * keeping only files directly owned by this meta.
- *
- * @param node - The meta node.
- * @param watcher - WatcherClient for scan queries.
- * @returns Array of in-scope file paths.
+ * Get all files in scope for a meta node via filesystem walk.
  */
-async function getScopeFiles(node, watcher) {
-    const allScanFiles = await paginatedScan(watcher, {
-        pathPrefix: node.ownerPath,
-    });
-    const allFiles = allScanFiles.map((f) => f.file_path);
+function getScopeFiles(node) {
+    const allFiles = walkFiles(node.ownerPath);
     return {
         scopeFiles: filterInScope(node, allFiles),
         allFiles,
@@ -788,22 +889,13 @@ async function getScopeFiles(node, watcher) {
  * Get files modified since a given timestamp within a meta node's scope.
  *
  * If no generatedAt is provided (first run), returns all scope files.
- *
- * @param node - The meta node.
- * @param watcher - WatcherClient for scan queries.
- * @param generatedAt - ISO timestamp of last synthesis, or null/undefined for first run.
- * @param scopeFiles - Pre-computed scope files (used as fallback for first run).
- * @returns Array of modified in-scope file paths.
  */
-async function getDeltaFiles(node, watcher, generatedAt, scopeFiles) {
+function getDeltaFiles(node, generatedAt, scopeFiles) {
     if (!generatedAt)
         return scopeFiles;
     const modifiedAfter = Math.floor(new Date(generatedAt).getTime() / 1000);
-    const deltaScanFiles = await paginatedScan(watcher, {
-        pathPrefix: node.ownerPath,
-        modifiedAfter,
-    });
-    return filterInScope(node, deltaScanFiles.map((f) => f.file_path));
+    const deltaFiles = walkFiles(node.ownerPath, { modifiedAfter });
+    return filterInScope(node, deltaFiles);
 }
 
 /**
@@ -882,7 +974,7 @@ function sleep(ms) {
  * @module executor/GatewayExecutor
  */
 const DEFAULT_POLL_INTERVAL_MS = 5000;
-const DEFAULT_TIMEOUT_MS = 600_000; // 10 minutes
+const DEFAULT_TIMEOUT_MS$1 = 600_000; // 10 minutes
 /**
  * MetaExecutor that spawns OpenClaw sessions via the gateway's
  * `/tools/invoke` endpoint.
@@ -895,10 +987,12 @@ class GatewayExecutor {
     gatewayUrl;
     apiKey;
     pollIntervalMs;
+    workspaceDir;
     constructor(options = {}) {
         this.gatewayUrl = (options.gatewayUrl ?? 'http://127.0.0.1:18789').replace(/\/+$/, '');
         this.apiKey = options.apiKey;
         this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        this.workspaceDir = options.workspaceDir ?? join(tmpdir(), 'jeeves-meta');
     }
     /** Invoke a gateway tool via the /tools/invoke HTTP endpoint. */
     async invoke(tool, args) {
@@ -923,13 +1017,44 @@ class GatewayExecutor {
         }
         return data;
     }
+    /** Look up totalTokens for a session via sessions_list. */
+    async getSessionTokens(sessionKey) {
+        try {
+            const result = await this.invoke('sessions_list', {
+                limit: 20,
+                messageLimit: 0,
+            });
+            const sessions = (result.result?.details?.sessions ??
+                result.result?.sessions ??
+                []);
+            const match = sessions.find((s) => s.key === sessionKey);
+            return match?.totalTokens ?? undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async spawn(task, options) {
-        const timeoutSeconds = options?.timeout ?? DEFAULT_TIMEOUT_MS / 1000;
+        const timeoutSeconds = options?.timeout ?? DEFAULT_TIMEOUT_MS$1 / 1000;
         const timeoutMs = timeoutSeconds * 1000;
         const deadline = Date.now() + timeoutMs;
+        // Ensure workspace dir exists
+        if (!existsSync(this.workspaceDir)) {
+            mkdirSync(this.workspaceDir, { recursive: true });
+        }
+        // Generate unique output path for file-based output
+        const outputId = randomUUID();
+        const outputPath = this.workspaceDir + '/output-' + outputId + '.json';
+        // Append file output instruction to the task
+        const taskWithOutput = task +
+            '\n\n## OUTPUT DELIVERY\n\n' +
+            'Write your complete output to a file using the Write tool at:\n' +
+            outputPath +
+            '\n\n' +
+            'Reply with ONLY the file path you wrote to. No other text.';
         // Step 1: Spawn the sub-agent session
         const spawnResult = await this.invoke('sessions_spawn', {
-            task,
+            task: taskWithOutput,
             label: options?.label ?? 'jeeves-meta-synthesis',
             runTimeoutSeconds: timeoutSeconds,
             ...(options?.thinking ? { thinking: options.thinking } : {}),
@@ -961,19 +1086,37 @@ class GatewayExecutor {
                         lastMsg.stopReason &&
                         lastMsg.stopReason !== 'toolUse' &&
                         lastMsg.stopReason !== 'error') {
-                        // Sum token usage from all messages
-                        let tokens;
-                        let sum = 0;
-                        for (const msg of msgArray) {
-                            if (msg.usage?.totalTokens)
-                                sum += msg.usage.totalTokens;
+                        // 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)) {
+                            try {
+                                const output = readFileSync(outputPath, 'utf8');
+                                return { output, tokens };
+                            }
+                            finally {
+                                try {
+                                    unlinkSync(outputPath);
+                                }
+                                catch {
+                                    /* cleanup best-effort */
+                                }
+                            }
                         }
-                        if (sum > 0)
-                            tokens = sum;
-                        // Find the last assistant message with content
+                        // Fallback: extract from message content if file wasn't written
                         for (let i = msgArray.length - 1; i >= 0; i--) {
-                            if (msgArray[i].role === 'assistant' && msgArray[i].content) {
-                                return { output: msgArray[i].content, tokens };
+                            const msg = msgArray[i];
+                            if (msg.role === 'assistant' && msg.content) {
+                                const text = typeof msg.content === 'string'
+                                    ? 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 };
                             }
                         }
                         return { output: '', tokens };
@@ -1053,10 +1196,10 @@ function condenseScopeFiles(files, maxIndividual = 30) {
  * @param watcher - WatcherClient for scope enumeration.
  * @returns The computed context package.
  */
-async function buildContextPackage(node, meta, watcher) {
+function buildContextPackage(node, meta) {
     // Scope and delta files via watcher scan
-    const { scopeFiles } = await getScopeFiles(node, watcher);
-    const deltaFiles = await getDeltaFiles(node, watcher, meta._generatedAt, scopeFiles);
+    const { scopeFiles } = getScopeFiles(node);
+    const deltaFiles = getDeltaFiles(node, meta._generatedAt, scopeFiles);
     // Child meta outputs
     const childMetas = {};
     for (const child of node.children) {
@@ -1167,7 +1310,7 @@ function buildBuilderTask(ctx, meta, config) {
         includeSteer: false,
         feedbackHeading: '## FEEDBACK FROM CRITIC',
     });
-    sections.push('', '## OUTPUT FORMAT', 'Return a JSON object with:', '- "_content": Markdown narrative synthesis (required)', '- Any additional structured fields as non-underscore keys');
+    sections.push('', '## OUTPUT FORMAT', '', 'Respond with ONLY a JSON object. No explanation, no markdown fences, no text before or after.', '', 'Required schema:', '{', '  "type": "object",', '  "required": ["_content"],', '  "properties": {', '    "_content": { "type": "string", "description": "Markdown narrative synthesis" }', '  },', '  "additionalProperties": true', '}', '', 'Add any structured fields that capture important facts about this entity', '(e.g. status, risks, dependencies, metrics). Use descriptive key names without underscore prefix.', 'The _content field is the only required key — everything else is domain-driven.', '', 'DIAGRAMS: When diagrams would aid understanding, use PlantUML in fenced code blocks (```plantuml).', 'PlantUML is rendered natively by the serving infrastructure. NEVER use ASCII art diagrams.');
     return sections.join('\n');
 }
 /**
@@ -1473,28 +1616,33 @@ function discoverStalestPath(candidates, depthWeight) {
  * @param watcher - WatcherClient instance.
  * @returns True if any file in scope was modified after _generatedAt.
  */
-async function isStale(scopePrefix, meta, watcher) {
+function isStale(scopePrefix, meta) {
     if (!meta._generatedAt)
         return true; // Never synthesized = stale
     const generatedAtUnix = Math.floor(new Date(meta._generatedAt).getTime() / 1000);
-    const result = await watcher.scan({
-        pathPrefix: scopePrefix,
+    const modified = walkFiles(scopePrefix, {
         modifiedAfter: generatedAtUnix,
-        limit: 1,
+        maxDepth: 1,
     });
-    return result.files.length > 0;
+    return modified.length > 0;
 }
+/** Maximum staleness for never-synthesized metas (1 year in seconds). */
+const MAX_STALENESS_SECONDS = 365 * 86_400;
 /**
  * Compute actual staleness in seconds (now minus _generatedAt).
  *
+ * Never-synthesized metas are capped at {@link MAX_STALENESS_SECONDS}
+ * (1 year) so that depth weighting can differentiate them. Without
+ * bounding, `Infinity * depthFactor` = `Infinity` for all depths.
+ *
  * @param meta - Current meta.json content.
- * @returns Staleness in seconds, or Infinity if never synthesized.
+ * @returns Staleness in seconds, capped at 1 year for never-synthesized metas.
  */
 function actualStaleness(meta) {
     if (!meta._generatedAt)
-        return Infinity;
+        return MAX_STALENESS_SECONDS;
     const generatedMs = new Date(meta._generatedAt).getTime();
-    return (Date.now() - generatedMs) / 1000;
+    return Math.min((Date.now() - generatedMs) / 1000, MAX_STALENESS_SECONDS);
 }
 /**
  * Check whether the architect step should be triggered.
@@ -1571,20 +1719,50 @@ function parseArchitectOutput(output) {
  */
 function parseBuilderOutput(output) {
     const trimmed = output.trim();
-    // Try to extract JSON from the output (may be wrapped in markdown code fences)
-    let jsonStr = trimmed;
-    const fenceMatch = /```(?:json)?\s*([\s\S]*?)```/.exec(trimmed);
-    if (fenceMatch) {
-        jsonStr = fenceMatch[1].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 parsed = JSON.parse(jsonStr);
+        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
-                : trimmed;
+        const content = typeof parsed['_content'] === 'string'
+            ? parsed['_content']
+            : typeof parsed['content'] === 'string'
+                ? parsed['content']
+                : null;
+        if (content === null)
+            return null;
         // Extract non-underscore fields
         const fields = {};
         for (const [key, value] of Object.entries(parsed)) {
@@ -1595,8 +1773,7 @@ function parseBuilderOutput(output) {
         return { content, fields };
     }
     catch {
-        // Not valid JSON — treat entire output as content
-        return { content: trimmed, fields: {} };
+        return null;
     }
 }
 /**
@@ -1657,9 +1834,243 @@ function finalizeCycle(opts) {
  * @param watcher - Watcher HTTP client.
  * @returns Result indicating whether synthesis occurred.
  */
-async function orchestrateOnce(config, executor, watcher, targetPath, onProgress) {
+/**
+ * Build a minimal MetaNode from the filesystem for a known meta path.
+ * Discovers immediate child .meta/ dirs without a full watcher scan.
+ */
+function buildMinimalNode(metaPath) {
+    const normalized = normalizePath(metaPath);
+    const ownerPath = normalizePath(dirname(metaPath));
+    // Find child .meta/ directories by scanning the owner directory
+    const children = [];
+    function findChildMetas(dir, depth) {
+        if (depth > 10)
+            return; // Safety limit
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const fullPath = normalizePath(join(dir, entry.name));
+                if (entry.name === '.meta' && fullPath !== normalized) {
+                    // Found a child .meta — check it has meta.json
+                    if (existsSync(join(fullPath, 'meta.json'))) {
+                        children.push({
+                            metaPath: fullPath,
+                            ownerPath: normalizePath(dirname(fullPath)),
+                            treeDepth: 1, // Relative to target
+                            children: [],
+                            parent: null, // Set below
+                        });
+                    }
+                    // Don't recurse into .meta dirs
+                    return;
+                }
+                if (entry.name === 'node_modules' ||
+                    entry.name === '.git' ||
+                    entry.name === 'archive')
+                    continue;
+                findChildMetas(fullPath, depth + 1);
+            }
+        }
+        catch {
+            // Permission errors, etc — skip
+        }
+    }
+    findChildMetas(ownerPath, 0);
+    const node = {
+        metaPath: normalized,
+        ownerPath,
+        treeDepth: 0,
+        children,
+        parent: null,
+    };
+    // Wire parent references
+    for (const child of children) {
+        child.parent = node;
+    }
+    return node;
+}
+/** Run the architect/builder/critic pipeline on a single node. */
+async function synthesizeNode(node, currentMeta, config, executor, watcher, onProgress) {
+    const architectPrompt = currentMeta._architect ?? config.defaultArchitect;
+    const criticPrompt = currentMeta._critic ?? config.defaultCritic;
+    // Step 5-6: Steer change detection
+    const latestArchive = readLatestArchive(node.metaPath);
+    const steerChanged = hasSteerChanged(currentMeta._steer, latestArchive?._steer, Boolean(latestArchive));
+    // Step 7: Compute context (includes scope files and delta files)
+    const ctx = buildContextPackage(node, currentMeta);
+    // 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;
+    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,
+            });
+            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
+                finalizeCycle({
+                    metaPath: node.metaPath,
+                    current: currentMeta,
+                    config,
+                    architect: architectPrompt,
+                    builder: '',
+                    critic: criticPrompt,
+                    builderOutput: null,
+                    feedback: null,
+                    structureHash: newStructureHash,
+                    synthesisCount,
+                    error: stepError,
+                    architectTokens,
+                });
+                return {
+                    synthesized: true,
+                    metaPath: node.metaPath,
+                    error: stepError,
+                };
+            }
+            // Has cached builder — continue with existing
+        }
+    }
+    // Step 9: Builder
+    const metaForBuilder = { ...currentMeta, _builder: builderBrief };
+    let builderOutput = null;
+    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,
+        });
+        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) {
+        stepError = toMetaError('builder', err);
+        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,
+        });
+        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
+    finalizeCycle({
+        metaPath: node.metaPath,
+        current: currentMeta,
+        config,
+        architect: architectPrompt,
+        builder: builderBrief,
+        critic: criticPrompt,
+        builderOutput,
+        feedback,
+        structureHash: newStructureHash,
+        synthesisCount,
+        error: stepError,
+        architectTokens,
+        builderTokens,
+        criticTokens,
+    });
+    return {
+        synthesized: true,
+        metaPath: node.metaPath,
+        error: stepError ?? undefined,
+    };
+}
+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 = buildMinimalNode(normalizedTarget);
+        if (!acquireLock(node.metaPath))
+            return { synthesized: false };
+        try {
+            const currentMeta = JSON.parse(readFileSync(targetMetaJson, 'utf8'));
+            return await synthesizeNode(node, currentMeta, config, executor, watcher, onProgress);
+        }
+        finally {
+            releaseLock(node.metaPath);
+        }
+    }
+    // Full discovery path (scheduler-driven, no specific target)
     // Step 1: Discover via watcher scan
-    const metaPaths = await discoverMetas(config, watcher);
+    const discoveryStart = Date.now();
+    const metaPaths = await discoverMetas(config, watcher, logger);
+    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
@@ -1679,23 +2090,15 @@ async function orchestrateOnce(config, executor, watcher, targetPath, onProgress
     if (validPaths.length === 0)
         return { synthesized: false };
     const tree = buildOwnershipTree(validPaths);
-    // If targetPath specified, skip candidate selection — go directly to that meta
-    let targetNode;
-    if (targetPath) {
-        const normalized = normalizePath(targetPath);
-        targetNode = findNode(tree, normalized) ?? undefined;
-        if (!targetNode)
-            return { synthesized: false };
-    }
     // Steps 3-4: Staleness check + candidate selection
     const candidates = [];
-    for (const node of tree.nodes.values()) {
-        const meta = metas.get(node.metaPath);
+    for (const treeNode of tree.nodes.values()) {
+        const meta = metas.get(treeNode.metaPath);
         if (!meta)
-            continue; // Node not in metas map (e.g. unreadable meta.json)
+            continue;
         const staleness = actualStaleness(meta);
         if (staleness > 0) {
-            candidates.push({ node, meta, actualStaleness: staleness });
+            candidates.push({ node: treeNode, meta, actualStaleness: staleness });
         }
     }
     const weighted = computeEffectiveStaleness(candidates, config.depthWeight);
@@ -1708,7 +2111,7 @@ async function orchestrateOnce(config, executor, watcher, targetPath, onProgress
     for (const candidate of ranked) {
         if (!acquireLock(candidate.node.metaPath))
             continue;
-        const verifiedStale = await isStale(getScopePrefix(candidate.node), candidate.meta, watcher);
+        const verifiedStale = isStale(getScopePrefix(candidate.node), candidate.meta);
         if (!verifiedStale && candidate.meta._generatedAt) {
             // Bump _generatedAt so it doesn't win next cycle
             const metaFilePath = join(candidate.node.metaPath, 'meta.json');
@@ -1723,169 +2126,12 @@ async function orchestrateOnce(config, executor, watcher, targetPath, onProgress
         winner = candidate;
         break;
     }
-    if (!winner && !targetNode)
-        return { synthesized: false };
-    const node = targetNode ?? winner.node;
-    // For targeted path, acquire lock now (candidate selection already locked for stalest)
-    if (targetNode && !acquireLock(node.metaPath)) {
+    if (!winner)
         return { synthesized: false };
-    }
+    const node = winner.node;
     try {
-        // Re-read meta after lock (may have changed)
         const currentMeta = JSON.parse(readFileSync(join(node.metaPath, 'meta.json'), 'utf8'));
-        const architectPrompt = currentMeta._architect ?? config.defaultArchitect;
-        const criticPrompt = currentMeta._critic ?? config.defaultCritic;
-        // Step 5-6: Steer change detection
-        const latestArchive = 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);
-        // 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;
-        if (architectTriggered) {
-            try {
-                await onProgress?.({
-                    type: 'phase_start',
-                    metaPath: node.metaPath,
-                    phase: 'architect',
-                });
-                const phaseStart = Date.now();
-                const architectTask = buildArchitectTask(ctx, currentMeta, config);
-                const architectResult = await executor.spawn(architectTask, {
-                    thinking: config.thinking,
-                    timeout: config.architectTimeout,
-                });
-                builderBrief = parseArchitectOutput(architectResult.output);
-                architectTokens = architectResult.tokens;
-                synthesisCount = 0;
-                await onProgress?.({
-                    type: 'phase_complete',
-                    metaPath: node.metaPath,
-                    phase: 'architect',
-                    tokens: architectTokens,
-                    durationMs: Date.now() - phaseStart,
-                });
-            }
-            catch (err) {
-                stepError = toMetaError('architect', err);
-                if (!currentMeta._builder) {
-                    // No cached builder — cycle fails
-                    finalizeCycle({
-                        metaPath: node.metaPath,
-                        current: currentMeta,
-                        config,
-                        architect: architectPrompt,
-                        builder: '',
-                        critic: criticPrompt,
-                        builderOutput: null,
-                        feedback: null,
-                        structureHash: newStructureHash,
-                        synthesisCount,
-                        error: stepError,
-                        architectTokens,
-                    });
-                    return {
-                        synthesized: true,
-                        metaPath: node.metaPath,
-                        error: stepError,
-                    };
-                }
-                // Has cached builder — continue with existing
-            }
-        }
-        // Step 9: Builder
-        const metaForBuilder = { ...currentMeta, _builder: builderBrief };
-        let builderOutput = null;
-        try {
-            await onProgress?.({
-                type: 'phase_start',
-                metaPath: node.metaPath,
-                phase: 'builder',
-            });
-            const builderStart = Date.now();
-            const builderTask = buildBuilderTask(ctx, metaForBuilder, config);
-            const builderResult = await executor.spawn(builderTask, {
-                thinking: config.thinking,
-                timeout: config.builderTimeout,
-            });
-            builderOutput = parseBuilderOutput(builderResult.output);
-            builderTokens = builderResult.tokens;
-            synthesisCount++;
-            await onProgress?.({
-                type: 'phase_complete',
-                metaPath: node.metaPath,
-                phase: 'builder',
-                tokens: builderTokens,
-                durationMs: Date.now() - builderStart,
-            });
-        }
-        catch (err) {
-            stepError = toMetaError('builder', err);
-            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',
-                metaPath: node.metaPath,
-                phase: 'critic',
-            });
-            const criticStart = Date.now();
-            const criticTask = buildCriticTask(ctx, metaForCritic, config);
-            const criticResult = await executor.spawn(criticTask, {
-                thinking: config.thinking,
-                timeout: config.criticTimeout,
-            });
-            feedback = parseCriticOutput(criticResult.output);
-            criticTokens = criticResult.tokens;
-            stepError = null; // Clear any architect error on full success
-            await onProgress?.({
-                type: 'phase_complete',
-                metaPath: node.metaPath,
-                phase: 'critic',
-                tokens: criticTokens,
-                durationMs: Date.now() - criticStart,
-            });
-        }
-        catch (err) {
-            stepError = stepError ?? toMetaError('critic', err);
-        }
-        // Steps 11-12: Merge, archive, prune
-        finalizeCycle({
-            metaPath: node.metaPath,
-            current: currentMeta,
-            config,
-            architect: architectPrompt,
-            builder: builderBrief,
-            critic: criticPrompt,
-            builderOutput,
-            feedback,
-            structureHash: newStructureHash,
-            synthesisCount,
-            error: stepError,
-            architectTokens,
-            builderTokens,
-            criticTokens,
-        });
-        return {
-            synthesized: true,
-            metaPath: node.metaPath,
-            error: stepError ?? undefined,
-        };
+        return await synthesizeNode(node, currentMeta, config, executor, watcher, onProgress);
     }
     finally {
         // Step 13: Release lock
@@ -1904,8 +2150,8 @@ async function orchestrateOnce(config, executor, watcher, targetPath, onProgress
  * @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) {
-    const result = await orchestrateOnce(config, executor, watcher, targetPath, onProgress);
+async function orchestrate(config, executor, watcher, targetPath, onProgress, logger) {
+    const result = await orchestrateOnce(config, executor, watcher, targetPath, onProgress, logger);
     return [result];
 }
 
@@ -1914,9 +2160,12 @@ async function orchestrate(config, executor, watcher, targetPath, onProgress) {
  *
  * @module progress
  */
+function formatNumber(n) {
+    return n.toLocaleString('en-US');
+}
 function formatSeconds(durationMs) {
     const seconds = durationMs / 1000;
-    return seconds.toFixed(1) + 's';
+    return Math.round(seconds).toString() + 's';
 }
 function titleCasePhase(phase) {
     return phase.charAt(0).toUpperCase() + phase.slice(1);
@@ -1924,32 +2173,30 @@ function titleCasePhase(phase) {
 function formatProgressEvent(event) {
     switch (event.type) {
         case 'synthesis_start':
-            return `🔬 Started meta synthesis: ${event.metaPath}`;
+            return `🔬 Started meta synthesis: ${event.path}`;
         case 'phase_start': {
             if (!event.phase) {
-                return `  ⚙️ Phase started: ${event.metaPath}`;
+                return '  ⚙️ Phase started';
             }
             return `  ⚙️ ${titleCasePhase(event.phase)} phase started`;
         }
         case 'phase_complete': {
             const phase = event.phase ? titleCasePhase(event.phase) : 'Phase';
             const tokens = event.tokens ?? 0;
-            const duration = event.durationMs !== undefined
-                ? formatSeconds(event.durationMs)
-                : '0.0s';
-            return `  ✅ ${phase} phase complete (${String(tokens)} tokens / ${duration})`;
+            const duration = event.durationMs !== undefined ? formatSeconds(event.durationMs) : '0s';
+            return `  ✅ ${phase} complete (${formatNumber(tokens)} tokens / ${duration})`;
         }
         case 'synthesis_complete': {
             const tokens = event.tokens ?? 0;
             const duration = event.durationMs !== undefined
                 ? formatSeconds(event.durationMs)
                 : '0.0s';
-            return `✅ Completed: ${event.metaPath} (${String(tokens)} tokens / ${duration})`;
+            return `✅ Completed: ${event.path} (${formatNumber(tokens)} tokens / ${duration})`;
         }
         case 'error': {
             const phase = event.phase ? `${titleCasePhase(event.phase)} ` : '';
             const error = event.error ?? 'Unknown error';
-            return `❌ Synthesis failed at ${phase}phase: ${event.metaPath}\n   Error: ${error}`;
+            return `❌ Synthesis failed at ${phase}phase: ${event.path}\n   Error: ${error}`;
         }
         default: {
             return 'Unknown progress event';
@@ -2127,7 +2374,7 @@ class Scheduler {
      */
     async discoverStalest() {
         try {
-            const result = await listMetas(this.config, this.watcher);
+            const result = await listMetas(this.config, this.watcher, this.logger);
             const stale = result.entries
                 .filter((e) => e.stalenessSeconds > 0)
                 .map((e) => ({
@@ -2413,7 +2660,7 @@ function registerMetasRoutes(app, deps) {
     app.get('/metas', async (request) => {
         const query = metasQuerySchema.parse(request.query);
         const { config, watcher } = deps;
-        const result = await listMetas(config, watcher);
+        const result = await listMetas(config, watcher, request.log);
         let entries = result.entries;
         // Apply filters
         if (query.pathPrefix) {
@@ -2476,7 +2723,7 @@ function registerMetasRoutes(app, deps) {
         const query = metaDetailQuerySchema.parse(request.query);
         const { config, watcher } = deps;
         const targetPath = normalizePath(decodeURIComponent(request.params.path));
-        const result = await listMetas(config, watcher);
+        const result = await listMetas(config, watcher, request.log);
         const targetNode = findNode(result.tree, targetPath);
         if (!targetNode) {
             return reply.status(404).send({
@@ -2509,7 +2756,7 @@ function registerMetasRoutes(app, deps) {
             return r;
         };
         // Compute scope
-        const { scopeFiles, allFiles } = await getScopeFiles(targetNode, watcher);
+        const { scopeFiles, allFiles } = getScopeFiles(targetNode);
         // Compute staleness
         const metaTyped = meta;
         const staleSeconds = metaTyped._generatedAt
@@ -2556,7 +2803,7 @@ function registerPreviewRoute(app, deps) {
         const query = request.query;
         let result;
         try {
-            result = await listMetas(config, watcher);
+            result = await listMetas(config, watcher, request.log);
         }
         catch {
             return reply.status(503).send({
@@ -2592,14 +2839,14 @@ function registerPreviewRoute(app, deps) {
         }
         const meta = JSON.parse(readFileSync(join(targetNode.metaPath, 'meta.json'), 'utf8'));
         // Scope files
-        const { scopeFiles } = await getScopeFiles(targetNode, watcher);
+        const { scopeFiles } = getScopeFiles(targetNode);
         const structureHash = computeStructureHash(scopeFiles);
         const structureChanged = structureHash !== meta._structureHash;
         const latestArchive = readLatestArchive(targetNode.metaPath);
         const steerChanged = hasSteerChanged(meta._steer, latestArchive?._steer, Boolean(latestArchive));
         const architectTriggered = isArchitectTriggered(meta, structureChanged, steerChanged, config.architectEvery);
         // Delta files
-        const deltaFiles = await getDeltaFiles(targetNode, watcher, meta._generatedAt, scopeFiles);
+        const deltaFiles = getDeltaFiles(targetNode, meta._generatedAt, scopeFiles);
         // EMA token estimates
         const estimatedTokens = {
             architect: meta._architectTokensAvg ?? meta._architectTokens ?? 0,
@@ -2693,7 +2940,7 @@ async function checkDependency(url, path) {
 }
 function registerStatusRoute(app, deps) {
     app.get('/status', async () => {
-        const { config, queue, scheduler, stats, watcher } = deps;
+        const { config, queue, scheduler, stats } = deps;
         // On-demand dependency checks
         const [watcherHealth, gatewayHealth] = await Promise.all([
             checkDependency(config.watcherUrl, '/status'),
@@ -2714,23 +2961,11 @@ function registerStatusRoute(app, deps) {
         else {
             status = 'idle';
         }
-        // Metas summary from listMetas (already computed)
-        let metasSummary = { total: 0, stale: 0, errors: 0, neverSynthesized: 0 };
-        try {
-            const result = await listMetas(config, watcher);
-            metasSummary = {
-                total: result.summary.total,
-                stale: result.summary.stale,
-                errors: result.summary.errors,
-                neverSynthesized: result.summary.neverSynthesized,
-            };
-        }
-        catch {
-            // Watcher unreachable — leave zeros
-        }
+        // Metas summary is expensive (paginated watcher scan + disk reads).
+        // Use GET /metas for full inventory; status is a lightweight health check.
         return {
-            service: 'jeeves-meta',
-            version: '0.4.0',
+            service: SERVICE_NAME,
+            version: SERVICE_VERSION,
             uptime: process.uptime(),
             status,
             currentTarget: queue.current?.path ?? null,
@@ -2750,7 +2985,6 @@ function registerStatusRoute(app, deps) {
                 watcher: watcherHealth,
                 gateway: gatewayHealth,
             },
-            metas: metasSummary,
         };
     });
 }
@@ -2776,7 +3010,7 @@ function registerSynthesizeRoute(app, deps) {
             // Discover stalest candidate
             let result;
             try {
-                result = await listMetas(config, watcher);
+                result = await listMetas(config, watcher, request.log);
             }
             catch {
                 return reply.status(503).send({
@@ -2937,6 +3171,10 @@ function buildMetaRules(config) {
                             type: 'string',
                             set: '{{json._error.step}}',
                         },
+                        generated_at: {
+                            type: 'string',
+                            set: '{{json._generatedAt}}',
+                        },
                         generated_at_unix: {
                             type: 'integer',
                             set: '{{toUnix json._generatedAt}}',
@@ -2949,16 +3187,7 @@ function buildMetaRules(config) {
                 },
             ],
             render: {
-                frontmatter: [
-                    'meta_id',
-                    'meta_steer',
-                    'generated_at_unix',
-                    'meta_depth',
-                    'meta_emphasis',
-                    'meta_architect_tokens',
-                    'meta_builder_tokens',
-                    'meta_critic_tokens',
-                ],
+                frontmatter: ['meta_id', 'generated_at', '*', '!_*', '!has_error'],
                 body: [{ path: 'json._content', heading: 1, label: 'Synthesis' }],
             },
             renderAs: 'md',
@@ -3108,7 +3337,10 @@ class RuleRegistrar {
  * @returns Configured Fastify instance (not yet listening).
  */
 function createServer(options) {
-    const app = Fastify({ logger: options.logger });
+    // Fastify 5 requires `loggerInstance` for external pino loggers
+    const app = Fastify({
+        loggerInstance: options.logger,
+    });
     registerRoutes(app, {
         config: options.config,
         logger: options.logger,
@@ -3189,6 +3421,7 @@ function registerShutdownHandlers(deps) {
 const DEFAULT_MAX_RETRIES = 3;
 const DEFAULT_BACKOFF_BASE_MS = 1000;
 const DEFAULT_BACKOFF_FACTOR = 4;
+const DEFAULT_TIMEOUT_MS = 30_000;
 /** Check if an error is transient (worth retrying). */
 function isTransient(status) {
     return status >= 500 || status === 408 || status === 429;
@@ -3201,11 +3434,13 @@ class HttpWatcherClient {
     maxRetries;
     backoffBaseMs;
     backoffFactor;
+    timeoutMs;
     constructor(options) {
         this.baseUrl = options.baseUrl.replace(/\/+$/, '');
         this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
         this.backoffBaseMs = options.backoffBaseMs ?? DEFAULT_BACKOFF_BASE_MS;
         this.backoffFactor = options.backoffFactor ?? DEFAULT_BACKOFF_FACTOR;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     }
     /** POST JSON with retry. */
     async post(endpoint, body) {
@@ -3215,6 +3450,7 @@ class HttpWatcherClient {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(body),
+                signal: AbortSignal.timeout(this.timeoutMs),
             });
             if (res.ok) {
                 return res.json();
@@ -3355,9 +3591,11 @@ async function startService(config, configPath) {
     const synthesizeFn = async (path) => {
         const startMs = Date.now();
         let cycleTokens = 0;
+        // Strip .meta suffix for human-readable progress reporting
+        const ownerPath = path.replace(/\/?\.meta\/?$/, '');
         await progress.report({
             type: 'synthesis_start',
-            metaPath: path,
+            path: ownerPath,
         });
         try {
             const results = await orchestrate(config, executor, watcher, path, async (evt) => {
@@ -3379,7 +3617,7 @@ async function startService(config, configPath) {
                 stats.totalErrors++;
                 await progress.report({
                     type: 'error',
-                    metaPath: path,
+                    path: ownerPath,
                     error: result.error.message,
                 });
             }
@@ -3387,7 +3625,7 @@ async function startService(config, configPath) {
                 scheduler.resetBackoff();
                 await progress.report({
                     type: 'synthesis_complete',
-                    metaPath: path,
+                    path: ownerPath,
                     tokens: cycleTokens,
                     durationMs,
                 });
@@ -3398,7 +3636,7 @@ async function startService(config, configPath) {
             const message = err instanceof Error ? err.message : String(err);
             await progress.report({
                 type: 'error',
-                metaPath: path,
+                path: ownerPath,
                 error: message,
             });
             throw err;
@@ -3460,4 +3698,4 @@ async function startService(config, configPath) {
     logger.info('Service fully initialized');
 }
 
-export { GatewayExecutor, HttpWatcherClient, ProgressReporter, RuleRegistrar, Scheduler, SynthesisQueue, acquireLock, actualStaleness, buildArchitectTask, buildBuilderTask, buildContextPackage, buildCriticTask, buildMetaFilter, buildOwnershipTree, cleanupStaleLocks, computeEffectiveStaleness, computeEma, computeStructureHash, createLogger, createServer, createSnapshot, discoverMetas, filterInScope, findNode, formatProgressEvent, getScopePrefix, hasSteerChanged, isArchitectTriggered, isLocked, isStale, listArchiveFiles, listMetas, loadServiceConfig, mergeAndWrite, metaConfigSchema, metaErrorSchema, metaJsonSchema, normalizePath, orchestrate, paginatedScan, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, pruneArchive, readLatestArchive, readLockState, registerRoutes, registerShutdownHandlers, releaseLock, resolveConfigPath, resolveMetaDir, selectCandidate, serviceConfigSchema, sleep, startService, toMetaError };
+export { DEFAULT_PORT, DEFAULT_PORT_STR, GatewayExecutor, HttpWatcherClient, ProgressReporter, RuleRegistrar, SERVICE_NAME, SERVICE_VERSION, Scheduler, SynthesisQueue, acquireLock, actualStaleness, buildArchitectTask, buildBuilderTask, buildContextPackage, buildCriticTask, buildMetaFilter, buildOwnershipTree, cleanupStaleLocks, computeEffectiveStaleness, computeEma, computeStructureHash, createLogger, createServer, createSnapshot, discoverMetas, filterInScope, findNode, formatProgressEvent, getScopePrefix, hasSteerChanged, isArchitectTriggered, isLocked, isStale, listArchiveFiles, listMetas, loadServiceConfig, mergeAndWrite, metaConfigSchema, metaErrorSchema, metaJsonSchema, normalizePath, orchestrate, paginatedScan, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, pruneArchive, readLatestArchive, readLockState, registerRoutes, registerShutdownHandlers, releaseLock, resolveConfigPath, resolveMetaDir, selectCandidate, serviceConfigSchema, sleep, startService, toMetaError, walkFiles };