@karmaniverous/jeeves-meta 0.2.2 → 0.3.0

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { readFileSync, readdirSync, unlinkSync, mkdirSync, writeFileSync, existsSync, statSync } from 'node:fs';
+import { readFileSync, readdirSync, unlinkSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
 import { dirname, join, relative, sep, resolve } from 'node:path';
 import { z } from 'zod';
-import { randomUUID, createHash } from 'node:crypto';
+import { createHash } from 'node:crypto';
 
 /**
  * Zod schema for jeeves-meta configuration.
@@ -15,7 +15,6 @@ import { randomUUID, createHash } from 'node:crypto';
 /** 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. */
@@ -48,6 +47,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'] }),
 });
 
 /**
@@ -310,81 +324,100 @@ var index$1 = /*#__PURE__*/Object.freeze({
 });
 
 /**
- * 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('\\', '/');
 }
 
 /**
- * Glob watchPaths for .meta/ directories.
+ * Paginated scan helper for exhaustive scope enumeration.
  *
- * Walks each watchPath recursively, collecting directories named '.meta'
- * that contain (or will contain) a meta.json file.
+ * @module paginatedScan
+ */
+/**
+ * Perform a paginated scan that follows cursor tokens until exhausted.
  *
- * @module discovery/globMetas
+ * @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;
+}
+
 /**
- * Recursively find all .meta/ directories under the given paths.
+ * Discover .meta/ directories via watcher scan.
+ *
+ * Replaces filesystem-based globMetas() with a watcher query
+ * that returns indexed .meta/meta.json points, filtered by domain.
  *
- * @param watchPaths - Root directories to search.
- * @returns Array of absolute paths to .meta/ directories.
+ * @module discovery/discoverMetas
  */
-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);
+/**
+ * Build a Qdrant filter from config metaProperty.
+ *
+ * @param config - Synth config with metaProperty.
+ * @returns Qdrant filter object for scanning live metas.
+ */
+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;
 }
 
 /**
@@ -397,7 +430,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('/');
 }
 /**
@@ -411,8 +444,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) {
@@ -535,26 +568,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
+    }
 }
 
 /**
@@ -846,120 +1053,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.
  *
@@ -1216,17 +1309,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()) {
@@ -1261,9 +1369,13 @@ async function orchestrateOnce(config, executor, watcher) {
         winner = candidate;
         break;
     }
-    if (!winner)
+    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)) {
         return { synthesized: false };
-    const { node } = winner;
+    }
     try {
         // Re-read meta after lock (may have changed)
         const currentMeta = JSON.parse(readFileSync(join(node.metaPath, 'meta.json'), 'utf8'));
@@ -1373,12 +1485,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
@@ -1386,108 +1499,6 @@ async function orchestrate(config, executor, watcher) {
     return results;
 }
 
-/**
- * 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.
  *
@@ -1604,16 +1615,16 @@ var index = /*#__PURE__*/Object.freeze({
     buildBuilderTask: buildBuilderTask,
     buildContextPackage: buildContextPackage,
     buildCriticTask: buildCriticTask,
+    buildMetaFilter: buildMetaFilter,
     buildOwnershipTree: buildOwnershipTree,
     computeEffectiveStaleness: computeEffectiveStaleness,
     computeEma: computeEma,
     computeStructureHash: computeStructureHash,
     createSnapshot: createSnapshot,
-    ensureMetaJson: ensureMetaJson,
+    discoverMetas: discoverMetas,
     filterInScope: filterInScope,
     findNode: findNode,
     getScopePrefix: getScopePrefix,
-    globMetas: globMetas,
     hasSteerChanged: hasSteerChanged,
     isArchitectTriggered: isArchitectTriggered,
     isLocked: isLocked,
@@ -1622,7 +1633,7 @@ var index = /*#__PURE__*/Object.freeze({
     loadSynthConfig: loadSynthConfig,
     mergeAndWrite: mergeAndWrite,
     metaJsonSchema: metaJsonSchema,
-    normalizePath: normalizePath,
+    normalizePath: normalizePath$1,
     orchestrate: orchestrate,
     paginatedScan: paginatedScan,
     parseArchitectOutput: parseArchitectOutput,
@@ -1648,6 +1659,10 @@ var index = /*#__PURE__*/Object.freeze({
  *
  * @module cli
  */
+/** Read and parse a meta.json file with proper typing. */
+function readMeta(metaPath) {
+    return JSON.parse(readFileSync(join(metaPath, 'meta.json'), 'utf8'));
+}
 const args = process.argv.slice(2);
 const command = args.find((a) => !a.startsWith('-'));
 const jsonOutput = args.includes('--json');
@@ -1683,8 +1698,9 @@ function output(data) {
         console.log(JSON.stringify(data, null, 2));
     }
 }
-function runStatus(config) {
-    const metaPaths = globMetas(config.watchPaths);
+async function runStatus(config) {
+    const watcher = new HttpWatcherClient({ baseUrl: config.watcherUrl });
+    const metaPaths = await discoverMetas(config, watcher);
     const tree = buildOwnershipTree(metaPaths);
     let stale = 0;
     let errors = 0;
@@ -1694,13 +1710,19 @@ function runStatus(config) {
     let buildTokens = 0;
     let critTokens = 0;
     for (const node of tree.nodes.values()) {
-        const meta = ensureMetaJson(node.metaPath);
+        let meta;
+        try {
+            meta = readMeta(node.metaPath);
+        }
+        catch {
+            continue;
+        }
         const s = actualStaleness(meta);
         if (s > 0)
             stale++;
         if (meta._error)
             errors++;
-        if (isLocked(normalizePath(node.metaPath)))
+        if (isLocked(normalizePath$1(node.metaPath)))
             locked++;
         if (!meta._generatedAt)
             neverSynth++;
@@ -1720,19 +1742,26 @@ function runStatus(config) {
         tokens: { architect: archTokens, builder: buildTokens, critic: critTokens },
     });
 }
-function runList(config) {
+async function runList(config) {
     const prefix = getArg('--prefix');
     const filter = getArg('--filter');
-    const metaPaths = globMetas(config.watchPaths);
+    const watcher = new HttpWatcherClient({ baseUrl: config.watcherUrl });
+    const metaPaths = await discoverMetas(config, watcher);
     const tree = buildOwnershipTree(metaPaths);
     const rows = [];
     for (const node of tree.nodes.values()) {
         if (prefix && !node.metaPath.includes(prefix))
             continue;
-        const meta = ensureMetaJson(node.metaPath);
+        let meta;
+        try {
+            meta = readMeta(node.metaPath);
+        }
+        catch {
+            continue;
+        }
         const s = actualStaleness(meta);
         const hasError = Boolean(meta._error);
-        const isLockedNow = isLocked(normalizePath(node.metaPath));
+        const isLockedNow = isLocked(normalizePath$1(node.metaPath));
         if (filter === 'hasError' && !hasError)
             continue;
         if (filter === 'stale' && s <= 0)
@@ -1759,15 +1788,16 @@ async function runDetail(config) {
         process.exit(1);
     }
     const archiveArg = getArg('--archive');
-    const metaPaths = globMetas(config.watchPaths);
+    const watcher = new HttpWatcherClient({ baseUrl: config.watcherUrl });
+    const metaPaths = await discoverMetas(config, watcher);
     const tree = buildOwnershipTree(metaPaths);
-    const normalized = normalizePath(targetPath);
+    const normalized = normalizePath$1(targetPath);
     const node = findNode(tree, normalized);
     if (!node) {
         console.error('Meta not found: ' + targetPath);
         process.exit(1);
     }
-    const meta = ensureMetaJson(node.metaPath);
+    const meta = readMeta(node.metaPath);
     const result = { meta };
     if (archiveArg) {
         const { listArchiveFiles } = await Promise.resolve().then(function () { return index$1; });
@@ -1784,12 +1814,12 @@ async function runDetail(config) {
 async function runPreview(config) {
     const targetPath = getArg('--path');
     const { filterInScope, paginatedScan, readLatestArchive, computeStructureHash, selectCandidate, } = await Promise.resolve().then(function () { return index; });
-    const metaPaths = globMetas(config.watchPaths);
-    const tree = buildOwnershipTree(metaPaths);
     const watcher = new HttpWatcherClient({ baseUrl: config.watcherUrl });
+    const metaPaths = await discoverMetas(config, watcher);
+    const tree = buildOwnershipTree(metaPaths);
     let targetNode;
     if (targetPath) {
-        const normalized = normalizePath(targetPath);
+        const normalized = normalizePath$1(targetPath);
         targetNode = findNode(tree, normalized);
         if (!targetNode) {
             console.error('Meta not found: ' + targetPath);
@@ -1799,7 +1829,13 @@ async function runPreview(config) {
     else {
         const candidates = [];
         for (const node of tree.nodes.values()) {
-            const meta = ensureMetaJson(node.metaPath);
+            let meta;
+            try {
+                meta = readMeta(node.metaPath);
+            }
+            catch {
+                continue;
+            }
             const s = actualStaleness(meta);
             if (s > 0)
                 candidates.push({ node, meta, actualStaleness: s });
@@ -1812,7 +1848,7 @@ async function runPreview(config) {
         }
         targetNode = winner.node;
     }
-    const meta = ensureMetaJson(targetNode.metaPath);
+    const meta = readMeta(targetNode.metaPath);
     const allFiles = await paginatedScan(watcher, {
         pathPrefix: targetNode.ownerPath,
     });
@@ -1840,9 +1876,6 @@ async function runSynthesize(config) {
     const batchArg = getArg('--batch');
     const effectiveConfig = {
         ...config,
-        ...(targetPath
-            ? { watchPaths: [targetPath.replace(/[/\\]\.meta[/\\]?$/, '')] }
-            : {}),
         ...(batchArg ? { batchSize: parseInt(batchArg, 10) } : {}),
     };
     const executor = new GatewayExecutor({
@@ -1850,7 +1883,7 @@ async function runSynthesize(config) {
         apiKey: config.gatewayApiKey,
     });
     const watcher = new HttpWatcherClient({ baseUrl: config.watcherUrl });
-    const results = await orchestrate(effectiveConfig, executor, watcher);
+    const results = await orchestrate(effectiveConfig, executor, watcher, targetPath ?? undefined);
     const synthesized = results.filter((r) => r.synthesized);
     output({
         synthesizedCount: synthesized.length,
@@ -1921,9 +1954,16 @@ async function runValidate(config) {
     catch {
         checks.gateway = 'UNREACHABLE (' + config.gatewayUrl + ')';
     }
-    // Check watch paths
-    const metaPaths = globMetas(config.watchPaths);
-    checks.metas = String(metaPaths.length) + ' .meta/ directories found';
+    // Check meta discovery via watcher
+    try {
+        const watcherClient = new HttpWatcherClient({ baseUrl: config.watcherUrl });
+        const metaPaths = await discoverMetas(config, watcherClient);
+        checks.metas =
+            String(metaPaths.length) + ' .meta/ entities discovered via watcher';
+    }
+    catch {
+        checks.metas = 'FAILED — could not discover metas (watcher may be down)';
+    }
     output({ config: 'valid', checks });
 }
 function runConfigShow(config) {
@@ -1983,10 +2023,10 @@ async function main() {
     }
     switch (command) {
         case 'status':
-            runStatus(config);
+            await runStatus(config);
             break;
         case 'list':
-            runList(config);
+            await runList(config);
             break;
         case 'detail':
             await runDetail(config);