@lumenflow/memory 2.10.0 → 2.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/memory",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "description": "Memory layer for LumenFlow workflow framework - session tracking, context recovery, and agent coordination",
   "keywords": [
     "lumenflow",
@@ -49,7 +49,7 @@
     "ms": "^2.1.3",
     "yaml": "^2.8.2",
     "zod": "^4.3.5",
-    "@lumenflow/core": "2.10.0"
+    "@lumenflow/core": "2.11.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.17",

package/dist/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * @lumenflow/memory - Session tracking and context recovery
- * @module @lumenflow/memory
- */
-export * from './mem-checkpoint-core.js';
-export * from './mem-cleanup-core.js';
-export * from './mem-create-core.js';
-export * from './mem-export-core.js';
-export * from './mem-id.js';
-export * from './mem-init-core.js';
-export * from './mem-ready-core.js';
-export * from './mem-signal-core.js';
-export * from './mem-start-core.js';
-export { filterSummarizableNodes, summarizeWu, getCompactionRatio as getSummarizeCompactionRatio, } from './mem-summarize-core.js';
-export * from './mem-triage-core.js';
-export * from './memory-schema.js';
-export * from './memory-store.js';

package/dist/mem-checkpoint-core.d.ts

@@ -1,91 +0,0 @@
-/**
- * Memory Checkpoint Core (WU-1467, WU-1748)
- *
- * Core logic for creating checkpoint nodes for context snapshots.
- * Used before /clear or session handoff to preserve progress state.
- *
- * Features:
- * - Creates checkpoint nodes with progress summary and next steps
- * - Optional linking to sessions and WUs
- * - Supports handoff trigger detection
- * - Auto-initializes memory layer if not present
- * - WU-1748: Persists to wu-events.jsonl for cross-agent visibility
- *
- * @see {@link tools/mem-checkpoint.mjs} - CLI wrapper
- * @see {@link tools/__tests__/mem-checkpoint.test.mjs} - Tests
- * @see {@link tools/lib/memory-schema.mjs} - Schema definitions
- */
-/**
- * Checkpoint creation options
- */
-export interface CreateCheckpointOptions {
-    /** Checkpoint note/description (required) */
-    note: string;
-    /** Session ID to link checkpoint to */
-    sessionId?: string;
-    /** Work Unit ID to link checkpoint to */
-    wuId?: string;
-    /** Progress summary */
-    progress?: string;
-    /** Next steps description */
-    nextSteps?: string;
-    /** Handoff trigger (e.g., 'clear', 'handoff') */
-    trigger?: string;
-}
-/**
- * Checkpoint metadata stored in the node
- */
-interface CheckpointMetadata {
-    progress?: string;
-    nextSteps?: string;
-    trigger?: string;
-    [key: string]: unknown;
-}
-/**
- * Memory node structure for checkpoints
- */
-interface CheckpointNode {
-    id: string;
-    type: 'checkpoint';
-    lifecycle: 'session';
-    content: string;
-    created_at: string;
-    wu_id?: string;
-    session_id?: string;
-    metadata?: CheckpointMetadata;
-}
-/**
- * Checkpoint creation result
- */
-export interface CreateCheckpointResult {
-    /** Whether the operation succeeded */
-    success: boolean;
-    /** Created checkpoint node */
-    checkpoint: CheckpointNode;
-}
-/**
- * Creates a new checkpoint node for context preservation.
- *
- * Creates a checkpoint-type memory node with:
- * - Unique ID (mem-XXXX format)
- * - User-provided note in content
- * - Optional session and WU linking
- * - Progress summary and next steps in metadata
- *
- * @param baseDir - Base directory containing .lumenflow/memory/
- * @param options - Checkpoint options
- * @returns Result with created checkpoint node
- * @throws If note is missing or WU ID is invalid
- *
- * @example
- * const result = await createCheckpoint(baseDir, {
- *   note: 'Before /clear - completed TDD tests',
- *   sessionId: 'session-uuid',
- *   wuId: 'WU-1467',
- *   progress: 'TDD tests passing, core module implemented',
- *   nextSteps: 'Implement CLI wrapper, add package.json script',
- * });
- * console.log(result.checkpoint.id); // 'mem-a1b2'
- */
-export declare function createCheckpoint(baseDir: string, options: CreateCheckpointOptions): Promise<CreateCheckpointResult>;
-export {};

package/dist/mem-cleanup-core.d.ts

@@ -1,202 +0,0 @@
-/**
- * Memory Cleanup Core (WU-1472, WU-1554)
- *
- * Prune closed memory nodes based on lifecycle policy.
- * Implements compaction to prevent memory bloat.
- *
- * Features:
- * - Remove ephemeral nodes (always discarded)
- * - Remove session nodes when session is closed
- * - Archive summarized nodes (marked with summarized_into)
- * - Respect sensitive:true flag for stricter retention
- * - Support dry-run mode for preview
- * - Report compaction metrics (ratio, bytes freed)
- * - WU-1554: TTL-based expiration for old nodes
- * - WU-1554: Active session protection regardless of age
- *
- * Lifecycle Policy:
- * - ephemeral: Always removed (scratch pad data)
- * - session: Removed when session is closed
- * - wu: Removed when marked with summarized_into (after WU completion)
- * - project: Never removed (architectural knowledge)
- *
- * TTL Policy (WU-1554):
- * - Nodes older than TTL are removed regardless of lifecycle
- * - Active sessions (status: 'active') are never removed
- * - Project and sensitive nodes are protected from TTL removal
- *
- * @see {@link tools/mem-cleanup.mjs} - CLI wrapper
- * @see {@link tools/__tests__/mem-cleanup.test.mjs} - Tests
- */
-import type { MemoryNode } from './memory-schema.js';
-/**
- * Lifecycle policy definition
- */
-interface LifecyclePolicyEntry {
-    alwaysRemove: boolean;
-    requiresSummarized: boolean;
-    protected?: boolean;
-}
-/**
- * Lifecycle policy type for indexed access
- */
-type LifecycleType = 'ephemeral' | 'session' | 'wu' | 'project';
-/**
- * Lifecycle policy definitions
- *
- * Determines which nodes are eligible for cleanup based on lifecycle.
- */
-export declare const LIFECYCLE_POLICY: Record<LifecycleType, LifecyclePolicyEntry>;
-/**
- * Metadata flag that indicates sensitive data requiring stricter retention
- */
-export declare const SENSITIVE_FLAG = "sensitive";
-/**
- * Cleanup options for memory pruning
- */
-export interface CleanupOptions {
-    /** If true, preview without modifications */
-    dryRun?: boolean;
-    /** Session ID to consider closed (removes session lifecycle nodes) */
-    sessionId?: string;
-    /** TTL duration string (e.g., '30d', '7d', '24h') for age-based cleanup */
-    ttl?: string;
-    /** TTL in milliseconds (alternative to ttl string) */
-    ttlMs?: number;
-    /** Current timestamp for testing (defaults to Date.now()) */
-    now?: number;
-}
-/**
- * Breakdown of cleanup by lifecycle type
- */
-interface CleanupBreakdown {
-    ephemeral: number;
-    session: number;
-    wu: number;
-    sensitive: number;
-    ttlExpired: number;
-    activeSessionProtected: number;
-}
-/**
- * Result of cleanup operation
- */
-export interface CleanupResult {
-    /** Whether cleanup succeeded */
-    success: boolean;
-    /** IDs of removed nodes */
-    removedIds: string[];
-    /** IDs of retained nodes */
-    retainedIds: string[];
-    /** Approximate bytes freed (0 if dry-run) */
-    bytesFreed: number;
-    /** Ratio of removed to total nodes */
-    compactionRatio: number;
-    /** True if in dry-run mode */
-    dryRun?: boolean;
-    /** TTL in milliseconds if TTL was provided */
-    ttlMs?: number;
-    /** Breakdown by lifecycle */
-    breakdown: CleanupBreakdown;
-}
-/**
- * Parse a TTL duration string into milliseconds (WU-1554).
- *
- * Uses the `ms` package to parse human-readable duration strings.
- *
- * @param ttlString - TTL string (e.g., '30d', '7d', '24h', '60m')
- * @returns TTL in milliseconds
- * @throws If TTL format is invalid
- *
- * @example
- * parseTtl('30d'); // 2592000000 (30 days in ms)
- * parseTtl('7d');  // 604800000 (7 days in ms)
- * parseTtl('24h'); // 86400000 (24 hours in ms)
- */
-export declare function parseTtl(ttlString: string): number;
-/**
- * Check if a node has expired based on TTL (WU-1554).
- *
- * @param node - Memory node to check
- * @param ttlMs - TTL in milliseconds
- * @param now - Current timestamp (defaults to Date.now())
- * @returns True if node is older than TTL
- *
- * @example
- * // Check if node is older than 30 days
- * const expired = isNodeExpired(node, 30 * 24 * 60 * 60 * 1000);
- */
-export declare function isNodeExpired(node: MemoryNode, ttlMs: number, now?: number): boolean;
-/**
- * Check if a node should be removed based on lifecycle policy and TTL.
- *
- * Policy rules (checked in order):
- * 1. Active sessions are always retained (WU-1554)
- * 2. Sensitive nodes are always retained
- * 3. Protected lifecycle (project) nodes are never removed
- * 4. TTL expiration removes old nodes (WU-1554)
- * 5. Ephemeral nodes are always removed
- * 6. Session nodes are removed when their session is closed
- * 7. WU nodes are removed only when marked with summarized_into
- *
- * @param {MemoryNode} node - Memory node to check
- * @param {CleanupOptions} options - Cleanup options
- * @returns {{remove: boolean, reason: string}} Removal decision with reason
- */
-export declare function shouldRemoveNode(node: MemoryNode, options?: CleanupOptions): {
-    remove: boolean;
-    reason: string;
-};
-/**
- * Calculate approximate byte size of a node when serialized.
- *
- * @param node - Memory node
- * @returns Approximate byte size
- */
-export declare function estimateNodeBytes(node: MemoryNode): number;
-/**
- * Calculate compaction ratio (removed / total).
- *
- * @param removedCount - Number of removed nodes
- * @param totalCount - Total number of nodes
- * @returns Compaction ratio (0 to 1, or 0 if no nodes)
- */
-export declare function getCompactionRatio(removedCount: number, totalCount: number): number;
-/**
- * Perform memory cleanup based on lifecycle policy and TTL.
- *
- * Removes nodes according to lifecycle policy:
- * - Active sessions are never removed (WU-1554)
- * - Sensitive nodes are always retained
- * - Project nodes are never removed
- * - TTL-expired nodes are removed (WU-1554)
- * - Ephemeral nodes are always removed
- * - Session nodes are removed when their session is closed
- * - WU nodes are removed only when marked with summarized_into
- *
- * In dry-run mode, no modifications are made but the result shows
- * what would be removed.
- *
- * @param {string} baseDir - Base directory containing .lumenflow/memory/
- * @param {CleanupOptions} options - Cleanup options
- * @returns {Promise<CleanupResult>} Result with removed nodes and metrics
- *
- * @example
- * // Cleanup with dry-run to preview
- * const preview = await cleanupMemory(baseDir, { dryRun: true });
- * console.log(`Would remove ${preview.removedIds.length} nodes`);
- * console.log(`Would free ${preview.bytesFreed} bytes`);
- *
- * @example
- * // Cleanup session nodes when session closes
- * const result = await cleanupMemory(baseDir, {
- *   sessionId: 'abc-123-def-456',
- * });
- * console.log(`Removed ${result.removedIds.length} nodes`);
- *
- * @example
- * // WU-1554: TTL-based cleanup
- * const result = await cleanupMemory(baseDir, { ttl: '30d' });
- * console.log(`Removed ${result.breakdown.ttlExpired} expired nodes`);
- */
-export declare function cleanupMemory(baseDir: string, options?: CleanupOptions): Promise<CleanupResult>;
-export {};

package/dist/mem-create-core.d.ts

@@ -1,93 +0,0 @@
-/**
- * Memory Create Core (WU-1469)
- *
- * Core logic for creating memory nodes with discovered-from provenance.
- * KEY DIFFERENTIATOR: supports discovered-from relationship for scope-creep
- * forensics. Creates audit trail of WHY work expanded, not just WHAT changed.
- *
- * Features:
- * - Creates all 5 node types: session, discovery, checkpoint, note, summary
- * - Auto-generates hash-based ID using mem-id
- * - Validates node against memory-schema
- * - Supports discovered-from relationship for provenance tracking
- *
- * @see {@link tools/mem-create.mjs} - CLI wrapper
- * @see {@link tools/__tests__/mem-create.test.mjs} - Tests
- * @see {@link tools/lib/memory-schema.mjs} - Schema definitions
- */
-import { type MemoryNode } from './memory-schema.js';
-/**
- * Memory node creation options
- */
-export interface CreateMemoryNodeOptions {
-    /** Node title/content (required) */
-    title: string;
-    /** Node type (session, discovery, checkpoint, note, summary) */
-    type?: string;
-    /** Work Unit ID to link node to */
-    wuId?: string;
-    /** Session ID to link node to */
-    sessionId?: string;
-    /** Parent node ID for provenance tracking */
-    discoveredFrom?: string;
-    /** Tags for categorization */
-    tags?: string[];
-    /** Priority level (P0, P1, P2, P3) */
-    priority?: string;
-}
-/**
- * Relationship between memory nodes
- */
-interface Relationship {
-    from_id: string;
-    to_id: string;
-    type: string;
-    created_at: string;
-}
-/**
- * Memory node creation result
- */
-export interface CreateMemoryNodeResult {
-    /** Whether the operation succeeded */
-    success: boolean;
-    /** Created memory node */
-    node: MemoryNode;
-    /** Created relationship (if discoveredFrom provided) */
-    relationship?: Relationship;
-}
-/**
- * Creates a new memory node with optional discovered-from provenance.
- *
- * Creates a memory node with:
- * - Unique ID (mem-XXXX format) generated from content hash
- * - User-provided title as content
- * - Type-appropriate lifecycle
- * - Optional discovered-from relationship for provenance tracking
- *
- * @param {string} baseDir - Base directory containing .lumenflow/memory/
- * @param {CreateMemoryNodeOptions} options - Node creation options
- * @returns {Promise<CreateMemoryNodeResult>} Result with created node and optional relationship
- * @throws {Error} If title is missing, type is invalid, or IDs are malformed
- *
- * @example
- * // Create a simple discovery node
- * const result = await createMemoryNode(baseDir, {
- *   title: 'Found relevant file at src/utils.mjs',
- *   type: 'discovery',
- *   wuId: 'WU-1469',
- * });
- *
- * @example
- * // Create a node with provenance (scope-creep tracking)
- * const parent = await createMemoryNode(baseDir, {
- *   title: 'Found src/components/',
- *   type: 'discovery',
- * });
- * const child = await createMemoryNode(baseDir, {
- *   title: 'Found src/components/Button.tsx',
- *   type: 'discovery',
- *   discoveredFrom: parent.node.id, // Track where this came from
- * });
- */
-export declare function createMemoryNode(baseDir: string, options: CreateMemoryNodeOptions): Promise<CreateMemoryNodeResult>;
-export {};

package/dist/mem-export-core.d.ts

@@ -1,33 +0,0 @@
-/**
- * Memory Export Core (WU-1137)
- *
- * Render memory.jsonl as markdown or JSON with basic filters.
- * Designed for human-readable inspection without changing storage format.
- */
-import type { MemoryNode } from './memory-schema.js';
-/** Supported output formats for export */
-export type ExportFormat = 'markdown' | 'json';
-/** Export filters */
-export interface ExportOptions {
-    /** WU ID filter (e.g., WU-1234) */
-    wuId?: string;
-    /** Node type filter (e.g., discovery, checkpoint) */
-    type?: string;
-    /** Lifecycle filter (ephemeral, session, wu, project) */
-    lifecycle?: string;
-    /** Output format (markdown or json) */
-    format?: ExportFormat;
-}
-/** Export result */
-export interface ExportResult {
-    format: ExportFormat;
-    nodes: MemoryNode[];
-    output: string;
-}
-/**
- * Export memory nodes in the requested format.
- *
- * @param baseDir - Project base directory
- * @param options - Export options
- */
-export declare function exportMemory(baseDir: string, options?: ExportOptions): Promise<ExportResult>;

package/dist/mem-id.d.ts

@@ -1,91 +0,0 @@
-/**
- * Memory ID Generator (WU-1465)
- *
- * Hash-based collision-free ID generation for memory nodes.
- * Format: mem-[4 hex chars] derived from content hash.
- * Supports hierarchical IDs (mem-a1b2.1.2) for sub-task decomposition.
- *
- * @see {@link tools/lib/__tests__/mem-id.test.mjs} - Tests
- * @see {@link tools/lib/memory-schema.mjs} - Schema definitions
- */
-/**
- * Regex patterns for memory ID validation
- */
-export declare const MEM_ID_PATTERNS: {
-    /**
-     * Base memory ID format: mem-[a-f0-9]{4}
-     * Only lowercase hex characters (0-9, a-f)
-     */
-    BASE_ID: RegExp;
-    /**
-     * Hierarchical memory ID format: mem-[a-f0-9]{4}(.[1-9][0-9]*)*
-     * Base ID followed by optional dot-separated positive integers
-     * Examples: mem-a1b2, mem-a1b2.1, mem-a1b2.1.2
-     */
-    HIERARCHICAL_ID: RegExp;
-};
-/**
- * Generates a deterministic memory ID from content.
- *
- * Uses SHA-256 hash of the content, taking the first 4 hex characters.
- * Same content always produces the same ID (deterministic).
- *
- * @param content - Content to hash for ID generation
- * @returns Memory ID in format mem-[a-f0-9]{4}
- *
- * @example
- * const id = generateMemId('discovered file at src/utils.mjs');
- * // Returns something like 'mem-a3f2'
- */
-export declare function generateMemId(content: string): string;
-/**
- * Generates a hierarchical memory ID by appending an index to a parent ID.
- *
- * Used for sub-task decomposition where a parent task (mem-a1b2) has
- * child tasks (mem-a1b2.1, mem-a1b2.2) and grandchildren (mem-a1b2.1.1).
- *
- * @param parentId - Parent memory ID (base or hierarchical)
- * @param index - Positive integer index (1-based)
- * @returns Hierarchical memory ID
- * @throws If parentId is invalid or index is not positive
- *
- * @example
- * generateHierarchicalId('mem-a1b2', 1);     // 'mem-a1b2.1'
- * generateHierarchicalId('mem-a1b2.1', 2);  // 'mem-a1b2.1.2'
- */
-export declare function generateHierarchicalId(parentId: string, index: number): string;
-/**
- * Validation result from validateMemId
- */
-export interface MemIdValidationResult {
-    /** Whether the ID is valid */
-    valid: boolean;
-    /** Type of ID if valid */
-    type?: 'base' | 'hierarchical';
-    /** Base ID portion if hierarchical */
-    baseId?: string;
-    /** Hierarchical indices (empty for base IDs) */
-    indices: number[];
-    /** Error message if invalid */
-    error?: string;
-}
-/**
- * Validates a memory ID and extracts its components.
- *
- * Returns validation result with type classification and parsed components.
- * Compatible with MEMORY_PATTERNS.MEMORY_ID from memory-schema.mjs.
- *
- * @param id - Memory ID to validate
- * @returns Validation result with parsed components
- *
- * @example
- * validateMemId('mem-a1b2');
- * // { valid: true, type: 'base', baseId: 'mem-a1b2', indices: [] }
- *
- * validateMemId('mem-a1b2.1.2');
- * // { valid: true, type: 'hierarchical', baseId: 'mem-a1b2', indices: [1, 2] }
- *
- * validateMemId('invalid');
- * // { valid: false, error: 'Invalid memory ID format', indices: [] }
- */
-export declare function validateMemId(id: string): MemIdValidationResult;

package/dist/mem-init-core.d.ts

@@ -1,93 +0,0 @@
-/**
- * Memory Init Core (WU-1464)
- *
- * Core logic for initializing memory layer in a repository.
- * Creates .lumenflow/memory/ directory with empty memory.jsonl and config.yaml.
- *
- * @see {@link tools/__tests__/mem-init.test.mjs} - Tests
- * @see {@link tools/lib/memory-store.mjs} - Memory store operations
- * @see {@link tools/lib/memory-schema.mjs} - Memory schema definitions
- */
-/**
- * Memory layer file/directory paths
- *
- * Uses LUMENFLOW_MEMORY_PATHS from local paths.ts to avoid circular dependency.
- */
-export declare const MEMORY_PATHS: {
-    /** Memory directory relative to project root */
-    MEMORY_DIR: ".lumenflow/memory";
-    /** Memory JSONL file name */
-    MEMORY_FILE: string;
-    /** Config YAML file name */
-    CONFIG_FILE: string;
-};
-/**
- * Default memory layer configuration
- *
- * Retention values are in seconds:
- * - ephemeral: 0 (immediate discard)
- * - session: 3600 (1 hour)
- * - wu: 604800 (7 days)
- * - project: -1 (never expire)
- */
-export declare const DEFAULT_CONFIG: {
-    /** Config schema version */
-    version: number;
-    /** Retention policy for each lifecycle */
-    retention: {
-        /** Ephemeral nodes are discarded immediately after use */
-        ephemeral: number;
-        /** Session nodes expire after 1 hour */
-        session: number;
-        /** WU nodes expire after 7 days */
-        wu: number;
-        /** Project nodes never expire (-1 = infinite) */
-        project: number;
-    };
-};
-/**
- * Memory initialization paths
- */
-interface InitMemoryPaths {
-    memoryDir: string;
-    memoryJsonl: string;
-    configYaml: string;
-}
-/**
- * Memory initialization created flags
- */
-interface InitMemoryCreated {
-    directory: boolean;
-    memoryJsonl: boolean;
-    configYaml: boolean;
-}
-/**
- * Memory initialization result
- */
-export interface InitMemoryResult {
-    success: boolean;
-    alreadyInitialized: boolean;
-    paths: InitMemoryPaths;
-    created: InitMemoryCreated;
-}
-/**
- * Initialize memory layer in a repository.
- *
- * Creates:
- * - .lumenflow/memory/ directory
- * - memory.jsonl (empty if not exists)
- * - config.yaml (default settings if not exists)
- *
- * Idempotent: Running multiple times does not corrupt existing data.
- *
- * @param baseDir - Base directory of the repository
- * @returns Result object with success, paths, and created flags
- *
- * @example
- * const result = await initMemory(process.cwd());
- * if (result.success) {
- *   console.log('Memory initialized at:', result.paths.memoryDir);
- * }
- */
-export declare function initMemory(baseDir: string): Promise<InitMemoryResult>;
-export {};

package/dist/mem-ready-core.d.ts

@@ -1,56 +0,0 @@
-/**
- * Memory Ready Core (WU-1468)
- *
- * Deterministic ready-work query for "what next?" oracle.
- * Returns open nodes with no blockers, ordered by priority then createdAt.
- *
- * Ordering algorithm:
- * 1. Priority ASC (P0 first, then P1, P2, P3; nodes without priority last)
- * 2. CreatedAt ASC (oldest first for same priority)
- * 3. ID ASC (stable sort for identical priority and timestamp)
- *
- * A node is "ready" if:
- * - Linked to the specified WU
- * - Not blocked by another node (no `blocks` relationship pointing to it)
- * - No `metadata.blocked_by` array set
- * - Lifecycle is not `ephemeral`
- * - Status is not `closed` (metadata.status !== 'closed')
- *
- * @see {@link tools/mem-ready.mjs} - CLI implementation
- * @see {@link tools/__tests__/mem-ready.test.mjs} - Tests
- */
-import { type MemoryNode } from './memory-schema.js';
-/**
- * Query options for ready nodes
- */
-export interface QueryOptions {
-    /** WU ID to query (required) */
-    wuId: string;
-    /** Filter by node type (optional) */
-    type?: string;
-}
-/**
- * Query ready nodes for a WU.
- *
- * Returns unblocked, open nodes linked to the WU in deterministic order:
- * 1. Priority (P0 first, then P1, P2, P3; nodes without priority last)
- * 2. CreatedAt (oldest first for same priority)
- * 3. ID (alphabetical for stable sort)
- *
- * @param baseDir - Base directory containing .lumenflow/memory
- * @param options - Query options
- * @returns Deterministically ordered ready nodes
- * @throws If WU ID format is invalid or file contains malformed JSON
- *
- * @example
- * const ready = await queryReadyNodes('/path/to/project', { wuId: 'WU-1234' });
- * console.log(`${ready.length} nodes ready for processing`);
- *
- * @example
- * // Filter by type
- * const discoveries = await queryReadyNodes('/path/to/project', {
- *   wuId: 'WU-1234',
- *   type: 'discovery',
- * });
- */
-export declare function queryReadyNodes(baseDir: string, options: QueryOptions): Promise<MemoryNode[]>;