claude-flow 3.17.0 → 3.18.1

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/intelligence.js

@@ -14,6 +14,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { createRequire } from 'node:module';
 import { join } from 'node:path';
+import { resolveTrainingBackend } from '../ruvector/lora-adapter.js';
 // ============================================================================
 // Persistence Configuration
 // ============================================================================
@@ -1006,15 +1007,29 @@ export function getIntelligenceStats() {
         loadRuvllmCoordinatorSync();
     }
     const ruvllmStats = ruvllmCoordinator?.stats?.() || null;
-    // Fetch cross-module stats for unified reporting
+    // Fetch cross-module stats for unified reporting.
+    //
+    // #2549 — two prior defects here: `trainingBackend` was declared and
+    // returned but never assigned (always 'unavailable'), and contrastive
+    // availability was read ONLY from an in-process global that a fresh
+    // read-only `neural status` process never populates. Both made the
+    // native @ruvector/ruvllm path invisible even when installed. Backend
+    // now comes from the lora-adapter's capability probe; the global still
+    // wins when present because it carries live in-process session counts.
     let contrastiveTrainer = 'unavailable';
     let trainingBackend = 'unavailable';
     try {
-        // Synchronous check — contrastiveTrainer is module-level in sona-optimizer
-        // We read it via the SONAOptimizer singleton if available
+        trainingBackend = resolveTrainingBackend();
+    }
+    catch { /* module absent — stay 'unavailable' */ }
+    try {
         const sonaModule = globalThis.__claudeFlowSonaStats;
-        if (sonaModule) {
-            contrastiveTrainer = sonaModule._contrastiveTrainer || 'unavailable';
+        if (sonaModule?._contrastiveTrainer) {
+            contrastiveTrainer = sonaModule._contrastiveTrainer;
+        }
+        else if (trainingBackend === 'ruvllm') {
+            // Module resolves but no in-process session — available, idle.
+            contrastiveTrainer = 'available';
         }
     }
     catch { /* not available */ }

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/lora-adapter.d.ts

@@ -97,6 +97,15 @@ export interface LoRAStats {
     /** Training backend in use ('ruvllm' | 'js-fallback') */
     _trainingBackend?: string;
 }
+/**
+ * Which training backend a train call would use — WITHOUT loading the
+ * pipeline (#2549). Before this existed, status surfaces read module state
+ * that only a prior in-process train populates, so a fresh read-only
+ * process always reported 'js-fallback'/'unavailable' even with
+ * @ruvector/ruvllm installed. The pipeline stays lazy: this only probes
+ * module resolution.
+ */
+export declare function resolveTrainingBackend(): 'ruvllm' | 'js-fallback';
 /**
  * Low-Rank Adaptation module for efficient embedding fine-tuning
  */

package/v3/@claude-flow/cli/dist/src/ruvector/lora-adapter.js

@@ -19,6 +19,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
+import { createRequire } from 'module';
 // ============================================================================
 // Types & Constants
 // ============================================================================
@@ -57,6 +58,25 @@ const DEFAULT_CONFIG = {
 // ============================================================================
 let ruvllmPipeline = null;
 let pipelineLoaded = false;
+/**
+ * Which training backend a train call would use — WITHOUT loading the
+ * pipeline (#2549). Before this existed, status surfaces read module state
+ * that only a prior in-process train populates, so a fresh read-only
+ * process always reported 'js-fallback'/'unavailable' even with
+ * @ruvector/ruvllm installed. The pipeline stays lazy: this only probes
+ * module resolution.
+ */
+export function resolveTrainingBackend() {
+    if (pipelineLoaded)
+        return ruvllmPipeline ? 'ruvllm' : 'js-fallback';
+    try {
+        createRequire(import.meta.url).resolve('@ruvector/ruvllm');
+        return 'ruvllm';
+    }
+    catch {
+        return 'js-fallback';
+    }
+}
 async function loadTrainingPipeline(adapter) {
     if (pipelineLoaded)
         return ruvllmPipeline;
@@ -295,9 +315,7 @@ export class LoRAAdapter {
                 ? this.adaptationNormSum / this.totalAdaptations
                 : 0,
             lastUpdate: this.lastUpdate,
-            _trainingBackend: pipelineLoaded
-                ? (ruvllmPipeline ? 'ruvllm' : 'js-fallback')
-                : 'js-fallback',
+            _trainingBackend: resolveTrainingBackend(),
         };
     }
     /**

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