moflo 4.9.35 → 4.9.37

package/dist/src/cli/mcp-tools/memory-tools.js

@@ -54,6 +54,63 @@ function notifyMemoryGate() {
 const MAX_KEY_LENGTH = 1024;
 const MAX_VALUE_SIZE = 1024 * 1024; // 1MB
 const MAX_QUERY_LENGTH = 4096;
+function parseNavigation(metadataJson, mode) {
+    if (!metadataJson)
+        return null;
+    let meta;
+    try {
+        meta = JSON.parse(metadataJson);
+    }
+    catch {
+        return null;
+    }
+    if (!meta || typeof meta !== 'object')
+        return null;
+    // Discriminator: only `type === 'chunk'` entries carry the nav fields.
+    if (meta.type !== 'chunk')
+        return null;
+    if (mode === 'compact') {
+        return {
+            parentDoc: meta.parentDoc,
+            prevChunk: meta.prevChunk ?? null,
+            nextChunk: meta.nextChunk ?? null,
+            chunkTitle: meta.chunkTitle,
+        };
+    }
+    return {
+        parentDoc: meta.parentDoc,
+        parentPath: meta.parentPath,
+        prevChunk: meta.prevChunk ?? null,
+        nextChunk: meta.nextChunk ?? null,
+        siblings: meta.siblings,
+        chunkIndex: meta.chunkIndex,
+        totalChunks: meta.totalChunks,
+        hierarchicalParent: meta.hierarchicalParent ?? null,
+        hierarchicalChildren: meta.hierarchicalChildren ?? null,
+        chunkTitle: meta.chunkTitle,
+        headerLevel: meta.headerLevel,
+    };
+}
+function shapeRetrievedEntry(entry) {
+    let value = entry.content;
+    try {
+        value = JSON.parse(entry.content);
+    }
+    catch { /* keep string */ }
+    return {
+        key: entry.key,
+        namespace: entry.namespace,
+        value,
+        tags: entry.tags,
+        storedAt: entry.createdAt,
+        updatedAt: entry.updatedAt,
+        accessCount: entry.accessCount,
+        hasEmbedding: entry.hasEmbedding,
+        navigation: parseNavigation(entry.metadata, 'full'),
+        found: true,
+        backend: 'sql.js + HNSW',
+    };
+}
 function validateMemoryInput(key, value, query) {
     if (key && key.length > MAX_KEY_LENGTH) {
         throw new Error(`Key exceeds maximum length of ${MAX_KEY_LENGTH} characters`);
@@ -220,7 +277,7 @@ export const memoryTools = [
     },
     {
         name: 'memory_retrieve',
-        description: 'Retrieve a value from memory by key',
+        description: 'Retrieve a value from memory by key. Chunk entries also return a full `navigation` object — use it with memory_get_neighbors for traversal instead of bulk-retrieving every search hit.',
         category: 'memory',
         inputSchema: {
             type: 'object',
@@ -238,27 +295,9 @@ export const memoryTools = [
             try {
                 const result = await getEntry({ key, namespace });
                 if (result.found && result.entry) {
-                    // Try to parse JSON value
-                    let value = result.entry.content;
-                    try {
-                        value = JSON.parse(result.entry.content);
-                    }
-                    catch {
-                        // Keep as string
-                    }
                     notifyMemoryGate();
-                    return {
-                        key,
-                        namespace,
-                        value,
-                        tags: result.entry.tags,
-                        storedAt: result.entry.createdAt,
-                        updatedAt: result.entry.updatedAt,
-                        accessCount: result.entry.accessCount,
-                        hasEmbedding: result.entry.hasEmbedding,
-                        found: true,
-                        backend: 'sql.js + HNSW',
-                    };
+                    // #1053 S1: surface RAG navigation for chunked guidance entries.
+                    return shapeRetrievedEntry(result.entry);
                 }
                 return {
                     key,
@@ -280,15 +319,15 @@ export const memoryTools = [
     },
     {
         name: 'memory_search',
-        description: 'Semantic vector search using HNSW index (150x-12,500x faster than keyword search)',
+        description: 'Semantic vector search using HNSW index (150x-12,500x faster than keyword search). Results include a compact `navigation` crumb on chunk hits — traverse via memory_get_neighbors rather than retrieving every hit.',
         category: 'memory',
         inputSchema: {
             type: 'object',
             properties: {
                 query: { type: 'string', description: 'Search query (semantic similarity)' },
                 namespace: { type: 'string', description: 'Namespace to search (default: all namespaces)' },
-                limit: { type: 'number', description: 'Maximum results (default: 10)' },
-                threshold: { type: 'number', description: 'Minimum similarity threshold 0-1 (default: 0.3)' },
+                limit: { type: 'number', description: 'Maximum results (default: 8)' },
+                threshold: { type: 'number', description: 'Minimum similarity threshold 0-1 (default: 0.5)' },
             },
             required: ['query'],
         },
@@ -297,13 +336,13 @@ export const memoryTools = [
             const { searchEntries } = await getMemoryFunctions();
             const query = input.query;
             const namespace = input.namespace || 'all';
-            const limit = input.limit || 10;
-            // Falsiness check would coerce a caller-supplied 0 to 0.3 and silently
+            // #1053 S6: tighter defaults — fewer hits, higher relevance bar.
+            const limit = input.limit || 8;
+            // Falsiness check would coerce a caller-supplied 0 to default and silently
             // filter low-similarity matches; use a typeof guard so explicit zero
             // means "no threshold" (#837).
-            const threshold = typeof input.threshold === 'number' ? input.threshold : 0.3;
+            const threshold = typeof input.threshold === 'number' ? input.threshold : 0.5;
             validateMemoryInput(undefined, undefined, query);
-            const startTime = performance.now();
             try {
                 const result = await searchEntries({
                     query,
@@ -311,7 +350,6 @@ export const memoryTools = [
                     limit,
                     threshold,
                 });
-                const duration = performance.now() - startTime;
                 // Parse JSON values in results
                 const results = result.results.map(r => {
                     let value = r.content;
@@ -321,19 +359,27 @@ export const memoryTools = [
                     catch {
                         // Keep as string
                     }
+                    // #1053 S1: compact RAG navigation crumb per result.
+                    // Compact subset is small enough to always include — keeps the
+                    // result envelope navigable without ballooning per-hit size.
+                    const navigation = parseNavigation(r.metadata, 'compact');
                     return {
                         key: r.key,
                         namespace: r.namespace,
                         value,
-                        similarity: r.score,
+                        // #1053 S6: 2dp keeps signal, drops noise (8-decimal floats add ~6
+                        // bytes per hit and don't help any caller).
+                        similarity: Math.round(r.score * 100) / 100,
+                        navigation,
                     };
                 });
                 notifyMemoryGate();
+                // #1053 S6: searchTime dropped from MCP envelope (CLI keeps it for
+                // human reading); `backend` retained — doctor reads it (#1053 epic).
                 return {
                     query,
                     results,
                     total: results.length,
-                    searchTime: `${duration.toFixed(2)}ms`,
                     backend: 'HNSW + sql.js',
                 };
             }
@@ -347,6 +393,98 @@ export const memoryTools = [
             }
         },
     },
+    {
+        name: 'memory_get_neighbors',
+        description: 'Traverse the chunk graph in one call: fetch the requested neighbors (prev/next/siblings/parent/children) of a chunk key. Returns success:false if the source is not a chunk.',
+        category: 'memory',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Source chunk key (must be a chunk-* entry)' },
+                namespace: { type: 'string', description: 'Namespace (default: "default")' },
+                include: {
+                    type: 'array',
+                    items: { type: 'string', enum: ['prev', 'next', 'siblings', 'parent', 'children'] },
+                    description: "Which neighbors to fetch. Default: ['prev','next']. parent/children = hierarchical (h2→h3) chunk neighbors; siblings = same-doc chunk peers.",
+                },
+            },
+            required: ['key'],
+        },
+        handler: async (input) => {
+            await ensureInitialized();
+            const { getEntry } = await getMemoryFunctions();
+            const key = input.key;
+            const namespace = input.namespace || 'default';
+            const includeRaw = input.include;
+            const include = Array.isArray(includeRaw) && includeRaw.length > 0 ? includeRaw : ['prev', 'next'];
+            validateMemoryInput(key);
+            try {
+                const sourceResult = await getEntry({ key, namespace });
+                if (!sourceResult.found || !sourceResult.entry) {
+                    return {
+                        success: false,
+                        key,
+                        namespace,
+                        error: `Source key '${key}' not found in namespace '${namespace}'`,
+                    };
+                }
+                const sourceMeta = sourceResult.entry.metadata;
+                const nav = parseNavigation(sourceMeta, 'full');
+                if (!nav) {
+                    return {
+                        success: false,
+                        key,
+                        namespace,
+                        error: `Source key '${key}' has no chunk metadata; only chunk-* entries are navigable`,
+                    };
+                }
+                // Resolve requested neighbor keys, dedup, exclude the source key itself.
+                const neighborKeys = new Set();
+                const addIfChunkKey = (k) => {
+                    if (k && k !== key)
+                        neighborKeys.add(k);
+                };
+                for (const inc of include) {
+                    if (inc === 'prev')
+                        addIfChunkKey(nav.prevChunk);
+                    else if (inc === 'next')
+                        addIfChunkKey(nav.nextChunk);
+                    else if (inc === 'siblings')
+                        (nav.siblings ?? []).forEach(addIfChunkKey);
+                    else if (inc === 'parent')
+                        addIfChunkKey(nav.hierarchicalParent);
+                    else if (inc === 'children')
+                        (nav.hierarchicalChildren ?? []).forEach(addIfChunkKey);
+                }
+                // Parallel fetch — one round-trip from the caller's perspective.
+                // Missing neighbors (deleted/renamed) are silently skipped rather
+                // than failing the whole call; the response.total reflects what
+                // we actually returned.
+                const fetched = await Promise.all(Array.from(neighborKeys).map(async (k) => {
+                    const res = await getEntry({ key: k, namespace });
+                    return res.found && res.entry ? shapeRetrievedEntry(res.entry) : null;
+                }));
+                notifyMemoryGate();
+                const neighbors = fetched.filter((e) => e !== null);
+                return {
+                    success: true,
+                    source: { key, namespace },
+                    include,
+                    neighbors,
+                    total: neighbors.length,
+                    backend: 'sql.js + HNSW',
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    key,
+                    namespace,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+        },
+    },
     {
         name: 'memory_delete',
         description: 'Delete a memory entry by key',

package/dist/src/cli/memory/auto-memory-bridge.js

@@ -12,11 +12,11 @@
  * @module moflo/cli/memory/auto-memory-bridge
  */
 import { createHash } from 'node:crypto';
-import { homedir } from 'node:os';
 import { EventEmitter } from 'node:events';
 import * as fs from 'node:fs/promises';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import * as path from 'node:path';
+import { claudeProjectDirFor } from '../shared/utils/claude-projects-path.js';
 import { createDefaultEntry, } from './types.js';
 import { LearningBridge } from './learning-bridge.js';
 import { MemoryGraph } from './memory-graph.js';
@@ -539,20 +539,17 @@ export class AutoMemoryBridge extends EventEmitter {
 // ===== Utility Functions =====
 /**
  * Resolve the auto memory directory for a given working directory.
- * Mirrors Claude Code's path derivation from git root.
+ *
+ * The git root is preferred over the raw cwd so a session in
+ * `<repo>/packages/foo` resolves to the repo's auto-memory store, matching
+ * Claude Code's own behaviour. The encoded suffix is produced by the shared
+ * `claudeProjectDirFor` helper so this bridge cannot drift away from the
+ * Claude Code directory naming convention (issue #1048).
  */
 export function resolveAutoMemoryDir(workingDir) {
     const gitRoot = findGitRoot(workingDir);
     const basePath = gitRoot || workingDir;
-    // Claude Code normalizes to forward slashes then replaces with dashes
-    // The leading dash IS preserved (e.g. /workspaces/foo -> -workspaces-foo)
-    // On Windows, strip drive letter prefix (C:) for cleaner keys
-    let normalized = basePath.split(path.sep).join('/');
-    if (process.platform === 'win32') {
-        normalized = normalized.replace(/^[A-Za-z]:/, '');
-    }
-    const projectKey = normalized.replace(/\//g, '-');
-    return path.join(homedir(), '.claude', 'projects', projectKey, 'memory');
+    return path.join(claudeProjectDirFor(basePath), 'memory');
 }
 /**
  * Find the git root directory by walking up from workingDir.

package/dist/src/cli/memory/bridge-entries.js

@@ -403,7 +403,7 @@ export async function bridgeSearchEntries(options) {
         let rows;
         try {
             const sql = `
-        SELECT id, key, namespace, content, embedding
+        SELECT id, key, namespace, content, metadata, embedding
         FROM memory_entries
         WHERE status = 'active' ${nsFilter}
         LIMIT 1000
@@ -459,6 +459,7 @@ export async function bridgeSearchEntries(options) {
                 const provenance = usedSemantic
                     ? `semantic:${semanticScore.toFixed(3)}+bm25:${bm25ScoreVal.toFixed(3)}`
                     : `bm25:${bm25ScoreVal.toFixed(3)}`;
+                const metadataStr = row.metadata != null ? String(row.metadata) : undefined;
                 results.push({
                     id: String(row.id).substring(0, 12),
                     // The substring is a fallback id-prefix when key is missing —
@@ -468,6 +469,7 @@ export async function bridgeSearchEntries(options) {
                     score,
                     namespace: String(row.namespace || 'default'),
                     provenance,
+                    metadata: metadataStr,
                 });
             }
         }
@@ -542,13 +544,14 @@ export async function bridgeGetEntry(options) {
                     updatedAt: cached.updatedAt || new Date().toISOString(),
                     hasEmbedding: !!cached.embedding,
                     tags: cached.tags || [],
+                    metadata: cached.metadata || undefined,
                 },
             };
         }
         let row;
         try {
             const stmt = ctx.db.prepare(`
-        SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
+        SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags, metadata
         FROM memory_entries
         WHERE status = 'active' AND key = ? AND namespace = ?
         LIMIT 1
@@ -591,6 +594,7 @@ export async function bridgeGetEntry(options) {
             updatedAt: row.updated_at || new Date().toISOString(),
             hasEmbedding: !!(row.embedding && String(row.embedding).length > 10),
             tags,
+            metadata: row.metadata != null ? String(row.metadata) : undefined,
         };
         await cacheSet(registry, cacheKey, entry);
         return { success: true, found: true, cacheHit: false, entry };

package/dist/src/cli/memory/memory-initializer.js

@@ -424,8 +424,8 @@ export async function getHNSWIndex(options) {
         // adjacency. When the sidecar IS loaded we skip the per-row JSON.parse
         // of the embedding column, which is the expensive part on a populated
         // consumer DB.
-        const SELECT_WITH_EMBEDDING = `id, key, namespace, content, embedding`;
-        const SELECT_METADATA_ONLY = `id, key, namespace, content`;
+        const SELECT_WITH_EMBEDDING = `id, key, namespace, content, metadata, embedding`;
+        const SELECT_METADATA_ONLY = `id, key, namespace, content, metadata`;
         if (fs.existsSync(dbPath)) {
             try {
                 const initSqlJs = (await mofloImport('sql.js')).default;
@@ -442,7 +442,9 @@ export async function getHNSWIndex(options) {
                 let parseSkipped = 0;
                 if (result[0]?.values) {
                     for (const row of result[0].values) {
-                        const [id, key, ns, content, embeddingJson] = row;
+                        // Column order matches SELECT_WITH_EMBEDDING / SELECT_METADATA_ONLY.
+                        // When sidecar is loaded, embeddingJson is undefined (column absent).
+                        const [id, key, ns, content, metadataJson, embeddingJson] = row;
                         if (!sidecarLoaded) {
                             const vec = parseEmbeddingJson(embeddingJson);
                             if (!vec) {
@@ -455,7 +457,8 @@ export async function getHNSWIndex(options) {
                             id: String(id),
                             key: key || String(id),
                             namespace: ns || 'default',
-                            content: content || ''
+                            content: content || '',
+                            metadata: metadataJson || undefined
                         });
                     }
                 }
@@ -545,7 +548,8 @@ export async function searchHNSWIndex(queryEmbedding, options) {
                 key: entry.key || entry.id.substring(0, 15),
                 content: entry.content.substring(0, 60) + (entry.content.length > 60 ? '...' : ''),
                 score,
-                namespace: entry.namespace
+                namespace: entry.namespace,
+                metadata: entry.metadata
             });
             if (filtered.length >= k)
                 break;
@@ -1817,7 +1821,7 @@ export async function searchEntries(options) {
         const db = new SQL.Database(fileBuffer);
         // Get entries with embeddings
         const entries = db.exec(`
-      SELECT id, key, namespace, content, embedding
+      SELECT id, key, namespace, content, metadata, embedding
       FROM memory_entries
       WHERE status = 'active'
         ${namespace !== 'all' ? `AND namespace = '${namespace.replace(/'/g, "''")}'` : ''}
@@ -1826,7 +1830,7 @@ export async function searchEntries(options) {
         const results = [];
         if (entries[0]?.values) {
             for (const row of entries[0].values) {
-                const [id, key, ns, content, embeddingJson] = row;
+                const [id, key, ns, content, metadataJson, embeddingJson] = row;
                 let score = 0;
                 if (embeddingJson) {
                     try {
@@ -1849,7 +1853,8 @@ export async function searchEntries(options) {
                         key: key || id.substring(0, 15),
                         content: (content || '').substring(0, 60) + ((content || '').length > 60 ? '...' : ''),
                         score,
-                        namespace: ns || 'default'
+                        namespace: ns || 'default',
+                        metadata: metadataJson || undefined
                     });
                 }
             }
@@ -1987,7 +1992,7 @@ export async function getEntry(options) {
         const db = new SQL.Database(fileBuffer);
         // Find entry by key
         const result = db.exec(`
-      SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
+      SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags, metadata
       FROM memory_entries
       WHERE status = 'active'
         AND key = '${key.replace(/'/g, "''")}'
@@ -1998,7 +2003,7 @@ export async function getEntry(options) {
             db.close();
             return { success: true, found: false };
         }
-        const [id, entryKey, ns, content, embedding, accessCount, createdAt, updatedAt, tagsJson] = result[0].values[0];
+        const [id, entryKey, ns, content, embedding, accessCount, createdAt, updatedAt, tagsJson, metadataJson] = result[0].values[0];
         // Update access count
         db.run(`
       UPDATE memory_entries
@@ -2028,7 +2033,8 @@ export async function getEntry(options) {
                 createdAt: createdAt || new Date().toISOString(),
                 updatedAt: updatedAt || new Date().toISOString(),
                 hasEmbedding: !!embedding && embedding.length > 10,
-                tags
+                tags,
+                metadata: metadataJson || undefined
             }
         };
     }

package/dist/src/cli/services/claude-stats.js

@@ -22,9 +22,10 @@
  */
 import { createReadStream } from 'node:fs';
 import { stat, readdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
+import { claudeProjectDirFor, encodeCwdForClaudeProjects, } from '../shared/utils/claude-projects-path.js';
+export { claudeProjectDirFor, encodeCwdForClaudeProjects };
 /**
  * Map a transcript model name to a stable display key. Recognises bare family
  * names ("opus", "sonnet", "haiku"), dated/dotted variants
@@ -43,21 +44,6 @@ export function canonicalModelKey(model) {
         return 'haiku';
     return 'unknown';
 }
-// ============================================================================
-// Path resolution
-// ============================================================================
-/**
- * Encode a CWD the same way Claude Code does for `~/.claude/projects/<dir>`.
- * Replaces `\`, `/`, and `:` with `-` so `C:\Users\eric\Projects\moflo` →
- * `C--Users-eric-Projects-moflo`.
- */
-export function encodeCwdForClaudeProjects(cwd) {
-    return cwd.replace(/[\\/:]/g, '-');
-}
-/** Absolute path to `~/.claude/projects/<encoded-cwd>` for the given CWD. */
-export function claudeProjectDirFor(cwd) {
-    return join(homedir(), '.claude', 'projects', encodeCwdForClaudeProjects(cwd));
-}
 const CACHE_TTL_MS = 30_000;
 let cache = null;
 /** Test-only — drop the in-memory cache so the next call re-aggregates. */

package/dist/src/cli/services/subagent-bootstrap.js

@@ -21,7 +21,7 @@ const BOOTSTRAP_JSON_REL = '.claude/helpers/subagent-bootstrap.json';
 // Defense-in-depth copy of the canonical directive in subagent-bootstrap.json.
 // Kept as a single-line literal so the parity test can verify it matches the
 // JSON via plain substring containment.
-const FALLBACK_DIRECTIVE = 'MANDATORY FIRST ACTION: Your very first tool call MUST be mcp__moflo__memory_search (any query, any namespace). The memory-first gate WILL BLOCK all Glob, Grep, and Read calls until you do this. After memory search, follow `.claude/guidance/moflo-subagents.md` protocol.';
+const FALLBACK_DIRECTIVE = 'MANDATORY FIRST ACTION: Your very first tool call MUST be mcp__moflo__memory_search (any query, any namespace). The memory-first gate WILL BLOCK all Glob, Grep, and Read calls until you do this. After memory search, follow `.claude/guidance/moflo-subagents.md` protocol. When search returns chunk hits, traverse via mcp__moflo__memory_get_neighbors before retrieving — see `.claude/guidance/moflo-memory-protocol.md`.';
 function loadDirective() {
     const jsonPath = locateMofloRootPath(BOOTSTRAP_JSON_REL);
     if (!jsonPath) {

package/dist/src/cli/shared/utils/claude-projects-path.js

@@ -0,0 +1,32 @@
+/**
+ * Encode a working directory the same way Claude Code does for its
+ * `~/.claude/projects/<dir>/` transcript & memory store.
+ *
+ * Claude Code replaces *every* non-alphanumeric character in the absolute
+ * path with `-`. Earlier moflo versions used a narrower class (`/[\\/:]/g`,
+ * or split-and-rejoin variants) which agreed with Claude Code only for
+ * paths whose every other character was alphanumeric — issue #1048.
+ *
+ * Centralised here so the stats aggregator and the auto-memory bridge
+ * cannot drift apart.
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Encode a CWD to the form Claude Code uses as a `~/.claude/projects/`
+ * subdirectory name. Replaces every non-alphanumeric character with `-`.
+ *
+ * @example
+ *   encodeCwdForClaudeProjects('C:\\Users\\me\\some_project')
+ *     → 'C--Users-me-some-project'
+ *   encodeCwdForClaudeProjects('/Users/me/dev/some_project')
+ *     → '-Users-me-dev-some-project'
+ */
+export function encodeCwdForClaudeProjects(cwd) {
+    return cwd.replace(/[^A-Za-z0-9]/g, '-');
+}
+/** Absolute path to `~/.claude/projects/<encoded-cwd>` for the given CWD. */
+export function claudeProjectDirFor(cwd) {
+    return join(homedir(), '.claude', 'projects', encodeCwdForClaudeProjects(cwd));
+}
+//# sourceMappingURL=claude-projects-path.js.map

package/dist/src/cli/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.9.35';
+export const VERSION = '4.9.37';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.9.35",
+  "version": "4.9.37",
   "description": "MoFlo — AI agent orchestration for Claude Code. A standalone, opinionated toolkit with semantic memory, learned routing, gates, spells, and the /flo issue-execution skill.",
   "main": "dist/src/cli/index.js",
   "type": "module",
@@ -97,7 +97,7 @@
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.9.34",
+    "moflo": "^4.9.36",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"