claude-flow 3.16.3 → 3.18.0

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

@@ -0,0 +1,277 @@
+/**
+ * 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
+ */
+const MODEL_TIER = { haiku: 2, sonnet: 3, opus: 3 };
+const NEXT_MODEL = {
+    haiku: 'sonnet',
+    sonnet: 'opus',
+    opus: null,
+};
+// Refusal phrasings scanned near the start of the output. Anchored to the
+// head so a legitimate answer that *discusses* refusals doesn't trip it.
+const REFUSAL_HEAD_CHARS = 240;
+const REFUSAL_PATTERNS = [
+    /\bI\s+(?:can(?:no|')t|cannot)\s+(?:help|assist|do|provide|comply|fulfill|complete|write|generate)\b/i,
+    /\bI(?:'m| am)\s+(?:sorry|afraid)\b[\s\S]{0,60}\b(?:can(?:no|')t|cannot|unable)\b/i,
+    /\bI(?:'m| am)\s+(?:unable|not able)\s+to\b/i,
+    /\bI\s+(?:must|have to)\s+(?:decline|refuse)\b/i,
+    /\bI\s+won'?t\s+be\s+able\s+to\b/i,
+    /\bas an AI(?:\s+(?:language\s+)?model)?[,\s]+I\b/i,
+];
+// A trailing dangling operator / opener strongly suggests a mid-expression cutoff.
+const TRUNCATION_TAIL = /(?:,|&&|\|\||=>|[+*/%=]|\(|\[|\{|\bconst|\blet|\bvar|\bfunction|\breturn|:)\s*$/;
+/** Pull fenced code blocks out of markdown-ish output. */
+export function extractCodeBlocks(output) {
+    const blocks = [];
+    const re = /```([A-Za-z0-9_-]*)\n([\s\S]*?)```/g;
+    let m;
+    while ((m = re.exec(output)) !== null) {
+        blocks.push({ lang: (m[1] || '').toLowerCase(), code: m[2] });
+    }
+    return blocks;
+}
+/** Cheap stack-based bracket balance check that skips string/comment-ish content. */
+export function bracketsBalanced(code) {
+    const stack = [];
+    const pairs = { ')': '(', ']': '[', '}': '{' };
+    let inString = null;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < code.length; i++) {
+        const c = code[i];
+        const next = code[i + 1];
+        if (inLineComment) {
+            if (c === '\n')
+                inLineComment = false;
+            continue;
+        }
+        if (inBlockComment) {
+            if (c === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            if (c === '\\') {
+                i++;
+                continue;
+            }
+            if (c === inString)
+                inString = null;
+            continue;
+        }
+        if (c === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (c === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'" || c === '`') {
+            inString = c;
+            continue;
+        }
+        if (c === '(' || c === '[' || c === '{')
+            stack.push(c);
+        else if (c === ')' || c === ']' || c === '}') {
+            if (stack.pop() !== pairs[c])
+                return false;
+        }
+    }
+    return stack.length === 0;
+}
+const CODE_TASK_HINT = /\b(?:code|function|class|implement|refactor|typescript|javascript|python|script|method|api endpoint|unit test)\b/i;
+const CODE_OUTPUT_HINT = /(?:^|\n)\s*(?:import\s|export\s|function\s|class\s|const\s|let\s|def\s|return\s)/;
+function detectTaskKind(input) {
+    if (input.taskKind && input.taskKind !== 'auto')
+        return input.taskKind;
+    if (/\bjson\b/i.test(input.task) && /^[\s]*[[{]/.test(input.output.trim()))
+        return 'json';
+    if (extractCodeBlocks(input.output).length > 0)
+        return 'code';
+    if (CODE_TASK_HINT.test(input.task) && CODE_OUTPUT_HINT.test(input.output))
+        return 'code';
+    return 'text';
+}
+/**
+ * Syntax-check a JS/TS snippet. Uses the TypeScript compiler when available
+ * (transpileModule with reportDiagnostics catches syntactic errors without
+ * type-checking — cheap, no program construction). Falls back to bracket
+ * balance when typescript is not installed.
+ */
+async function checkCodeParses(code, lang) {
+    if (lang === 'json') {
+        try {
+            JSON.parse(code);
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, detail: `JSON.parse failed: ${e instanceof Error ? e.message : String(e)}` };
+        }
+    }
+    const jsLike = ['', 'js', 'jsx', 'ts', 'tsx', 'javascript', 'typescript', 'mjs', 'cjs'].includes(lang);
+    if (!jsLike) {
+        // Non-JS languages: bracket balance is the best free proxy we have.
+        return bracketsBalanced(code)
+            ? { ok: true, detail: `no parser for lang="${lang}"; delimiter check only` }
+            : { ok: false, detail: `unbalanced delimiters in ${lang} block` };
+    }
+    try {
+        const ts = (await import('typescript')).default;
+        const result = ts.transpileModule(code, {
+            reportDiagnostics: true,
+            compilerOptions: { jsx: ts.JsxEmit.Preserve, allowJs: true },
+        });
+        const syntaxErrors = (result.diagnostics ?? []).filter(d => d.category === ts.DiagnosticCategory.Error);
+        if (syntaxErrors.length > 0) {
+            const first = syntaxErrors[0];
+            const msg = ts.flattenDiagnosticMessageText(first.messageText, ' ');
+            return { ok: false, detail: `syntax error: ${msg}` };
+        }
+        return { ok: true };
+    }
+    catch {
+        // typescript not installed — graceful degradation, delimiter check only.
+        return bracketsBalanced(code)
+            ? { ok: true, detail: 'typescript unavailable; delimiter check only' }
+            : { ok: false, detail: 'typescript unavailable; unbalanced delimiters' };
+    }
+}
+/** Detect degenerate repetition (same non-trivial line repeated many times in a row). */
+function isDegenerate(output) {
+    const lines = output.split('\n').map(l => l.trim()).filter(l => l.length > 8);
+    let run = 1;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i] === lines[i - 1]) {
+            run++;
+            if (run >= 5)
+                return true;
+        }
+        else {
+            run = 1;
+        }
+    }
+    return false;
+}
+/**
+ * Compute a confidence verdict for `output` from cheap structural signals,
+ * and suggest an escalation target when not confident.
+ */
+export async function verifyAndEscalate(input) {
+    const output = input.output ?? '';
+    const trimmed = output.trim();
+    const minLength = input.minLength ?? 20;
+    const taskKind = detectTaskKind(input);
+    const model = input.model ?? 'haiku';
+    const tierUsed = input.tierUsed ?? MODEL_TIER[model] ?? 2;
+    const signals = [];
+    const reasons = [];
+    const fail = (name, detail) => {
+        signals.push({ name, ok: false, detail });
+        reasons.push(`${name}: ${detail}`);
+    };
+    const pass = (name, detail) => signals.push({ name, ok: true, detail });
+    // 1. Emptiness
+    if (trimmed.length === 0)
+        fail('empty-output', 'output is empty or whitespace-only');
+    else
+        pass('empty-output');
+    // 2. Plausible length (skip when already flagged empty)
+    if (trimmed.length > 0 && trimmed.length < minLength) {
+        fail('too-short', `output is ${trimmed.length} chars (< ${minLength})`);
+    }
+    else if (trimmed.length > 0) {
+        pass('too-short');
+    }
+    // 3. Refusal patterns near the head
+    const head = trimmed.slice(0, REFUSAL_HEAD_CHARS);
+    const refusal = REFUSAL_PATTERNS.find(p => p.test(head));
+    if (refusal)
+        fail('refusal', `refusal pattern near start of output (${refusal.source.slice(0, 40)}…)`);
+    else
+        pass('refusal');
+    // 4. Truncation: unclosed code fence, or dangling operator/opener at the tail
+    const fenceCount = (output.match(/```/g) ?? []).length;
+    if (fenceCount % 2 !== 0) {
+        fail('truncation', 'unclosed code fence (odd number of ``` markers)');
+    }
+    else if (trimmed.length > 0 && TRUNCATION_TAIL.test(trimmed)) {
+        fail('truncation', `output ends mid-expression ("…${trimmed.slice(-24).replace(/\n/g, '\\n')}")`);
+    }
+    else {
+        pass('truncation');
+    }
+    // 5. Degenerate repetition
+    if (isDegenerate(trimmed))
+        fail('degenerate-repetition', 'same line repeated 5+ times consecutively');
+    else
+        pass('degenerate-repetition');
+    // 6. Code / JSON parse checks
+    if (taskKind === 'code' || taskKind === 'json') {
+        const blocks = extractCodeBlocks(output);
+        const targets = blocks.length > 0
+            ? blocks
+            : [{ lang: taskKind === 'json' ? 'json' : '', code: output }];
+        let allOk = true;
+        const details = [];
+        for (const block of targets) {
+            const check = await checkCodeParses(block.code, taskKind === 'json' ? 'json' : block.lang);
+            if (!check.ok) {
+                allOk = false;
+                details.push(check.detail ?? 'parse failed');
+            }
+            else if (check.detail) {
+                details.push(check.detail);
+            }
+        }
+        if (allOk)
+            pass('code-parses', details.join('; ') || undefined);
+        else
+            fail('code-parses', details.join('; '));
+    }
+    const passed = signals.filter(s => s.ok).length;
+    const score = signals.length > 0 ? passed / signals.length : 0;
+    const confident = reasons.length === 0;
+    const nextModel = NEXT_MODEL[model] ?? null;
+    const suggestedModel = confident ? null : nextModel;
+    const suggestedTier = confident
+        ? tierUsed
+        : (nextModel !== null ? Math.min(3, tierUsed + 1) : tierUsed);
+    const escalate = !confident && nextModel !== null;
+    if (!confident && nextModel === null) {
+        reasons.push('already-at-top-tier: no higher tier to escalate to — retry or surface to the user');
+    }
+    return { confident, score, reasons, signals, suggestedTier, suggestedModel, escalate, taskKind };
+}
+export default verifyAndEscalate;
+//# sourceMappingURL=output-verifier.js.map

package/v3/@claude-flow/cli/dist/src/ruvector/trajectory-tree.d.ts

@@ -0,0 +1,113 @@
+/**
+ * trajectory-tree.ts — Execution-state-tree retrieval PROTOTYPE (MAGE-style).
+ *
+ * Research basis: MAGE (arXiv 2606.06090) observes that semantic-similarity
+ * retrieval fragments decision trajectories on long-horizon tasks; retrieving
+ * by POSITION in a hierarchical execution-state tree (the root→current path)
+ * preserves coherence. This module mirrors ruflo's existing trajectory
+ * recording (hooks_intelligence_trajectory-start/step/end) into such a tree
+ * and offers position-based recall — NO embedding search anywhere.
+ *
+ * Structure:
+ *   session root ─ trajectory ─ step
+ *                       └ trajectory (nested: a start while another is open
+ *                                     opens UNDER the open one) ─ step …
+ *
+ * - `trajectory-start` opens a node under the deepest open trajectory of the
+ *   session (or the session root).
+ * - `trajectory-step` appends a step child; the step becomes the "current"
+ *   position of the session.
+ * - `trajectory-end` closes the node; current returns to its parent.
+ * - `recallPath({sessionId, depth})` returns the root→current path (the
+ *   MAGE-style working context) plus the most recent siblings of the current
+ *   node.
+ *
+ * PROTOTYPE LIMITATIONS (deliberate — see the feature spec):
+ * - Persistence is a single best-effort JSON snapshot at
+ *   `.claude-flow/intelligence/trajectory-tree.json`, written on every
+ *   mutation. It sits ALONGSIDE the existing 'trajectories' memory-namespace
+ *   persistence; nothing is migrated and the semantic path is untouched.
+ * - No concurrency control: two MCP server processes sharing a cwd will
+ *   last-writer-win the snapshot.
+ * - No pruning/compaction: long-lived sessions grow the file unboundedly
+ *   (labels are truncated to 200 chars to bound row size, not row count).
+ * - sessionId defaults to CLAUDE_FLOW_SESSION_ID or 'default'; hosts that
+ *   never set it collapse into one tree.
+ * - Retrieval is position-only by design; hybrid position+semantic ranking
+ *   is future work.
+ *
+ * @module ruvector/trajectory-tree
+ */
+export type TreeNodeKind = 'session' | 'trajectory' | 'step';
+export interface TreeNode {
+    id: string;
+    kind: TreeNodeKind;
+    /** Task text (trajectory), action text (step), or session id — ≤200 chars. */
+    label: string;
+    parentId: string | null;
+    childIds: string[];
+    status: 'open' | 'closed';
+    openedAt: string;
+    closedAt?: string;
+    meta?: Record<string, unknown>;
+}
+export interface RecallResult {
+    sessionId: string;
+    /** Root→current node path (the MAGE-style working context). */
+    path: TreeNode[];
+    /** Most recent siblings of the current node (excluding it), oldest→newest. */
+    siblings: TreeNode[];
+    /** Id of the current node (deepest position in the session). */
+    currentId: string | null;
+    strategy: 'state-tree';
+}
+export declare class TrajectoryTree {
+    private nodes;
+    /** sessionId → id of the deepest "current" node (step or open trajectory). */
+    private currentBySession;
+    /** trajectoryId → sessionId, so step/end calls can omit the session. */
+    private trajectorySession;
+    private readonly persistPath;
+    constructor(persistPath?: string);
+    private sessionRootId;
+    private ensureSession;
+    /** Deepest OPEN trajectory node on the current path of a session, if any. */
+    private deepestOpenTrajectory;
+    openTrajectory(args: {
+        sessionId: string;
+        trajectoryId: string;
+        task: string;
+        agent?: string;
+    }): TreeNode;
+    appendStep(args: {
+        trajectoryId: string;
+        stepId: string;
+        action: string;
+        quality?: number;
+    }): TreeNode | null;
+    closeTrajectory(args: {
+        trajectoryId: string;
+        success?: boolean;
+    }): TreeNode | null;
+    /**
+     * MAGE-style positional recall: the exact root→current path for a session,
+     * plus the most recent siblings of the current node for local context.
+     *
+     * @param depth Max number of path nodes returned, counted from the CURRENT
+     *              node upward (deepest levels win). Default: full path.
+     * @param siblingWindow Max recent siblings of the current node. Default 3.
+     */
+    recallPath(args: {
+        sessionId: string;
+        depth?: number;
+        siblingWindow?: number;
+    }): RecallResult;
+    get size(): number;
+    private load;
+    private save;
+}
+export declare function getTrajectoryTree(persistPath?: string): TrajectoryTree;
+/** Test/reset hook — drops the singleton so the next get() reloads from disk. */
+export declare function resetTrajectoryTree(): void;
+export default TrajectoryTree;
+//# sourceMappingURL=trajectory-tree.d.ts.map

package/v3/@claude-flow/cli/dist/src/ruvector/trajectory-tree.js

@@ -0,0 +1,237 @@
+/**
+ * trajectory-tree.ts — Execution-state-tree retrieval PROTOTYPE (MAGE-style).
+ *
+ * Research basis: MAGE (arXiv 2606.06090) observes that semantic-similarity
+ * retrieval fragments decision trajectories on long-horizon tasks; retrieving
+ * by POSITION in a hierarchical execution-state tree (the root→current path)
+ * preserves coherence. This module mirrors ruflo's existing trajectory
+ * recording (hooks_intelligence_trajectory-start/step/end) into such a tree
+ * and offers position-based recall — NO embedding search anywhere.
+ *
+ * Structure:
+ *   session root ─ trajectory ─ step
+ *                       └ trajectory (nested: a start while another is open
+ *                                     opens UNDER the open one) ─ step …
+ *
+ * - `trajectory-start` opens a node under the deepest open trajectory of the
+ *   session (or the session root).
+ * - `trajectory-step` appends a step child; the step becomes the "current"
+ *   position of the session.
+ * - `trajectory-end` closes the node; current returns to its parent.
+ * - `recallPath({sessionId, depth})` returns the root→current path (the
+ *   MAGE-style working context) plus the most recent siblings of the current
+ *   node.
+ *
+ * PROTOTYPE LIMITATIONS (deliberate — see the feature spec):
+ * - Persistence is a single best-effort JSON snapshot at
+ *   `.claude-flow/intelligence/trajectory-tree.json`, written on every
+ *   mutation. It sits ALONGSIDE the existing 'trajectories' memory-namespace
+ *   persistence; nothing is migrated and the semantic path is untouched.
+ * - No concurrency control: two MCP server processes sharing a cwd will
+ *   last-writer-win the snapshot.
+ * - No pruning/compaction: long-lived sessions grow the file unboundedly
+ *   (labels are truncated to 200 chars to bound row size, not row count).
+ * - sessionId defaults to CLAUDE_FLOW_SESSION_ID or 'default'; hosts that
+ *   never set it collapse into one tree.
+ * - Retrieval is position-only by design; hybrid position+semantic ranking
+ *   is future work.
+ *
+ * @module ruvector/trajectory-tree
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+const DEFAULT_PERSIST_PATH = join('.claude-flow', 'intelligence', 'trajectory-tree.json');
+const LABEL_MAX = 200;
+function now() {
+    return new Date().toISOString();
+}
+function truncate(text) {
+    return text.length > LABEL_MAX ? `${text.slice(0, LABEL_MAX - 1)}…` : text;
+}
+export class TrajectoryTree {
+    nodes = new Map();
+    /** sessionId → id of the deepest "current" node (step or open trajectory). */
+    currentBySession = new Map();
+    /** trajectoryId → sessionId, so step/end calls can omit the session. */
+    trajectorySession = new Map();
+    persistPath;
+    constructor(persistPath) {
+        this.persistPath = resolve(persistPath ?? DEFAULT_PERSIST_PATH);
+        this.load();
+    }
+    sessionRootId(sessionId) {
+        return `session:${sessionId}`;
+    }
+    ensureSession(sessionId) {
+        const id = this.sessionRootId(sessionId);
+        let node = this.nodes.get(id);
+        if (!node) {
+            node = {
+                id,
+                kind: 'session',
+                label: truncate(sessionId),
+                parentId: null,
+                childIds: [],
+                status: 'open',
+                openedAt: now(),
+            };
+            this.nodes.set(id, node);
+        }
+        return node;
+    }
+    /** Deepest OPEN trajectory node on the current path of a session, if any. */
+    deepestOpenTrajectory(sessionId) {
+        let cursor = this.nodes.get(this.currentBySession.get(sessionId) ?? '');
+        while (cursor) {
+            if (cursor.kind === 'trajectory' && cursor.status === 'open')
+                return cursor;
+            cursor = cursor.parentId ? this.nodes.get(cursor.parentId) : undefined;
+        }
+        return null;
+    }
+    openTrajectory(args) {
+        const session = this.ensureSession(args.sessionId);
+        const parent = this.deepestOpenTrajectory(args.sessionId) ?? session;
+        const node = {
+            id: args.trajectoryId,
+            kind: 'trajectory',
+            label: truncate(args.task),
+            parentId: parent.id,
+            childIds: [],
+            status: 'open',
+            openedAt: now(),
+            meta: args.agent ? { agent: args.agent } : undefined,
+        };
+        this.nodes.set(node.id, node);
+        parent.childIds.push(node.id);
+        this.trajectorySession.set(args.trajectoryId, args.sessionId);
+        this.currentBySession.set(args.sessionId, node.id);
+        this.save();
+        return node;
+    }
+    appendStep(args) {
+        const trajectory = this.nodes.get(args.trajectoryId);
+        if (!trajectory || trajectory.kind !== 'trajectory')
+            return null;
+        const sessionId = this.trajectorySession.get(args.trajectoryId);
+        // The upstream stepId scheme (`step-${Date.now()}`) can collide within a
+        // millisecond — uniquify locally instead of clobbering an existing node.
+        let stepId = args.stepId;
+        let bump = 1;
+        while (this.nodes.has(stepId))
+            stepId = `${args.stepId}-${bump++}`;
+        const node = {
+            id: stepId,
+            kind: 'step',
+            label: truncate(args.action),
+            parentId: trajectory.id,
+            childIds: [],
+            status: 'closed',
+            openedAt: now(),
+            closedAt: now(),
+            meta: args.quality !== undefined ? { quality: args.quality } : undefined,
+        };
+        this.nodes.set(node.id, node);
+        trajectory.childIds.push(node.id);
+        if (sessionId)
+            this.currentBySession.set(sessionId, node.id);
+        this.save();
+        return node;
+    }
+    closeTrajectory(args) {
+        const trajectory = this.nodes.get(args.trajectoryId);
+        if (!trajectory || trajectory.kind !== 'trajectory')
+            return null;
+        trajectory.status = 'closed';
+        trajectory.closedAt = now();
+        if (args.success !== undefined) {
+            trajectory.meta = { ...trajectory.meta, success: args.success };
+        }
+        const sessionId = this.trajectorySession.get(args.trajectoryId);
+        if (sessionId && trajectory.parentId) {
+            // Current position pops back to the enclosing trajectory / session root.
+            this.currentBySession.set(sessionId, trajectory.parentId);
+        }
+        this.save();
+        return trajectory;
+    }
+    /**
+     * MAGE-style positional recall: the exact root→current path for a session,
+     * plus the most recent siblings of the current node for local context.
+     *
+     * @param depth Max number of path nodes returned, counted from the CURRENT
+     *              node upward (deepest levels win). Default: full path.
+     * @param siblingWindow Max recent siblings of the current node. Default 3.
+     */
+    recallPath(args) {
+        const currentId = this.currentBySession.get(args.sessionId) ?? null;
+        const path = [];
+        let cursor = currentId ? this.nodes.get(currentId) : undefined;
+        while (cursor) {
+            path.unshift(cursor);
+            cursor = cursor.parentId ? this.nodes.get(cursor.parentId) : undefined;
+        }
+        const depth = args.depth && args.depth > 0 ? args.depth : path.length;
+        const trimmedPath = path.slice(Math.max(0, path.length - depth));
+        const siblingWindow = args.siblingWindow ?? 3;
+        let siblings = [];
+        const current = currentId ? this.nodes.get(currentId) : undefined;
+        const parent = current?.parentId ? this.nodes.get(current.parentId) : undefined;
+        if (current && parent) {
+            siblings = parent.childIds
+                .filter(id => id !== current.id)
+                .map(id => this.nodes.get(id))
+                .filter((n) => !!n)
+                .slice(-siblingWindow);
+        }
+        return { sessionId: args.sessionId, path: trimmedPath, siblings, currentId, strategy: 'state-tree' };
+    }
+    get size() {
+        return this.nodes.size;
+    }
+    // ── Persistence (best-effort JSON snapshot) ──────────────────────────────
+    load() {
+        try {
+            if (!existsSync(this.persistPath))
+                return;
+            const raw = JSON.parse(readFileSync(this.persistPath, 'utf-8'));
+            if (raw?.v !== 1 || typeof raw.nodes !== 'object')
+                return;
+            this.nodes = new Map(Object.entries(raw.nodes));
+            this.currentBySession = new Map(Object.entries(raw.currentBySession ?? {}));
+            this.trajectorySession = new Map(Object.entries(raw.trajectorySession ?? {}));
+        }
+        catch {
+            // Corrupt/unreadable snapshot — start fresh; the semantic trajectory
+            // persistence in the 'trajectories' namespace is unaffected.
+        }
+    }
+    save() {
+        try {
+            const snapshot = {
+                v: 1,
+                nodes: Object.fromEntries(this.nodes),
+                currentBySession: Object.fromEntries(this.currentBySession),
+                trajectorySession: Object.fromEntries(this.trajectorySession),
+            };
+            mkdirSync(dirname(this.persistPath), { recursive: true });
+            writeFileSync(this.persistPath, JSON.stringify(snapshot), 'utf-8');
+        }
+        catch {
+            // Best-effort — tree still lives in memory.
+        }
+    }
+}
+// ── Singleton (mirrors the lazy-singleton pattern used by model-router) ────
+let treeInstance = null;
+export function getTrajectoryTree(persistPath) {
+    if (!treeInstance)
+        treeInstance = new TrajectoryTree(persistPath);
+    return treeInstance;
+}
+/** Test/reset hook — drops the singleton so the next get() reloads from disk. */
+export function resetTrajectoryTree() {
+    treeInstance = null;
+}
+export default TrajectoryTree;
+//# sourceMappingURL=trajectory-tree.js.map

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.16.3",
+  "version": "3.18.0",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -115,11 +115,11 @@
     "@claude-flow/memory": "^3.0.0-alpha.21",
     "@claude-flow/plugin-gastown-bridge": "^0.1.3",
     "@claude-flow/security": "^3.0.0-alpha.10",
-    "@metaharness/darwin": "~0.3.1",
-    "@metaharness/kernel": "~0.1.0",
-    "@metaharness/redblue": "~0.1.1",
+    "@metaharness/darwin": "~0.8.0",
+    "@metaharness/kernel": "~0.1.2",
+    "@metaharness/redblue": "~0.1.4",
     "@metaharness/router": "~0.3.2",
-    "metaharness": "~0.2.6",
+    "metaharness": "~0.2.8",
     "@ruvector/attention": "^0.1.32",
     "@ruvector/attention-darwin-arm64": "0.1.32",
     "@ruvector/diskann": "^0.1.0",