@lumenflow/core 2.2.2 → 2.3.2

package/dist/wu-preflight-validators.js

@@ -28,6 +28,7 @@ import { TEST_TYPES, LOG_PREFIX, EMOJI } from './wu-constants.js';
 import { BaseWUSchema } from './wu-schema.js';
 // WU-1810: Import fixer to detect fixable issues
 import { detectFixableIssues, FIXABLE_ISSUES } from './wu-yaml-fixer.js';
+import fg from 'fast-glob';
 /**
  * Result structure for preflight validation
  * @typedef {object} PreflightResult
@@ -44,14 +45,16 @@ import { detectFixableIssues, FIXABLE_ISSUES } from './wu-yaml-fixer.js';
  * @param {string[]} [params.errors=[]] - Error messages
  * @param {string[]} [params.missingCodePaths=[]] - Missing code paths
  * @param {string[]} [params.missingTestPaths=[]] - Missing test paths
+ * @param {Record<string, string[]>} [params.suggestedTestPaths={}] - Suggested test paths
  * @returns {PreflightResult}
  */
-export function createPreflightResult({ valid, errors = [], missingCodePaths = [], missingTestPaths = [], }) {
+export function createPreflightResult({ valid, errors = [], missingCodePaths = [], missingTestPaths = [], suggestedTestPaths = {}, }) {
     return {
         valid,
         errors,
         missingCodePaths,
         missingTestPaths,
+        suggestedTestPaths,
     };
 }
 /**
@@ -209,11 +212,23 @@ export async function validatePreflight(id, options = {}) {
         allErrors.push(...testPathsResult.errors);
         missingTestPaths.push(...testPathsResult.missing);
     }
+    // Step 5 (WU-1154): Generate suggestions for missing test paths
+    let suggestedTestPaths = {};
+    if (missingTestPaths.length > 0) {
+        const searchRoot = worktreePath || rootDir;
+        try {
+            suggestedTestPaths = await findSuggestedTestPaths(missingTestPaths, searchRoot);
+        }
+        catch (err) {
+            process.env.DEBUG && console.log(`[wu-preflight] Failed to find suggestions: ${err.message}`);
+        }
+    }
     return createPreflightResult({
         valid: allErrors.length === 0,
         errors: allErrors,
         missingCodePaths,
         missingTestPaths,
+        suggestedTestPaths,
     });
 }
 /**
@@ -249,3 +264,43 @@ export function formatPreflightResult(id, result) {
 }
 // Export PreflightResult type for documentation
 export const PreflightResult = {};
+/**
+ * Find suggested paths for missing test files
+ *
+ * @param {string[]} missingPaths - List of missing test paths
+ * @param {string} rootDir - Root directory to search in
+ * @returns {Promise<Record<string, string[]>>} Map of missing path -> suggestions
+ */
+export async function findSuggestedTestPaths(missingPaths, rootDir) {
+    const suggestions = {};
+    if (missingPaths.length === 0)
+        return suggestions;
+    // Cache strict searches to avoid re-reading fs
+    const globOptions = {
+        cwd: rootDir,
+        caseSensitiveMatch: false,
+        limit: 5,
+        ignore: ['**/node_modules/**'],
+    };
+    for (const missingPath of missingPaths) {
+        const filename = path.basename(missingPath);
+        const basename = path.basename(filename, path.extname(filename));
+        const cleanBasename = basename.replace(/(\.test|\.spec)$/, '');
+        // Strategy 1: Search for exact filename elsewhere
+        let matches = await fg(`**/${filename}`, globOptions);
+        // Strategy 2: Search for filename with different extension (ts/js/mjs)
+        if (matches.length === 0) {
+            matches = await fg(`**/${basename}.{ts,js,mjs,tsx,jsx}`, globOptions);
+        }
+        // Strategy 3: Search for fuzzy match on basename (without .test/.spec)
+        if (matches.length === 0) {
+            // Look for the code file the test might be for
+            matches = await fg(`**/${cleanBasename}.{ts,js,mjs,tsx,jsx}`, globOptions);
+        }
+        if (matches.length > 0) {
+            // Filter out the missing path itself if it somehow showed up
+            suggestions[missingPath] = matches.filter((m) => m !== missingPath);
+        }
+    }
+    return suggestions;
+}

package/dist/wu-recovery.d.ts

@@ -11,8 +11,8 @@
  * Recovery mode is idempotent - safe to run multiple times
  *
  * NOTE (WU-1826): Core recovery functions are now re-exported from
- * tools/lib/wu-repair-core.mjs for use by the unified wu:repair command.
- * This module remains the canonical implementation used by wu-done.mjs.
+ * tools/lib/wu-repair-core.ts for use by the unified wu:repair command.
+ * This module remains the canonical implementation used by wu-done.ts.
  */
 /**
  * WU-1335: Maximum number of recovery attempts before escalating to manual intervention

package/dist/wu-recovery.js

@@ -11,8 +11,8 @@
  * Recovery mode is idempotent - safe to run multiple times
  *
  * NOTE (WU-1826): Core recovery functions are now re-exported from
- * tools/lib/wu-repair-core.mjs for use by the unified wu:repair command.
- * This module remains the canonical implementation used by wu-done.mjs.
+ * tools/lib/wu-repair-core.ts for use by the unified wu:repair command.
+ * This module remains the canonical implementation used by wu-done.ts.
  */
 import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join, isAbsolute } from 'node:path';
@@ -221,7 +221,7 @@ export function resetWorktreeYAMLForRecovery({ worktreePath, id, doc }) {
     console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} Reset worktree YAML to in_progress for recovery`);
     return { reset: true };
 }
-// Note: updateBacklogMd removed (WU-1163) - now uses shared moveWUToDoneBacklog from wu-backlog-updater.mjs
+// Note: updateBacklogMd removed (WU-1163) - now uses shared moveWUToDoneBacklog from wu-backlog-updater.ts
 /**
  * Recover from zombie state
  *
@@ -299,7 +299,7 @@ export async function recoverZombieState({ id, doc, _worktreePath, _args }) {
             console.log(RECOVERY.COMMITTING);
             try {
                 await git.add([stampPath, wuPath, statusPath, backlogPath]);
-                // WU-1383: Set recovery mode env var to bypass stamp existence check in validate.mjs
+                // WU-1383: Set recovery mode env var to bypass stamp existence check in validate.ts
                 // During recovery, stamp and status=done are committed atomically, but pre-commit
                 // hooks run mid-commit when both files are staged but validation sees inconsistent state
                 process.env.WU_RECOVERY_ID = id;

package/dist/wu-repair-core.d.ts

@@ -7,12 +7,12 @@
  * - Admin repair (--admin mode): administrative fixes for done WUs
  *
  * This module consolidates logic from:
- * - wu-consistency-checker.mjs (consistency checks)
- * - wu-repair-claim.mjs (claim metadata repair)
- * - wu-admin-repair.mjs (admin fixes)
- * - wu-recovery.mjs (zombie state recovery)
+ * - wu-consistency-checker.ts (consistency checks)
+ * - wu-repair-claim.ts (claim metadata repair)
+ * - wu-admin-repair.ts (admin fixes)
+ * - wu-recovery.ts (zombie state recovery)
  *
- * @see {@link ../wu-repair.mjs} - Unified CLI interface
+ * @see {@link ../wu-repair.ts} - Unified CLI interface
  */
 import { checkWUConsistency, checkAllWUConsistency, repairWUInconsistency } from './wu-consistency-checker.js';
 export { checkWUConsistency, checkAllWUConsistency, repairWUInconsistency };

package/dist/wu-repair-core.js

@@ -7,12 +7,12 @@
  * - Admin repair (--admin mode): administrative fixes for done WUs
  *
  * This module consolidates logic from:
- * - wu-consistency-checker.mjs (consistency checks)
- * - wu-repair-claim.mjs (claim metadata repair)
- * - wu-admin-repair.mjs (admin fixes)
- * - wu-recovery.mjs (zombie state recovery)
+ * - wu-consistency-checker.ts (consistency checks)
+ * - wu-repair-claim.ts (claim metadata repair)
+ * - wu-admin-repair.ts (admin fixes)
+ * - wu-recovery.ts (zombie state recovery)
  *
- * @see {@link ../wu-repair.mjs} - Unified CLI interface
+ * @see {@link ../wu-repair.ts} - Unified CLI interface
  */
 import path from 'node:path';
 import { existsSync, writeFileSync, appendFileSync, mkdirSync, readFileSync } from 'node:fs';
@@ -29,7 +29,7 @@ import { validateLaneFormat } from './lane-checker.js';
 import { normalizeToDateString } from './date-utils.js';
 // Re-export for backwards compatibility
 export { checkWUConsistency, checkAllWUConsistency, repairWUInconsistency };
-// Re-export recovery utilities from wu-recovery.mjs
+// Re-export recovery utilities from wu-recovery.ts
 export { detectZombieState, recoverZombieState, resetWorktreeYAMLForRecovery, getRecoveryMarkerPath, getRecoveryAttemptCount, incrementRecoveryAttempt, clearRecoveryAttempts, shouldEscalateToManualIntervention, MAX_RECOVERY_ATTEMPTS, } from './wu-recovery.js';
 const PREFIX = LOG_PREFIX.REPAIR;
 // ============================================================================

package/dist/wu-schema-normalization.d.ts

@@ -1,5 +1,5 @@
 /**
- * @file wu-schema-normalization.mjs
+ * @file wu-schema-normalization.ts
  * @description Schema normalization for legacy WU YAML formats (WU-2004)
  *
  * Handles migration of legacy fields to current schema:

package/dist/wu-schema-normalization.js

@@ -1,5 +1,5 @@
 /**
- * @file wu-schema-normalization.mjs
+ * @file wu-schema-normalization.ts
  * @description Schema normalization for legacy WU YAML formats (WU-2004)
  *
  * Handles migration of legacy fields to current schema:

package/dist/wu-schema.d.ts

@@ -12,11 +12,11 @@
  * - WUSchema: Extends base + placeholder rejection (for wu:claim, wu:done)
  * - ReadyWUSchema: Alias for BaseWUSchema (for wu:create, wu:edit)
  *
- * @see {@link tools/wu-done.mjs} - Consumer (validates spec completeness, uses WUSchema)
- * @see {@link tools/wu-claim.mjs} - Consumer (validates spec completeness, uses WUSchema)
- * @see {@link tools/wu-create.mjs} - Consumer (structural validation, uses ReadyWUSchema)
- * @see {@link tools/wu-edit.mjs} - Consumer (structural validation, uses ReadyWUSchema)
- * @see {@link tools/validate.mjs} - Consumer (CI validation)
+ * @see {@link packages/@lumenflow/cli/src/wu-done.ts} - Consumer (validates spec completeness, uses WUSchema)
+ * @see {@link packages/@lumenflow/cli/src/wu-claim.ts} - Consumer (validates spec completeness, uses WUSchema)
+ * @see {@link packages/@lumenflow/cli/src/wu-create.ts} - Consumer (structural validation, uses ReadyWUSchema)
+ * @see {@link packages/@lumenflow/cli/src/wu-edit.ts} - Consumer (structural validation, uses ReadyWUSchema)
+ * @see {@link packages/@lumenflow/cli/src/validate.ts} - Consumer (CI validation)
  * @see {@link apps/web/src/lib/llm/schemas/orchestrator.ts} - Pattern reference
  */
 import { z } from 'zod';
@@ -27,11 +27,11 @@ import { z } from 'zod';
  * Single source of truth for placeholder detection (DRY principle).
  *
  * @example
- * // tools/wu-create.mjs
+ * // tools/wu-create.ts
  * description: `${PLACEHOLDER_SENTINEL} Describe the work...`
  *
  * @example
- * // tools/validate.mjs
+ * // tools/validate.ts
  * if (doc.description.includes(PLACEHOLDER_SENTINEL)) { error(); }
  */
 export declare const PLACEHOLDER_SENTINEL = "[PLACEHOLDER]";

package/dist/wu-schema.js

@@ -12,11 +12,11 @@
  * - WUSchema: Extends base + placeholder rejection (for wu:claim, wu:done)
  * - ReadyWUSchema: Alias for BaseWUSchema (for wu:create, wu:edit)
  *
- * @see {@link tools/wu-done.mjs} - Consumer (validates spec completeness, uses WUSchema)
- * @see {@link tools/wu-claim.mjs} - Consumer (validates spec completeness, uses WUSchema)
- * @see {@link tools/wu-create.mjs} - Consumer (structural validation, uses ReadyWUSchema)
- * @see {@link tools/wu-edit.mjs} - Consumer (structural validation, uses ReadyWUSchema)
- * @see {@link tools/validate.mjs} - Consumer (CI validation)
+ * @see {@link packages/@lumenflow/cli/src/wu-done.ts} - Consumer (validates spec completeness, uses WUSchema)
+ * @see {@link packages/@lumenflow/cli/src/wu-claim.ts} - Consumer (validates spec completeness, uses WUSchema)
+ * @see {@link packages/@lumenflow/cli/src/wu-create.ts} - Consumer (structural validation, uses ReadyWUSchema)
+ * @see {@link packages/@lumenflow/cli/src/wu-edit.ts} - Consumer (structural validation, uses ReadyWUSchema)
+ * @see {@link packages/@lumenflow/cli/src/validate.ts} - Consumer (CI validation)
  * @see {@link apps/web/src/lib/llm/schemas/orchestrator.ts} - Pattern reference
  */
 import { z } from 'zod';
@@ -48,11 +48,11 @@ const VALID_STATUSES = [
  * Single source of truth for placeholder detection (DRY principle).
  *
  * @example
- * // tools/wu-create.mjs
+ * // tools/wu-create.ts
  * description: `${PLACEHOLDER_SENTINEL} Describe the work...`
  *
  * @example
- * // tools/validate.mjs
+ * // tools/validate.ts
  * if (doc.description.includes(PLACEHOLDER_SENTINEL)) { error(); }
  */
 export const PLACEHOLDER_SENTINEL = '[PLACEHOLDER]';
@@ -86,7 +86,7 @@ const NEWLINE_PATTERN = /\\n|\n/;
  * This transform auto-repairs: ["a\nb\nc"] → ["a", "b", "c"]
  *
  * @example
- * // Input: ["tools/a.mjs\ntools/b.js"]
+ * // Input: ["tools/a.ts\ntools/b.js"]
  * // Output: ["tools/a.js", "tools/b.js"]
  */
 const normalizedStringArray = z.array(z.string()).transform((arr) => arr

package/dist/wu-spawn-context.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Memory Context Integration for wu:spawn (WU-1240, WU-1287)
+ *
+ * Thin wrapper that delegates to @lumenflow/memory's generateContext function.
+ * Provides spawn-specific formatting (## Memory Context header) while leveraging
+ * the full feature set of mem-context-core (lane filter, recency, decay).
+ *
+ * WU-1287: Refactored to eliminate duplicate logic. Now delegates to
+ * mem-context-core.generateContext for all memory context generation,
+ * ensuring spawn prompts benefit from lane filtering, recency limits,
+ * and decay/prioritization features.
+ *
+ * Features:
+ * - Detects memory layer initialization (memory.jsonl existence)
+ * - Delegates to mem-context-core for context generation
+ * - Respects lane filter, recency limits, decay/prioritization from mem-context-core
+ * - Configurable max context size (default 4KB, from .lumenflow.config.yaml)
+ * - Graceful skip when memory not initialized or @lumenflow/memory unavailable
+ * - No LLM calls (vendor-agnostic)
+ *
+ * @see {@link packages/@lumenflow/memory/src/mem-context-core.ts} - Core context generation
+ */
+import type { LumenFlowConfig } from './lumenflow-config-schema.js';
+/**
+ * Section header for memory context in spawn prompts
+ */
+export declare const MEMORY_CONTEXT_SECTION_HEADER = "## Memory Context";
+/**
+ * Options for generating memory context
+ */
+export interface GenerateMemoryContextOptions {
+    /** WU ID to filter context for */
+    wuId: string;
+    /** Lane to filter context for (WU-1281: enables lane-specific filtering) */
+    lane?: string;
+    /** Maximum size of context block in bytes (default: 4096) */
+    maxSize?: number;
+    /** WU-1238: Sort by decay score instead of recency (default: false) */
+    sortByDecay?: boolean;
+    /** WU-1238: Track access for included nodes (default: false) */
+    trackAccess?: boolean;
+    /** WU-1281: Maximum number of recent summaries to include (default: 5) */
+    maxRecentSummaries?: number;
+    /** WU-1281: Maximum number of project nodes to include (default: 10) */
+    maxProjectNodes?: number;
+}
+/**
+ * Checks if the memory layer is initialized.
+ *
+ * The memory layer is considered initialized when:
+ * 1. The .lumenflow/memory directory exists
+ * 2. memory.jsonl file exists and is non-empty
+ *
+ * @param baseDir - Project root directory
+ * @returns true if memory layer is initialized, false otherwise
+ */
+export declare function checkMemoryLayerInitialized(baseDir: string): Promise<boolean>;
+/**
+ * Gets the maximum context size from config or returns default.
+ *
+ * Reads from config.memory.spawn_context_max_size, defaulting to 4KB.
+ *
+ * @param config - LumenFlow configuration object
+ * @returns Maximum context size in bytes
+ */
+export declare function getMemoryContextMaxSize(config: Partial<LumenFlowConfig>): number;
+/**
+ * Generates the Memory Context section for wu:spawn prompts.
+ *
+ * WU-1287: Delegates to mem-context-core.generateContext for all context
+ * generation logic, ensuring spawn prompts benefit from:
+ * - Lane filtering (WU-1281)
+ * - Recency limits (WU-1281)
+ * - Decay-based prioritization (WU-1238)
+ * - WU-specific content prioritization (WU-1281)
+ *
+ * Context includes (via mem-context-core):
+ * 1. WU-specific context (checkpoints, notes matching wu_id) - high priority
+ * 2. Summaries relevant to the WU
+ * 3. Discoveries related to the WU
+ * 4. Project profile items (lifecycle=project memories) - lower priority, may be truncated
+ *
+ * @param baseDir - Project root directory
+ * @param options - Generation options (wuId, lane, maxSize, etc.)
+ * @returns Formatted Memory Context section, or empty string if no context
+ */
+export declare function generateMemoryContextSection(baseDir: string, options: GenerateMemoryContextOptions): Promise<string>;

package/dist/wu-spawn-context.js

@@ -0,0 +1,175 @@
+/**
+ * Memory Context Integration for wu:spawn (WU-1240, WU-1287)
+ *
+ * Thin wrapper that delegates to @lumenflow/memory's generateContext function.
+ * Provides spawn-specific formatting (## Memory Context header) while leveraging
+ * the full feature set of mem-context-core (lane filter, recency, decay).
+ *
+ * WU-1287: Refactored to eliminate duplicate logic. Now delegates to
+ * mem-context-core.generateContext for all memory context generation,
+ * ensuring spawn prompts benefit from lane filtering, recency limits,
+ * and decay/prioritization features.
+ *
+ * Features:
+ * - Detects memory layer initialization (memory.jsonl existence)
+ * - Delegates to mem-context-core for context generation
+ * - Respects lane filter, recency limits, decay/prioritization from mem-context-core
+ * - Configurable max context size (default 4KB, from .lumenflow.config.yaml)
+ * - Graceful skip when memory not initialized or @lumenflow/memory unavailable
+ * - No LLM calls (vendor-agnostic)
+ *
+ * @see {@link packages/@lumenflow/memory/src/mem-context-core.ts} - Core context generation
+ */
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * Default maximum context size in bytes (4KB)
+ */
+const DEFAULT_MAX_SIZE = 4096;
+/**
+ * Memory layer paths
+ */
+const MEMORY_PATHS = {
+    MEMORY_DIR: '.lumenflow/memory',
+    MEMORY_FILE: 'memory.jsonl',
+};
+/**
+ * Section header for memory context in spawn prompts
+ */
+export const MEMORY_CONTEXT_SECTION_HEADER = '## Memory Context';
+/**
+ * Checks if the memory layer is initialized.
+ *
+ * The memory layer is considered initialized when:
+ * 1. The .lumenflow/memory directory exists
+ * 2. memory.jsonl file exists and is non-empty
+ *
+ * @param baseDir - Project root directory
+ * @returns true if memory layer is initialized, false otherwise
+ */
+export async function checkMemoryLayerInitialized(baseDir) {
+    const memoryFilePath = path.join(baseDir, MEMORY_PATHS.MEMORY_DIR, MEMORY_PATHS.MEMORY_FILE);
+    if (!existsSync(memoryFilePath)) {
+        return false;
+    }
+    try {
+        const stats = statSync(memoryFilePath);
+        return stats.size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Gets the maximum context size from config or returns default.
+ *
+ * Reads from config.memory.spawn_context_max_size, defaulting to 4KB.
+ *
+ * @param config - LumenFlow configuration object
+ * @returns Maximum context size in bytes
+ */
+export function getMemoryContextMaxSize(config) {
+    const memoryConfig = config;
+    return memoryConfig?.memory?.spawn_context_max_size ?? DEFAULT_MAX_SIZE;
+}
+function hasGenerateContext(module) {
+    if (!module || typeof module !== 'object') {
+        return false;
+    }
+    const candidate = module;
+    return typeof candidate.generateContext === 'function';
+}
+/**
+ * Dynamically imports and calls generateContext from @lumenflow/memory.
+ *
+ * @param baseDir - Project root directory
+ * @param options - Generation options
+ * @returns Result from mem-context-core.generateContext, or null if unavailable
+ */
+async function callMemContextCore(baseDir, options) {
+    try {
+        // Dynamic import of optional peer dependency
+        // Use a non-literal import to avoid compile-time dependency on optional peer
+        const memoryModuleName = '@lumenflow/memory';
+        const memModule = (await import(memoryModuleName));
+        if (!hasGenerateContext(memModule)) {
+            return null;
+        }
+        return await memModule.generateContext(baseDir, options);
+    }
+    catch {
+        // @lumenflow/memory not available - return null for graceful degradation
+        return null;
+    }
+}
+/**
+ * Converts mem-context-core output format to spawn prompt format.
+ *
+ * mem-context-core uses "## Section" headers, but spawn prompts expect
+ * "### Section" for subsections under "## Memory Context".
+ *
+ * @param contextBlock - Raw context block from mem-context-core
+ * @param wuId - WU ID for the intro line
+ * @returns Formatted context with spawn-specific header structure
+ */
+function formatForSpawnPrompt(contextBlock, wuId) {
+    if (!contextBlock || contextBlock.trim() === '') {
+        return '';
+    }
+    // Remove the mem:context header comment if present
+    let content = contextBlock.replace(/^<!--\s*mem:context[^>]*-->\s*\n*/m, '');
+    // Convert ## headers to ### for subsection nesting under ## Memory Context
+    content = content.replace(/^## /gm, '### ');
+    // Build the full Memory Context section with spawn-specific formatting
+    const header = `${MEMORY_CONTEXT_SECTION_HEADER}\n\n`;
+    const intro = `Prior context from memory layer for ${wuId}:\n\n`;
+    return header + intro + content.trim() + '\n';
+}
+/**
+ * Generates the Memory Context section for wu:spawn prompts.
+ *
+ * WU-1287: Delegates to mem-context-core.generateContext for all context
+ * generation logic, ensuring spawn prompts benefit from:
+ * - Lane filtering (WU-1281)
+ * - Recency limits (WU-1281)
+ * - Decay-based prioritization (WU-1238)
+ * - WU-specific content prioritization (WU-1281)
+ *
+ * Context includes (via mem-context-core):
+ * 1. WU-specific context (checkpoints, notes matching wu_id) - high priority
+ * 2. Summaries relevant to the WU
+ * 3. Discoveries related to the WU
+ * 4. Project profile items (lifecycle=project memories) - lower priority, may be truncated
+ *
+ * @param baseDir - Project root directory
+ * @param options - Generation options (wuId, lane, maxSize, etc.)
+ * @returns Formatted Memory Context section, or empty string if no context
+ */
+export async function generateMemoryContextSection(baseDir, options) {
+    const { wuId, lane, maxSize = DEFAULT_MAX_SIZE, sortByDecay = false, trackAccess = false, maxRecentSummaries, maxProjectNodes, } = options;
+    // Check if memory layer is initialized
+    const isInitialized = await checkMemoryLayerInitialized(baseDir);
+    if (!isInitialized) {
+        return '';
+    }
+    // Delegate to mem-context-core.generateContext
+    const result = await callMemContextCore(baseDir, {
+        wuId,
+        maxSize,
+        sortByDecay,
+        trackAccess,
+        lane,
+        maxRecentSummaries,
+        maxProjectNodes,
+    });
+    // Graceful degradation if @lumenflow/memory is not available
+    if (!result) {
+        return '';
+    }
+    // If no context was generated, return empty
+    if (!result.success || result.stats.totalNodes === 0) {
+        return '';
+    }
+    // Format for spawn prompt
+    return formatForSpawnPrompt(result.contextBlock, wuId);
+}

package/dist/wu-spawn-helpers.d.ts

@@ -1,5 +1,5 @@
 /**
- * @file wu-spawn-helpers.mjs
+ * @file wu-spawn-helpers.ts
  * Helper functions for wu:spawn thinking mode and model configuration (WU-1577)
  *
  * Provides:

package/dist/wu-spawn-helpers.js

@@ -1,5 +1,5 @@
 /**
- * @file wu-spawn-helpers.mjs
+ * @file wu-spawn-helpers.ts
  * Helper functions for wu:spawn thinking mode and model configuration (WU-1577)
  *
  * Provides: