@karmaniverous/jeeves-meta 0.2.2 → 0.3.0

package/dist/index.js

@@ -1,7 +1,7 @@
-import { readdirSync, unlinkSync, readFileSync, mkdirSync, writeFileSync, existsSync, statSync } from 'node:fs';
+import { readdirSync, unlinkSync, readFileSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
 import { join, dirname, relative, sep } from 'node:path';
 import { z } from 'zod';
-import { randomUUID, createHash } from 'node:crypto';
+import { createHash } from 'node:crypto';
 
 /**
  * List archive snapshot files in chronological order.
@@ -110,7 +110,6 @@ function createSnapshot(metaPath, meta) {
 /** Zod schema for jeeves-meta configuration. */
 const synthConfigSchema = z.object({
     /** Filesystem paths to watch for .meta/ directories. */
-    watchPaths: z.array(z.string()).min(1),
     /** Watcher service base URL. */
     watcherUrl: z.url(),
     /** OpenClaw gateway base URL for subprocess spawning. */
@@ -143,6 +142,21 @@ const synthConfigSchema = z.object({
     skipUnchanged: z.boolean().default(true),
     /** Number of metas to synthesize per invocation. */
     batchSize: z.number().int().min(1).default(1),
+    /**
+     * Watcher metadata properties for live .meta/meta.json files.
+     * Virtual rules use these to tag live metas; scan queries derive
+     * their filter from the first domain value.
+     */
+    metaProperty: z
+        .object({ domains: z.array(z.string()).min(1) })
+        .default({ domains: ['meta'] }),
+    /**
+     * Watcher metadata properties for .meta/archive/** snapshots.
+     * Virtual rules use these to tag archive files.
+     */
+    metaArchiveProperty: z
+        .object({ domains: z.array(z.string()).min(1) })
+        .default({ domains: ['meta-archive'] }),
 });
 
 /**
@@ -295,81 +309,100 @@ function resolveConfigPath(args) {
 }
 
 /**
- * Ensure meta.json exists in each .meta/ directory.
+ * Normalize file paths to forward slashes for consistency with watcher-indexed paths.
  *
- * If meta.json is missing, creates it with a generated UUID.
+ * Watcher indexes paths with forward slashes (`j:/domains/...`). This utility
+ * ensures all paths in the library use the same convention, regardless of
+ * the platform's native separator.
  *
- * @module discovery/ensureMetaJson
+ * @module normalizePath
  */
 /**
- * Ensure meta.json exists at the given .meta/ path.
+ * Normalize a file path to forward slashes.
  *
- * @param metaPath - Absolute path to a .meta/ directory.
- * @returns The meta.json content (existing or newly created).
+ * @param p - File path (may contain backslashes).
+ * @returns Path with all backslashes replaced by forward slashes.
  */
-function ensureMetaJson(metaPath) {
-    const filePath = join(metaPath, 'meta.json');
-    if (existsSync(filePath)) {
-        const raw = readFileSync(filePath, 'utf8');
-        return JSON.parse(raw);
-    }
-    // Create the archive subdirectory while we're at it
-    const archivePath = join(metaPath, 'archive');
-    if (!existsSync(archivePath)) {
-        mkdirSync(archivePath, { recursive: true });
-    }
-    const meta = { _id: randomUUID() };
-    writeFileSync(filePath, JSON.stringify(meta, null, 2) + '\n');
-    return meta;
+function normalizePath$1(p) {
+    return p.replaceAll('\\', '/');
+}
+
+/**
+ * Paginated scan helper for exhaustive scope enumeration.
+ *
+ * @module paginatedScan
+ */
+/**
+ * Perform a paginated scan that follows cursor tokens until exhausted.
+ *
+ * @param watcher - WatcherClient instance.
+ * @param params - Base scan parameters (cursor is managed internally).
+ * @returns All matching files across all pages.
+ */
+async function paginatedScan(watcher, params) {
+    const allFiles = [];
+    let cursor;
+    do {
+        const result = await watcher.scan({ ...params, cursor });
+        allFiles.push(...result.files);
+        cursor = result.next;
+    } while (cursor);
+    return allFiles;
 }
 
 /**
- * Glob watchPaths for .meta/ directories.
+ * Discover .meta/ directories via watcher scan.
  *
- * Walks each watchPath recursively, collecting directories named '.meta'
- * that contain (or will contain) a meta.json file.
+ * Replaces filesystem-based globMetas() with a watcher query
+ * that returns indexed .meta/meta.json points, filtered by domain.
  *
- * @module discovery/globMetas
+ * @module discovery/discoverMetas
  */
 /**
- * Recursively find all .meta/ directories under the given paths.
+ * Build a Qdrant filter from config metaProperty.
  *
- * @param watchPaths - Root directories to search.
- * @returns Array of absolute paths to .meta/ directories.
+ * @param config - Synth config with metaProperty.
+ * @returns Qdrant filter object for scanning live metas.
  */
-function globMetas(watchPaths) {
-    const results = [];
-    function walk(dir) {
-        let entries;
-        try {
-            entries = readdirSync(dir);
-        }
-        catch {
-            return; // Skip unreadable directories
-        }
-        for (const entry of entries) {
-            const full = join(dir, entry);
-            let stat;
-            try {
-                stat = statSync(full);
-            }
-            catch {
-                continue;
-            }
-            if (!stat.isDirectory())
-                continue;
-            if (entry === '.meta') {
-                results.push(full);
-            }
-            else {
-                walk(full);
-            }
-        }
-    }
-    for (const wp of watchPaths) {
-        walk(wp);
+function buildMetaFilter(config) {
+    return {
+        must: [
+            {
+                key: 'domains',
+                match: { value: config.metaProperty.domains[0] },
+            },
+        ],
+    };
+}
+/**
+ * Discover all .meta/ directories via watcher scan.
+ *
+ * Queries the watcher for indexed .meta/meta.json points using the
+ * configured domain filter. Returns deduplicated meta directory paths.
+ *
+ * @param config - Synth config (for domain filter).
+ * @param watcher - WatcherClient for scan queries.
+ * @returns Array of normalized .meta/ directory paths.
+ */
+async function discoverMetas(config, watcher) {
+    const filter = buildMetaFilter(config);
+    const scanFiles = await paginatedScan(watcher, {
+        filter,
+        fields: ['file_path'],
+    });
+    // Deduplicate by file_path (multi-chunk files)
+    const seen = new Set();
+    const metaPaths = [];
+    for (const sf of scanFiles) {
+        const fp = normalizePath$1(sf.file_path);
+        if (seen.has(fp))
+            continue;
+        seen.add(fp);
+        // Derive .meta/ directory from file_path (strip /meta.json)
+        const metaPath = fp.replace(/\/meta\.json$/, '');
+        metaPaths.push(metaPath);
     }
-    return results;
+    return metaPaths;
 }
 
 /**
@@ -382,7 +415,7 @@ function globMetas(watchPaths) {
  * @module discovery/ownershipTree
  */
 /** Normalize path separators to forward slashes for consistent comparison. */
-function normalizePath$1(p) {
+function normalizePath(p) {
     return p.split(sep).join('/');
 }
 /**
@@ -396,8 +429,8 @@ function buildOwnershipTree(metaPaths) {
     // Create nodes, sorted by ownerPath length (shortest first = shallowest)
     const sorted = [...metaPaths]
         .map((mp) => ({
-        metaPath: normalizePath$1(mp),
-        ownerPath: normalizePath$1(dirname(mp)),
+        metaPath: normalizePath(mp),
+        ownerPath: normalizePath(dirname(mp)),
     }))
         .sort((a, b) => a.ownerPath.length - b.ownerPath.length);
     for (const { metaPath, ownerPath } of sorted) {
@@ -469,15 +502,6 @@ function findNode(tree, targetPath) {
 function getScopePrefix(node) {
     return node.ownerPath;
 }
-/**
- * Get paths that should be excluded from the scope (child meta subtrees).
- *
- * @param node - The meta node to compute exclusions for.
- * @returns Array of path prefixes to exclude from scope queries.
- */
-function getScopeExclusions(node) {
-    return node.children.map((child) => child.ownerPath);
-}
 /**
  * Filter a list of file paths to only those in scope for a meta node.
  *
@@ -529,26 +553,200 @@ function computeEma(current, previous, decay = DEFAULT_DECAY) {
 }
 
 /**
- * Paginated scan helper for exhaustive scope enumeration.
+ * Shared error utilities.
  *
- * @module paginatedScan
+ * @module errors
  */
 /**
- * Perform a paginated scan that follows cursor tokens until exhausted.
+ * Wrap an unknown caught value into a SynthError.
  *
- * @param watcher - WatcherClient instance.
- * @param params - Base scan parameters (cursor is managed internally).
- * @returns All matching files across all pages.
+ * @param step - Which synthesis step failed.
+ * @param err - The caught error value.
+ * @param code - Error classification code.
+ * @returns A structured SynthError.
  */
-async function paginatedScan(watcher, params) {
-    const allFiles = [];
-    let cursor;
-    do {
-        const result = await watcher.scan({ ...params, cursor });
-        allFiles.push(...result.files);
-        cursor = result.next;
-    } while (cursor);
-    return allFiles;
+function toSynthError(step, err, code = 'FAILED') {
+    return {
+        step,
+        code,
+        message: err instanceof Error ? err.message : String(err),
+    };
+}
+
+/**
+ * SynthExecutor implementation using the OpenClaw gateway HTTP API.
+ *
+ * Lives in the library package so both plugin and runner can import it.
+ * Spawns sub-agent sessions via the gateway, polls for completion,
+ * and extracts output text.
+ *
+ * @module executor/GatewayExecutor
+ */
+const DEFAULT_POLL_INTERVAL_MS = 5000;
+const DEFAULT_TIMEOUT_MS = 600_000; // 10 minutes
+/** Sleep helper. */
+function sleep$1(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * SynthExecutor that spawns OpenClaw sessions via the gateway HTTP API.
+ *
+ * Used by both the OpenClaw plugin (in-process tool calls) and the
+ * runner/CLI (external invocation). Constructs from `gatewayUrl` and
+ * optional `apiKey` — typically sourced from `SynthConfig`.
+ */
+class GatewayExecutor {
+    gatewayUrl;
+    apiKey;
+    pollIntervalMs;
+    constructor(options = {}) {
+        this.gatewayUrl = (options.gatewayUrl ?? 'http://127.0.0.1:3000').replace(/\/+$/, '');
+        this.apiKey = options.apiKey;
+        this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    }
+    async spawn(task, options) {
+        const timeoutMs = (options?.timeout ?? DEFAULT_TIMEOUT_MS / 1000) * 1000;
+        const deadline = Date.now() + timeoutMs;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = 'Bearer ' + this.apiKey;
+        }
+        const spawnRes = await fetch(this.gatewayUrl + '/api/sessions/spawn', {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                task,
+                mode: 'run',
+                model: options?.model,
+                runTimeoutSeconds: options?.timeout,
+            }),
+        });
+        if (!spawnRes.ok) {
+            const text = await spawnRes.text();
+            throw new Error('Gateway spawn failed: HTTP ' +
+                spawnRes.status.toString() +
+                ' - ' +
+                text);
+        }
+        const spawnData = (await spawnRes.json());
+        if (!spawnData.sessionKey) {
+            throw new Error('Gateway spawn returned no sessionKey: ' + JSON.stringify(spawnData));
+        }
+        const { sessionKey } = spawnData;
+        // Poll for completion
+        while (Date.now() < deadline) {
+            await sleep$1(this.pollIntervalMs);
+            const historyRes = await fetch(this.gatewayUrl +
+                '/api/sessions/' +
+                encodeURIComponent(sessionKey) +
+                '/history?limit=50', { headers });
+            if (!historyRes.ok)
+                continue;
+            const history = (await historyRes.json());
+            if (history.status === 'completed' || history.status === 'done') {
+                // Extract token usage from session-level or message-level usage
+                let tokens;
+                if (history.usage?.totalTokens) {
+                    tokens = history.usage.totalTokens;
+                }
+                else {
+                    // Sum message-level usage as fallback
+                    let sum = 0;
+                    for (const msg of history.messages ?? []) {
+                        if (msg.usage?.totalTokens)
+                            sum += msg.usage.totalTokens;
+                    }
+                    if (sum > 0)
+                        tokens = sum;
+                }
+                // Extract the last assistant message as output
+                const messages = history.messages ?? [];
+                for (let i = messages.length - 1; i >= 0; i--) {
+                    if (messages[i].role === 'assistant' && messages[i].content) {
+                        return { output: messages[i].content, tokens };
+                    }
+                }
+                return { output: '', tokens };
+            }
+        }
+        throw new Error('Synthesis subprocess timed out after ' + timeoutMs.toString() + 'ms');
+    }
+}
+
+/**
+ * File-system lock for preventing concurrent synthesis on the same meta.
+ *
+ * Lock file: .meta/.lock containing PID + timestamp.
+ * Stale timeout: 30 minutes.
+ *
+ * @module lock
+ */
+const LOCK_FILE = '.lock';
+const STALE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+/**
+ * Attempt to acquire a lock on a .meta directory.
+ *
+ * @param metaPath - Absolute path to the .meta directory.
+ * @returns True if lock was acquired, false if already locked (non-stale).
+ */
+function acquireLock(metaPath) {
+    const lockPath = join(metaPath, LOCK_FILE);
+    if (existsSync(lockPath)) {
+        try {
+            const raw = readFileSync(lockPath, 'utf8');
+            const data = JSON.parse(raw);
+            const lockAge = Date.now() - new Date(data.startedAt).getTime();
+            if (lockAge < STALE_TIMEOUT_MS) {
+                return false; // Lock is active
+            }
+            // Stale lock — fall through to overwrite
+        }
+        catch {
+            // Corrupt lock file — overwrite
+        }
+    }
+    const lock = {
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+    };
+    writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n');
+    return true;
+}
+/**
+ * Release a lock on a .meta directory.
+ *
+ * @param metaPath - Absolute path to the .meta directory.
+ */
+function releaseLock(metaPath) {
+    const lockPath = join(metaPath, LOCK_FILE);
+    try {
+        unlinkSync(lockPath);
+    }
+    catch {
+        // Already removed or never existed
+    }
+}
+/**
+ * Check if a .meta directory is currently locked (non-stale).
+ *
+ * @param metaPath - Absolute path to the .meta directory.
+ * @returns True if locked and not stale.
+ */
+function isLocked(metaPath) {
+    const lockPath = join(metaPath, LOCK_FILE);
+    if (!existsSync(lockPath))
+        return false;
+    try {
+        const raw = readFileSync(lockPath, 'utf8');
+        const data = JSON.parse(raw);
+        const lockAge = Date.now() - new Date(data.startedAt).getTime();
+        return lockAge < STALE_TIMEOUT_MS;
+    }
+    catch {
+        return false; // Corrupt lock = not locked
+    }
 }
 
 /**
@@ -840,120 +1038,6 @@ function mergeAndWrite(options) {
     return result.data;
 }
 
-/**
- * Shared error utilities.
- *
- * @module errors
- */
-/**
- * Wrap an unknown caught value into a SynthError.
- *
- * @param step - Which synthesis step failed.
- * @param err - The caught error value.
- * @param code - Error classification code.
- * @returns A structured SynthError.
- */
-function toSynthError(step, err, code = 'FAILED') {
-    return {
-        step,
-        code,
-        message: err instanceof Error ? err.message : String(err),
-    };
-}
-
-/**
- * File-system lock for preventing concurrent synthesis on the same meta.
- *
- * Lock file: .meta/.lock containing PID + timestamp.
- * Stale timeout: 30 minutes.
- *
- * @module lock
- */
-const LOCK_FILE = '.lock';
-const STALE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
-/**
- * Attempt to acquire a lock on a .meta directory.
- *
- * @param metaPath - Absolute path to the .meta directory.
- * @returns True if lock was acquired, false if already locked (non-stale).
- */
-function acquireLock(metaPath) {
-    const lockPath = join(metaPath, LOCK_FILE);
-    if (existsSync(lockPath)) {
-        try {
-            const raw = readFileSync(lockPath, 'utf8');
-            const data = JSON.parse(raw);
-            const lockAge = Date.now() - new Date(data.startedAt).getTime();
-            if (lockAge < STALE_TIMEOUT_MS) {
-                return false; // Lock is active
-            }
-            // Stale lock — fall through to overwrite
-        }
-        catch {
-            // Corrupt lock file — overwrite
-        }
-    }
-    const lock = {
-        pid: process.pid,
-        startedAt: new Date().toISOString(),
-    };
-    writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n');
-    return true;
-}
-/**
- * Release a lock on a .meta directory.
- *
- * @param metaPath - Absolute path to the .meta directory.
- */
-function releaseLock(metaPath) {
-    const lockPath = join(metaPath, LOCK_FILE);
-    try {
-        unlinkSync(lockPath);
-    }
-    catch {
-        // Already removed or never existed
-    }
-}
-/**
- * Check if a .meta directory is currently locked (non-stale).
- *
- * @param metaPath - Absolute path to the .meta directory.
- * @returns True if locked and not stale.
- */
-function isLocked(metaPath) {
-    const lockPath = join(metaPath, LOCK_FILE);
-    if (!existsSync(lockPath))
-        return false;
-    try {
-        const raw = readFileSync(lockPath, 'utf8');
-        const data = JSON.parse(raw);
-        const lockAge = Date.now() - new Date(data.startedAt).getTime();
-        return lockAge < STALE_TIMEOUT_MS;
-    }
-    catch {
-        return false; // Corrupt lock = not locked
-    }
-}
-
-/**
- * Normalize file paths to forward slashes for consistency with watcher-indexed paths.
- *
- * Watcher indexes paths with forward slashes (`j:/domains/...`). This utility
- * ensures all paths in the library use the same convention, regardless of
- * the platform's native separator.
- *
- * @module normalizePath
- */
-/**
- * Normalize a file path to forward slashes.
- *
- * @param p - File path (may contain backslashes).
- * @returns Path with all backslashes replaced by forward slashes.
- */
-function normalizePath(p) {
-    return p.replaceAll('\\', '/');
-}
-
 /**
  * Select the best synthesis candidate from stale metas.
  *
@@ -1210,17 +1294,32 @@ function finalizeCycle(metaPath, current, config, architect, builder, critic, bu
  * @param watcher - Watcher HTTP client.
  * @returns Result indicating whether synthesis occurred.
  */
-async function orchestrateOnce(config, executor, watcher) {
-    // Step 1: Discover
-    const metaPaths = globMetas(config.watchPaths);
+async function orchestrateOnce(config, executor, watcher, targetPath) {
+    // Step 1: Discover via watcher scan
+    const metaPaths = await discoverMetas(config, watcher);
     if (metaPaths.length === 0)
         return { synthesized: false };
-    // Ensure all meta.json files exist
+    // Read meta.json for each discovered meta
     const metas = new Map();
     for (const mp of metaPaths) {
-        metas.set(normalizePath(mp), ensureMetaJson(mp));
+        const metaFilePath = join(mp, 'meta.json');
+        try {
+            metas.set(normalizePath$1(mp), JSON.parse(readFileSync(metaFilePath, 'utf8')));
+        }
+        catch {
+            // Skip metas with unreadable meta.json
+            continue;
+        }
     }
     const tree = buildOwnershipTree(metaPaths);
+    // If targetPath specified, skip candidate selection — go directly to that meta
+    let targetNode;
+    if (targetPath) {
+        const normalized = normalizePath$1(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()) {
@@ -1255,9 +1354,13 @@ async function orchestrateOnce(config, executor, watcher) {
         winner = candidate;
         break;
     }
-    if (!winner)
+    if (!winner && !targetNode)
         return { synthesized: false };
-    const { node } = winner;
+    const node = targetNode ?? winner.node;
+    // For targeted path, acquire lock now (candidate selection already locked for stalest)
+    if (targetNode && !acquireLock(node.metaPath)) {
+        return { synthesized: false };
+    }
     try {
         // Re-read meta after lock (may have changed)
         const currentMeta = JSON.parse(readFileSync(join(node.metaPath, 'meta.json'), 'utf8'));
@@ -1367,12 +1470,13 @@ async function orchestrateOnce(config, executor, watcher) {
  * @param config - Validated synthesis config.
  * @param executor - Pluggable LLM executor.
  * @param watcher - Watcher HTTP client.
+ * @param targetPath - Optional: specific meta/owner path to synthesize instead of stalest candidate.
  * @returns Array of results, one per cycle attempted.
  */
-async function orchestrate(config, executor, watcher) {
+async function orchestrate(config, executor, watcher, targetPath) {
     const results = [];
     for (let i = 0; i < config.batchSize; i++) {
-        const result = await orchestrateOnce(config, executor, watcher);
+        const result = await orchestrateOnce(config, executor, watcher, targetPath);
         results.push(result);
         if (!result.synthesized)
             break; // No more candidates
@@ -1380,134 +1484,6 @@ async function orchestrate(config, executor, watcher) {
     return results;
 }
 
-/**
- * Factory for creating a bound synthesis engine.
- *
- * @module engine
- */
-/**
- * Create a synthesis engine with bound config, executor, and watcher client.
- *
- * @param config - Validated synthesis config.
- * @param executor - Pluggable LLM executor.
- * @param watcher - Watcher HTTP client.
- * @returns A bound engine instance.
- */
-function createSynthEngine(config, executor, watcher) {
-    return {
-        config,
-        synthesize() {
-            return orchestrate(config, executor, watcher);
-        },
-        synthesizePath(ownerPath) {
-            const scopedConfig = { ...config, watchPaths: [ownerPath] };
-            return orchestrate(scopedConfig, executor, watcher);
-        },
-    };
-}
-
-/**
- * SynthExecutor implementation using the OpenClaw gateway HTTP API.
- *
- * Lives in the library package so both plugin and runner can import it.
- * Spawns sub-agent sessions via the gateway, polls for completion,
- * and extracts output text.
- *
- * @module executor/GatewayExecutor
- */
-const DEFAULT_POLL_INTERVAL_MS = 5000;
-const DEFAULT_TIMEOUT_MS = 600_000; // 10 minutes
-/** Sleep helper. */
-function sleep$1(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * SynthExecutor that spawns OpenClaw sessions via the gateway HTTP API.
- *
- * Used by both the OpenClaw plugin (in-process tool calls) and the
- * runner/CLI (external invocation). Constructs from `gatewayUrl` and
- * optional `apiKey` — typically sourced from `SynthConfig`.
- */
-class GatewayExecutor {
-    gatewayUrl;
-    apiKey;
-    pollIntervalMs;
-    constructor(options = {}) {
-        this.gatewayUrl = (options.gatewayUrl ?? 'http://127.0.0.1:3000').replace(/\/+$/, '');
-        this.apiKey = options.apiKey;
-        this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-    }
-    async spawn(task, options) {
-        const timeoutMs = (options?.timeout ?? DEFAULT_TIMEOUT_MS / 1000) * 1000;
-        const deadline = Date.now() + timeoutMs;
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        if (this.apiKey) {
-            headers['Authorization'] = 'Bearer ' + this.apiKey;
-        }
-        const spawnRes = await fetch(this.gatewayUrl + '/api/sessions/spawn', {
-            method: 'POST',
-            headers,
-            body: JSON.stringify({
-                task,
-                mode: 'run',
-                model: options?.model,
-                runTimeoutSeconds: options?.timeout,
-            }),
-        });
-        if (!spawnRes.ok) {
-            const text = await spawnRes.text();
-            throw new Error('Gateway spawn failed: HTTP ' +
-                spawnRes.status.toString() +
-                ' - ' +
-                text);
-        }
-        const spawnData = (await spawnRes.json());
-        if (!spawnData.sessionKey) {
-            throw new Error('Gateway spawn returned no sessionKey: ' + JSON.stringify(spawnData));
-        }
-        const { sessionKey } = spawnData;
-        // Poll for completion
-        while (Date.now() < deadline) {
-            await sleep$1(this.pollIntervalMs);
-            const historyRes = await fetch(this.gatewayUrl +
-                '/api/sessions/' +
-                encodeURIComponent(sessionKey) +
-                '/history?limit=50', { headers });
-            if (!historyRes.ok)
-                continue;
-            const history = (await historyRes.json());
-            if (history.status === 'completed' || history.status === 'done') {
-                // Extract token usage from session-level or message-level usage
-                let tokens;
-                if (history.usage?.totalTokens) {
-                    tokens = history.usage.totalTokens;
-                }
-                else {
-                    // Sum message-level usage as fallback
-                    let sum = 0;
-                    for (const msg of history.messages ?? []) {
-                        if (msg.usage?.totalTokens)
-                            sum += msg.usage.totalTokens;
-                    }
-                    if (sum > 0)
-                        tokens = sum;
-                }
-                // Extract the last assistant message as output
-                const messages = history.messages ?? [];
-                for (let i = messages.length - 1; i >= 0; i--) {
-                    if (messages[i].role === 'assistant' && messages[i].content) {
-                        return { output: messages[i].content, tokens };
-                    }
-                }
-                return { output: '', tokens };
-            }
-        }
-        throw new Error('Synthesis subprocess timed out after ' + timeoutMs.toString() + 'ms');
-    }
-}
-
 /**
  * HTTP implementation of the WatcherClient interface.
  *
@@ -1608,4 +1584,4 @@ class HttpWatcherClient {
     }
 }
 
-export { GatewayExecutor, HttpWatcherClient, acquireLock, actualStaleness, buildArchitectTask, buildBuilderTask, buildContextPackage, buildCriticTask, buildOwnershipTree, computeEffectiveStaleness, computeEma, computeStructureHash, createSnapshot, createSynthEngine, ensureMetaJson, filterInScope, findNode, getScopeExclusions, getScopePrefix, globMetas, hasSteerChanged, isArchitectTriggered, isLocked, isStale, listArchiveFiles, loadSynthConfig, mergeAndWrite, metaJsonSchema, normalizePath, orchestrate, paginatedScan, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, pruneArchive, readLatestArchive, releaseLock, resolveConfigPath, selectCandidate, synthConfigSchema, synthErrorSchema, toSynthError };
+export { GatewayExecutor, HttpWatcherClient, acquireLock, actualStaleness, buildArchitectTask, buildBuilderTask, buildContextPackage, buildCriticTask, buildMetaFilter, buildOwnershipTree, computeEffectiveStaleness, computeEma, computeStructureHash, createSnapshot, discoverMetas, filterInScope, findNode, getScopePrefix, hasSteerChanged, isArchitectTriggered, isLocked, isStale, listArchiveFiles, loadSynthConfig, mergeAndWrite, metaJsonSchema, normalizePath$1 as normalizePath, orchestrate, paginatedScan, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, pruneArchive, readLatestArchive, releaseLock, resolveConfigPath, selectCandidate, synthConfigSchema, synthErrorSchema, toSynthError };