claude-flow 3.16.3 → 3.18.0

package/v3/@claude-flow/cli/dist/src/mcp-tools/metaharness-tools.js

@@ -24,6 +24,13 @@
  *
  *   - metaharness_redblue        red-team → judge → blue-patch → retest → report
  *
+ * metaharness@0.3.0 + @metaharness/darwin@0.8.0 add two more:
+ *
+ *   - metaharness_learn          upstream ADR-235 GEPA learning run ($0 dry-run
+ *                                default; run=true to spend; needs repo checkout)
+ *   - metaharness_gepa           GEPA library surface — genome load/validate/
+ *                                render + transcript failure analysis
+ *
  * Every tool resolves the corresponding plugin script
  * (`plugins/ruflo-metaharness/scripts/<X>.mjs`) via the same locator
  * the commands/metaharness.ts dispatcher uses, then spawns it with
@@ -591,5 +598,87 @@ export const metaharnessTools = [
             return { success: r.success, data: r.json, degraded: r.degraded, exitCode: r.exitCode };
         },
     },
+    // ───────────────────────────────────────────────────────────────────────
+    // metaharness@0.3.0 `learn` + @metaharness/darwin@0.8.0 GEPA (2 tools).
+    //
+    // learn — upstream ADR-235 GEPA learning run. $0 dry-run by default;
+    // spending requires the explicit `run: true` opt-in, forwarded as --run.
+    // Requires a metaharness repo checkout (the learning harness is too heavy
+    // for the npm package) — absent checkout returns a structured
+    // {status: "checkout-required"} payload, distinct from degraded.
+    //
+    // gepa — the darwin GEPA *library* surface (genome load/validate/render,
+    // transcript analysis). gepaOptimize itself is deliberately NOT exposed:
+    // it takes an in-process evaluate() callback that cannot cross the
+    // subprocess boundary; optimization runs live behind metaharness_evolve.
+    // ───────────────────────────────────────────────────────────────────────
+    {
+        name: 'metaharness_learn',
+        description: 'ADR-235 (upstream) — GEPA learning run via `metaharness learn`: optimizes a harness genome against a SWE-bench-style slice manifest. $0 DRY-RUN BY DEFAULT — it resolves the slice and prices the run without model calls; pass run=true to actually spend (model calls + Docker sandboxes). Requires a local metaharness repo checkout (repo param or $METAHARNESS_REPO); without one the tool returns {status:"checkout-required"} with clone instructions — that is a precondition report, not an error. Use when you want the harness policy to LEARN from a task corpus rather than hand-editing prompts; manual prompt tweaking is wrong because GEPA scores candidates against held-out slices and only promotes measured winners. Long real runs exceed the 120s MCP subprocess budget — run those via `ruflo metaharness learn` in a terminal instead. ' + MCP_SUCCESS_SEMANTIC,
+        category: 'metaharness',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                host: { type: 'string', description: 'Target host harness (e.g. claude-code, codex, pi-dev, hermes)' },
+                model: { type: 'string', description: 'Model to learn against (upstream model id)' },
+                slice: { type: 'string', description: 'Path to a slice manifest JSON' },
+                repo: { type: 'string', description: 'Path to a metaharness repo checkout (sets $METAHARNESS_REPO)' },
+                run: { type: 'boolean', description: 'EXPLICIT SPEND OPT-IN — without this the run is a $0 dry-run', default: false },
+                alertOnFail: { type: 'boolean', description: 'Exit 1 when the learn run reports failure', default: false },
+                timeoutMs: { type: 'number', description: 'Subprocess hard timeout override' },
+            },
+        },
+        handler: async (input) => {
+            const args = [];
+            if (input.host)
+                args.push('--host', String(input.host));
+            if (input.model)
+                args.push('--model', String(input.model));
+            if (input.slice)
+                args.push('--slice', String(input.slice));
+            if (input.repo)
+                args.push('--repo', String(input.repo));
+            if (input.run === true)
+                args.push('--run');
+            if (input.alertOnFail === true)
+                args.push('--alert-on-fail');
+            if (input.timeoutMs !== undefined)
+                args.push('--timeout-ms', String(input.timeoutMs));
+            const r = await runScript('learn.mjs', args);
+            return { success: r.success, data: r.json, degraded: r.degraded, exitCode: r.exitCode };
+        },
+    },
+    {
+        name: 'metaharness_gepa',
+        description: 'GEPA genome operations from the `@metaharness/darwin/gepa` library entry (darwin 0.8.0). op=genome loads + validates a genome (default: the shipped cand-6 — first holdout-confirmed cheap-tier policy promotion, provenance in the package); op=validate returns structural errors for a genome JSON; op=render compiles a genome to the system prompt it encodes (inspect what a policy actually says before adopting it); op=analyze classifies failure modes in a transcript JSON array. Use when adopting/auditing/debugging evolved harness policies — reading genome JSON by eye is wrong because the behavior lives in the rendered system prompt and the component interactions, not the raw fields. NOTE: gepaOptimize (bring-your-own-evaluator optimization) is library-only — import @metaharness/darwin/gepa directly, or use metaharness_evolve for sandbox-scored evolution. ' + MCP_SUCCESS_SEMANTIC,
+        category: 'metaharness',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                op: { type: 'string', enum: ['genome', 'validate', 'render', 'analyze'], description: 'genome = load + validate; validate = structural errors only; render = genome → system prompt; analyze = transcript failure classes' },
+                path: { type: 'string', description: 'Genome JSON path (genome/validate/render; default: shipped cand-6)' },
+                transcript: { type: 'string', description: 'Transcript JSON array path (required for op=analyze)' },
+                ext: { type: 'string', description: 'render only — target file extension hint' },
+                glob: { type: 'string', description: 'render only — target glob hint' },
+                alertOnInvalid: { type: 'boolean', description: 'Exit 1 when validation finds errors (gate-style)', default: false },
+            },
+            required: ['op'],
+        },
+        handler: async (input) => {
+            const args = ['--op', String(input.op)];
+            if (input.path)
+                args.push('--path', String(input.path));
+            if (input.transcript)
+                args.push('--transcript', String(input.transcript));
+            if (input.ext)
+                args.push('--ext', String(input.ext));
+            if (input.glob)
+                args.push('--glob', String(input.glob));
+            if (input.alertOnInvalid === true)
+                args.push('--alert-on-invalid');
+            const r = await runScript('gepa.mjs', args);
+            return { success: r.success, data: r.json, degraded: r.degraded, exitCode: r.exitCode };
+        },
+    },
 ];
 //# sourceMappingURL=metaharness-tools.js.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/neural-tools.js

@@ -15,99 +15,120 @@ import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText } from './validate-input.js';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-// Try to import real embeddings.
-// Tier 0 (NEW, ADR-089): ruvector@0.2.27 bundled ONNX (no sharp dep, fixes ADR-086's
+// Real embeddings — resolved LAZILY on first use.
+// Perf (measured 2026-07): the previous top-level-await version of this block
+// ran `await import('ruvector')` + `initOnnxEmbedder()` + a probe embed at
+// module-import time, adding ~450ms (warm) to ~2800ms (cold) to EVERY CLI
+// command, because mcp-client statically imports this module. ensureEmbeddings()
+// keeps the exact same tier chain and degraded/fallback semantics, but only
+// pays the cost when a handler actually needs an embedding.
+// Tier 0 (ADR-089): ruvector@0.2.27 bundled ONNX (no sharp dep, fixes ADR-086's
 //   silent-fallback bug at source; closes the chain described in ruvnet/ruvector#523).
 // Tier 1: agentic-flow v3 ReasoningBank (was Tier 1 — broken on darwin-arm64 without sharp)
 // Tier 2-3: @claude-flow/embeddings
 let realEmbeddings = null;
 let embeddingServiceName = 'none';
-try {
-    // Tier 0: ruvector@0.2.27 — bundled all-MiniLM-L6-v2 + parallel worker pool.
-    // Probe with isOnnxAvailable() and verify an actual embed succeeds (avoids
-    // the type-load-success-but-runtime-fails trap from ADR-086).
-    // NOTE: ruvector's embed() returns `{embedding, dimension, timeMs}` — we
-    // unwrap to plain number[] for the shared interface.
-    const rv = await import('ruvector').catch(() => null);
-    if (rv?.embed && typeof rv.embed === 'function' && rv.isOnnxAvailable?.()) {
+let embeddingsPromise = null;
+/**
+ * Memoized lazy initialiser for the embedding provider chain. Safe to call
+ * concurrently (single shared promise). If every tier fails to import or
+ * probe, `realEmbeddings` stays null and callers use the explicit
+ * hash-fallback path — identical degraded semantics to the old eager block.
+ */
+function ensureEmbeddings() {
+    if (embeddingsPromise)
+        return embeddingsPromise;
+    embeddingsPromise = (async () => {
         try {
-            if (typeof rv.initOnnxEmbedder === 'function')
-                await rv.initOnnxEmbedder();
-            const probe = await rv.embed('probe');
-            // Handle both shapes: ruvector wraps as {embedding, dimension, timeMs};
-            // some versions returned raw Float32Array.
-            const probeVec = probe?.embedding ?? probe;
-            if (probeVec && (Array.isArray(probeVec) || probeVec.length > 0)) {
-                realEmbeddings = {
-                    embed: async (text) => {
-                        const r = await rv.embed(text);
-                        const v = r?.embedding ?? r;
-                        return Array.isArray(v) ? v : Array.from(v);
-                    },
-                };
-                embeddingServiceName = 'ruvector@0.2.27 (bundled all-MiniLM-L6-v2)';
-            }
-        }
-        catch {
-            // ruvector embed failed at runtime; fall through to next tier
-        }
-    }
-    // Tier 1: agentic-flow v3 ReasoningBank (kept for backward-compat; may
-    // silently fall back on darwin-arm64 without sharp — that's the bug
-    // Tier 0 was added to bypass).
-    if (!realEmbeddings) {
-        const rb = await import('agentic-flow/reasoningbank').catch(() => null);
-        if (rb?.computeEmbedding) {
-            realEmbeddings = { embed: (text) => rb.computeEmbedding(text) };
-            embeddingServiceName = 'agentic-flow/reasoningbank';
-        }
-    }
-    // Tier 2: @claude-flow/embeddings with agentic-flow provider
-    if (!realEmbeddings) {
-        const embeddingsModule = await import('@claude-flow/embeddings').catch(() => null);
-        if (embeddingsModule?.createEmbeddingService) {
-            try {
-                const service = embeddingsModule.createEmbeddingService({ provider: 'agentic-flow' });
-                realEmbeddings = {
-                    embed: async (text) => {
-                        const result = await service.embed(text);
-                        return Array.from(result.embedding);
-                    },
-                };
-                embeddingServiceName = 'agentic-flow';
+            // Tier 0: ruvector@0.2.27 — bundled all-MiniLM-L6-v2 + parallel worker pool.
+            // Probe with isOnnxAvailable() and verify an actual embed succeeds (avoids
+            // the type-load-success-but-runtime-fails trap from ADR-086). The probe now
+            // runs on first embed request instead of at import time.
+            // NOTE: ruvector's embed() returns `{embedding, dimension, timeMs}` — we
+            // unwrap to plain number[] for the shared interface.
+            const rv = await import('ruvector').catch(() => null);
+            if (rv?.embed && typeof rv.embed === 'function' && rv.isOnnxAvailable?.()) {
+                try {
+                    if (typeof rv.initOnnxEmbedder === 'function')
+                        await rv.initOnnxEmbedder();
+                    const probe = await rv.embed('probe');
+                    // Handle both shapes: ruvector wraps as {embedding, dimension, timeMs};
+                    // some versions returned raw Float32Array.
+                    const probeVec = probe?.embedding ?? probe;
+                    if (probeVec && (Array.isArray(probeVec) || probeVec.length > 0)) {
+                        realEmbeddings = {
+                            embed: async (text) => {
+                                const r = await rv.embed(text);
+                                const v = r?.embedding ?? r;
+                                return Array.isArray(v) ? v : Array.from(v);
+                            },
+                        };
+                        embeddingServiceName = 'ruvector@0.2.27 (bundled all-MiniLM-L6-v2)';
+                    }
+                }
+                catch {
+                    // ruvector embed failed at runtime; fall through to next tier
+                }
             }
-            catch {
-                // agentic-flow provider not available, try ONNX
+            // Tier 1: agentic-flow v3 ReasoningBank (kept for backward-compat; may
+            // silently fall back on darwin-arm64 without sharp — that's the bug
+            // Tier 0 was added to bypass).
+            if (!realEmbeddings) {
+                const rb = await import('agentic-flow/reasoningbank').catch(() => null);
+                if (rb?.computeEmbedding) {
+                    realEmbeddings = { embed: (text) => rb.computeEmbedding(text) };
+                    embeddingServiceName = 'agentic-flow/reasoningbank';
+                }
             }
-        }
-    }
-    // Tier 3: @claude-flow/embeddings with ONNX provider
-    if (!realEmbeddings) {
-        const embeddingsModule = await import('@claude-flow/embeddings').catch(() => null);
-        if (embeddingsModule?.createEmbeddingService) {
-            try {
-                const service = embeddingsModule.createEmbeddingService({ provider: 'onnx' });
-                realEmbeddings = {
-                    embed: async (text) => {
-                        const result = await service.embed(text);
-                        return Array.from(result.embedding);
-                    },
-                };
-                embeddingServiceName = 'onnx';
+            // Tier 2: @claude-flow/embeddings with agentic-flow provider
+            if (!realEmbeddings) {
+                const embeddingsModule = await import('@claude-flow/embeddings').catch(() => null);
+                if (embeddingsModule?.createEmbeddingService) {
+                    try {
+                        const service = embeddingsModule.createEmbeddingService({ provider: 'agentic-flow' });
+                        realEmbeddings = {
+                            embed: async (text) => {
+                                const result = await service.embed(text);
+                                return Array.from(result.embedding);
+                            },
+                        };
+                        embeddingServiceName = 'agentic-flow';
+                    }
+                    catch {
+                        // agentic-flow provider not available, try ONNX
+                    }
+                }
             }
-            catch {
-                // ONNX provider not available, fall through to mock
+            // Tier 3: @claude-flow/embeddings with ONNX provider
+            if (!realEmbeddings) {
+                const embeddingsModule = await import('@claude-flow/embeddings').catch(() => null);
+                if (embeddingsModule?.createEmbeddingService) {
+                    try {
+                        const service = embeddingsModule.createEmbeddingService({ provider: 'onnx' });
+                        realEmbeddings = {
+                            embed: async (text) => {
+                                const result = await service.embed(text);
+                                return Array.from(result.embedding);
+                            },
+                        };
+                        embeddingServiceName = 'onnx';
+                    }
+                    catch {
+                        // ONNX provider not available, fall through to mock
+                    }
+                }
             }
+            // No Tier 4 mock fallback. If all real-embedder tiers fail to import or
+            // probe, leave realEmbeddings null and let downstream code use the
+            // explicit hash-fallback path with a clear _embeddingNote in stats.
+            // Silently substituting mock embeddings would hide a missing production
+            // dependency from callers — that's the bug ADR-086 was about.
         }
-    }
-    // No Tier 4 mock fallback. If all real-embedder tiers fail to import or
-    // probe, leave realEmbeddings null and let downstream code use the
-    // explicit hash-fallback path with a clear _embeddingNote in stats.
-    // Silently substituting mock embeddings would hide a missing production
-    // dependency from callers — that's the bug ADR-086 was about.
-}
-catch {
-    // No embedding provider available, will use fallback
+        catch {
+            // No embedding provider available, will use fallback
+        }
+    })();
+    return embeddingsPromise;
 }
 // Storage paths
 const STORAGE_DIR = '.claude-flow';
@@ -173,8 +194,9 @@ export function getNeuralStoreStats() {
 export async function storeNeuralPatterns(items) {
     if (!items || items.length === 0)
         return { stored: 0, total: 0 };
-    // realEmbeddings is initialised by the top-level IIFE in this module;
-    // generateEmbedding() falls back to a hash-based embedding if it isn't.
+    // realEmbeddings is initialised lazily by ensureEmbeddings() (invoked from
+    // generateEmbedding()); it falls back to a hash-based embedding if no
+    // provider is available.
     const store = loadNeuralStore();
     let stored = 0;
     for (const item of items) {
@@ -200,6 +222,10 @@ export async function storeNeuralPatterns(items) {
 }
 // Generate embedding - uses real ML embeddings if available, falls back to deterministic hash
 async function generateEmbedding(text, dims = 384) {
+    // Lazily resolve the embedding provider on first real use (perf: keeps
+    // ONNX init off the CLI startup path — see ensureEmbeddings()).
+    if (text)
+        await ensureEmbeddings();
     // If real embeddings available and text provided, use them
     if (realEmbeddings && text) {
         try {
@@ -747,6 +773,9 @@ export const neuralTools = [
                 if (!v.valid)
                     return { success: false, error: v.error };
             }
+            // Resolve provider so embeddingProvider in the result matches the old
+            // eager-init reporting.
+            await ensureEmbeddings();
             const store = loadNeuralStore();
             const method = input.method || 'quantize';
             const targetReduction = input.targetSize || 0.5;
@@ -860,6 +889,9 @@ export const neuralTools = [
                 if (!v.valid)
                     return { success: false, error: v.error };
             }
+            // Resolve provider so _realEmbeddings/embeddingProvider report the same
+            // values the old eager-init version produced.
+            await ensureEmbeddings();
             const store = loadNeuralStore();
             if (input.modelId) {
                 const model = store.models[input.modelId];
@@ -928,6 +960,9 @@ export const neuralTools = [
                 if (!v.valid)
                     return { success: false, error: v.error };
             }
+            // Resolve provider so embeddingProvider in the result matches the old
+            // eager-init reporting.
+            await ensureEmbeddings();
             const store = loadNeuralStore();
             const target = input.target || 'balanced';
             const patterns = Object.values(store.patterns);

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.d.ts

@@ -419,14 +419,26 @@ export declare function bridgeHealthCheck(dbPath?: string): Promise<{
  *
  * Real HierarchicalMemory API (agentdb alpha.10+):
  *   store(content, importance?, tier?, options?) → Promise<string>
- * Stub API (fallback):
- *   store(key, value, tier) — synchronous
+ * Fallback API (@claude-flow/memory TieredMemoryStore):
+ *   store(key, value, tier, temporalOptions?) — synchronous, returns
+ *   { id, key, tier, superseded? }
+ *
+ * Temporal validity (Zep/Graphiti-style, impl/memory-sota):
+ * - validFrom / validUntil (ISO) travel with the entry.
+ * - supersedes=<entryId|key> INVALIDATES the old entry (validUntil=now +
+ *   supersededBy=newId) instead of deleting it. Natively supported by the
+ *   TieredMemoryStore fallback; on the real agentdb HierarchicalMemory the
+ *   temporal fields are stored in metadata, and supersede is reported as
+ *   unsupported (no public update API) rather than silently dropped.
  */
 export declare function bridgeHierarchicalStore(params: {
     key: string;
     value: string;
     tier?: string;
     importance?: number;
+    validFrom?: string;
+    validUntil?: string;
+    supersedes?: string;
 }): Promise<any>;
 /**
  * Recall from hierarchical memory.
@@ -441,6 +453,7 @@ export declare function bridgeHierarchicalRecall(params: {
     query: string;
     tier?: string;
     topK?: number;
+    includeExpired?: boolean;
 }): Promise<any>;
 /**
  * Run memory consolidation.

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.js

@@ -1970,8 +1970,17 @@ export async function bridgeHealthCheck(dbPath) {
  *
  * Real HierarchicalMemory API (agentdb alpha.10+):
  *   store(content, importance?, tier?, options?) → Promise<string>
- * Stub API (fallback):
- *   store(key, value, tier) — synchronous
+ * Fallback API (@claude-flow/memory TieredMemoryStore):
+ *   store(key, value, tier, temporalOptions?) — synchronous, returns
+ *   { id, key, tier, superseded? }
+ *
+ * Temporal validity (Zep/Graphiti-style, impl/memory-sota):
+ * - validFrom / validUntil (ISO) travel with the entry.
+ * - supersedes=<entryId|key> INVALIDATES the old entry (validUntil=now +
+ *   supersededBy=newId) instead of deleting it. Natively supported by the
+ *   TieredMemoryStore fallback; on the real agentdb HierarchicalMemory the
+ *   temporal fields are stored in metadata, and supersede is reported as
+ *   unsupported (no public update API) rather than silently dropped.
  */
 export async function bridgeHierarchicalStore(params) {
     const registry = await getRegistry();
@@ -1984,15 +1993,36 @@ export async function bridgeHierarchicalStore(params) {
         const tier = params.tier || 'working';
         // Detect real HierarchicalMemory (has async store returning id) vs stub
         if (typeof hm.getStats === 'function' && typeof hm.promote === 'function') {
-            // Real agentdb HierarchicalMemory
+            // Real agentdb HierarchicalMemory — temporal fields ride in metadata
+            // so bridgeHierarchicalRecall can filter on them.
+            const metadata = { key: params.key };
+            if (params.validFrom)
+                metadata.validFrom = params.validFrom;
+            if (params.validUntil)
+                metadata.validUntil = params.validUntil;
             const id = await hm.store(params.value, params.importance || 0.5, tier, {
-                metadata: { key: params.key },
+                metadata,
                 tags: [params.key],
             });
-            return { success: true, id, key: params.key, tier };
+            const result = { success: true, id, key: params.key, tier };
+            if (params.supersedes) {
+                // No public update/invalidate API on agentdb HierarchicalMemory —
+                // surface the limitation honestly instead of silently dropping it.
+                result.superseded = null;
+                result.warning = 'supersedes is not supported by the native agentdb HierarchicalMemory backend (no update API); the referenced entry was left untouched';
+            }
+            return result;
+        }
+        // TieredMemoryStore fallback (temporal-aware) / legacy stub
+        const storeResult = hm.store(params.key, params.value, tier, {
+            validFrom: params.validFrom,
+            validUntil: params.validUntil,
+            supersedes: params.supersedes,
+        });
+        if (storeResult && typeof storeResult === 'object') {
+            return { success: true, ...storeResult };
         }
-        // Stub fallback
-        hm.store(params.key, params.value, tier);
+        // Legacy stub (returns void) — temporal options were ignored
         return { success: true, key: params.key, tier };
     }
     catch (e) {
@@ -2027,10 +2057,34 @@ export async function bridgeHierarchicalRecall(params) {
                 memoryQuery.tier = params.tier;
             }
             const results = await hm.recall(memoryQuery);
-            return { results: results || [], controller: 'hierarchicalMemory' };
+            // Temporal filter over metadata (validFrom/validUntil stamped by
+            // bridgeHierarchicalStore). Entries without the fields are always
+            // valid — legacy behavior unchanged.
+            const filtered = params.includeExpired
+                ? (results || [])
+                : (results || []).filter((r) => {
+                    const meta = r?.metadata || {};
+                    const now = Date.now();
+                    if (meta.validFrom) {
+                        const from = Date.parse(String(meta.validFrom));
+                        if (!Number.isNaN(from) && from > now)
+                            return false;
+                    }
+                    if (meta.validUntil) {
+                        const until = Date.parse(String(meta.validUntil));
+                        if (!Number.isNaN(until) && until <= now)
+                            return false;
+                    }
+                    return true;
+                });
+            return { results: filtered, controller: 'hierarchicalMemory' };
         }
-        // Stub fallback — recall(string, number)
-        const results = hm.recall(params.query, params.topK || 5);
+        // TieredMemoryStore fallback — recall(string, number, options?).
+        // Temporal filtering happens inside the store; the legacy stub simply
+        // ignores the extra argument.
+        const results = hm.recall(params.query, params.topK || 5, {
+            includeExpired: params.includeExpired === true,
+        });
         const filtered = params.tier
             ? results.filter((r) => r.tier === params.tier)
             : results;

package/v3/@claude-flow/cli/dist/src/ruvector/output-verifier.d.ts

@@ -0,0 +1,83 @@
+/**
+ * output-verifier.ts — Confidence-gated tier escalation (post-generation).
+ *
+ * ADR-026/143 route tasks to a tier BEFORE generation. 2026 SOTA cascade
+ * routing adds a post-generation gate: attempt the cheap tier, run a CHEAP
+ * verifier over the produced output, and escalate to the next tier only when
+ * the verifier is not confident. This module is that verifier.
+ *
+ * Design constraints (load-bearing):
+ * - $0 by default — NO LLM call. Every signal is a structural / lexical
+ *   check: emptiness, refusal patterns, truncation, delimiter balance,
+ *   degenerate repetition, and (for code tasks) a real syntax parse via the
+ *   TypeScript compiler (lazy-imported; degrades to delimiter checks when
+ *   typescript is not installed) or JSON.parse for JSON output.
+ * - Pure with respect to router state — recording the verdict into the
+ *   bandit's learning stream is the CALLER's job (the hooks_model-verify
+ *   MCP tool does it via ModelRouter.recordOutcome), keeping this module
+ *   trivially unit-testable.
+ * - Escalation ladder mirrors the tier table: tier 2 (haiku) → tier 3
+ *   (sonnet), sonnet → opus, opus has no bump (escalate=false even when the
+ *   verdict is not confident — the caller should retry or surface instead).
+ *
+ * Verdict semantics: `confident=false` means "cheap signals say this output
+ * is likely unusable"; it is NOT a semantic-quality judgment. False
+ * negatives (bad output that parses fine) are expected — this gate trades
+ * recall for being free.
+ *
+ * @module ruvector/output-verifier
+ */
+export type VerifyTier = 1 | 2 | 3;
+export type VerifyModel = 'haiku' | 'sonnet' | 'opus';
+export type VerifyTaskKind = 'code' | 'json' | 'text' | 'auto';
+export interface VerifyInput {
+    /** The task the output was generated for. */
+    task: string;
+    /** The generated output to verify. */
+    output: string;
+    /** Model that produced the output (drives the escalation ladder). */
+    model?: VerifyModel;
+    /** Tier that produced the output; derived from `model` when absent. */
+    tierUsed?: VerifyTier;
+    /** Force the task kind; 'auto' (default) detects from task + output. */
+    taskKind?: VerifyTaskKind;
+    /** Minimum trimmed output length considered plausible (default 20). */
+    minLength?: number;
+}
+export interface VerifySignal {
+    name: string;
+    ok: boolean;
+    detail?: string;
+}
+export interface VerifyVerdict {
+    confident: boolean;
+    /** Fraction of signals that passed (0..1). */
+    score: number;
+    /** Human-readable failure reasons; empty when confident. */
+    reasons: string[];
+    /** Every signal evaluated, pass or fail. */
+    signals: VerifySignal[];
+    /** Tier the caller should use next: unchanged when confident, bumped 2→3 on failure. */
+    suggestedTier: VerifyTier;
+    /** Concrete next model on the ladder (haiku→sonnet→opus); null when no bump exists. */
+    suggestedModel: VerifyModel | null;
+    /** True when not confident AND a higher tier exists to escalate to. */
+    escalate: boolean;
+    /** Detected task kind after 'auto' resolution. */
+    taskKind: Exclude<VerifyTaskKind, 'auto'>;
+}
+interface ExtractedCode {
+    lang: string;
+    code: string;
+}
+/** Pull fenced code blocks out of markdown-ish output. */
+export declare function extractCodeBlocks(output: string): ExtractedCode[];
+/** Cheap stack-based bracket balance check that skips string/comment-ish content. */
+export declare function bracketsBalanced(code: string): boolean;
+/**
+ * Compute a confidence verdict for `output` from cheap structural signals,
+ * and suggest an escalation target when not confident.
+ */
+export declare function verifyAndEscalate(input: VerifyInput): Promise<VerifyVerdict>;
+export default verifyAndEscalate;
+//# sourceMappingURL=output-verifier.d.ts.map