@lumenflow/cli 2.2.2 → 2.3.2

package/dist/wu-spawn.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * WU Spawn Helper
  *
@@ -25,7 +26,7 @@
  * Codex Mode:
  *   When --codex is used, outputs a Codex/GPT-friendly Markdown prompt (no antml/XML escaping).
  *
- * @see {@link docs/04-operations/_frameworks/lumenflow/agent/onboarding/agent-invocation-guide.md} - Context loading templates
+ * @see {@link https://lumenflow.dev/reference/agent-invocation-guide/} - Context loading templates
  */
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
@@ -43,38 +44,31 @@ import { validateSpawnArgs, generateExecutionModeSection, generateThinkToolGuida
 import { SpawnStrategyFactory } from '@lumenflow/core/dist/spawn-strategy.js';
 import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
 import { generateClientSkillsGuidance, generateSkillsSelectionSection, resolveClientConfig, } from '@lumenflow/core/dist/wu-spawn-skills.js';
+// WU-1253: Template loader for extracted prompt templates
+import { loadTemplatesWithOverrides, replaceTokens } from '@lumenflow/core/dist/template-loader.js';
 import { validateSpawnDependencies, formatDependencyError, } from '@lumenflow/core/dist/dependency-validator.js';
+// WU-1192: Import prompt generation from Core (single source of truth)
+// WU-1203: Import generateAgentCoordinationSection from core for config-driven progress signals
+// WU-1288: Import policy-based test guidance and mandatory standards generators
+import { TRUNCATION_WARNING_BANNER, SPAWN_END_SENTINEL, generateTestGuidance, generateAgentCoordinationSection, generatePolicyBasedTestGuidance, generateMandatoryStandards, generateEnforcementSummary, } from '@lumenflow/core/dist/wu-spawn.js';
+// WU-1288: Import resolvePolicy for methodology policy resolution
+import { resolvePolicy } from '@lumenflow/core/dist/resolve-policy.js';
+// WU-1240: Import memory context integration for spawn prompts
+import { generateMemoryContextSection, checkMemoryLayerInitialized, getMemoryContextMaxSize, } from '@lumenflow/core/dist/wu-spawn-context.js';
+// Re-export for backwards compatibility
+export { TRUNCATION_WARNING_BANNER, SPAWN_END_SENTINEL, generateTestGuidance, generateAgentCoordinationSection, };
 /**
  * Mandatory agent trigger patterns.
- * Mirrors MANDATORY_TRIGGERS from orchestration-advisory-loader.mjs.
+ * Mirrors MANDATORY_TRIGGERS from orchestration.constants.ts.
+ *
+ * Note: For LumenFlow framework development, this is empty since we don't have
+ * application-specific concerns like PHI, auth, or RLS. Projects using LumenFlow
+ * should configure their own triggers based on their domain requirements.
  */
 const MANDATORY_TRIGGERS = {
-    'security-auditor': ['supabase/migrations/**', '**/auth/**', '**/rls/**', '**/permissions/**'],
-    'beacon-guardian': ['**/prompts/**', '**/classification/**', '**/detector/**', '**/llm/**'],
+// No mandatory triggers for LumenFlow framework development.
 };
 const LOG_PREFIX = '[wu:spawn]';
-/**
- * WU-1131: Truncation prevention constants
- *
- * These constants help detect when spawn output has been truncated during
- * copy-paste operations or context loading. The warning banner alerts users
- * to the truncation risk, and the end sentinel allows verification that
- * the full output was received.
- */
-export const TRUNCATION_WARNING_BANNER = `<!-- LUMENFLOW_TRUNCATION_WARNING -->
-<!--
-  ⚠️ CRITICAL: DO NOT TRUNCATE THIS OUTPUT
-
-  This spawn prompt MUST be copied verbatim. Truncation causes:
-  - Missing constraints (agents ignore safety rules)
-  - Missing TDD directives (agents skip tests)
-  - Degraded agent performance
-
-  VERIFICATION: The output MUST end with: <!-- LUMENFLOW_SPAWN_END -->
-  If you don't see that sentinel at the end, the output was truncated.
--->
-`;
-export const SPAWN_END_SENTINEL = '<!-- LUMENFLOW_SPAWN_END -->';
 /**
  * Detect mandatory agents based on code paths.
  *
@@ -142,15 +136,6 @@ function formatManualTests(manualTests) {
     }
     return manualTests.map((test) => `- [ ] ${test}`).join('\n');
 }
-/**
- * Generate implementation context section (WU-1833)
- *
- * Includes spec_refs, notes, risks, and tests.manual if present.
- * Sections with no content are omitted to keep prompts lean.
- *
- * @param {object} doc - WU YAML document
- * @returns {string} Implementation context section or empty string
- */
 function generateImplementationContext(doc) {
     const sections = [];
     // References (spec_refs)
@@ -216,14 +201,16 @@ function formatInvariantForOutput(inv) {
         lines.push(`**Path:** \`${inv.path}\``);
     }
     if (inv.paths) {
-        lines.push(`**Paths:** ${inv.paths.map((p) => `\`${p}\``).join(', ')}`);
+        const formattedPaths = inv.paths.map((p) => `\`${p}\``).join(', ');
+        lines.push(`**Paths:** ${formattedPaths}`);
     }
     // WU-2254: forbidden-import specific fields
     if (inv.from) {
         lines.push(`**From:** \`${inv.from}\``);
     }
     if (inv.cannot_import && Array.isArray(inv.cannot_import)) {
-        lines.push(`**Cannot Import:** ${inv.cannot_import.map((m) => `\`${m}\``).join(', ')}`);
+        const formattedImports = inv.cannot_import.map((m) => `\`${m}\``).join(', ');
+        lines.push(`**Cannot Import:** ${formattedImports}`);
     }
     // WU-2254: required-pattern specific fields
     if (inv.pattern &&
@@ -232,7 +219,8 @@ function formatInvariantForOutput(inv) {
         lines.push(`**Pattern:** \`${inv.pattern}\``);
     }
     if (inv.scope && Array.isArray(inv.scope)) {
-        lines.push(`**Scope:** ${inv.scope.map((s) => `\`${s}\``).join(', ')}`);
+        const formattedScope = inv.scope.map((s) => `\`${s}\``).join(', ');
+        lines.push(`**Scope:** ${formattedScope}`);
     }
     lines.push('');
     return lines;
@@ -281,107 +269,8 @@ function generateInvariantsPriorArtSection(codePaths) {
     ];
     return lines.join('\n');
 }
-/**
- * WU types that require TDD (failing test first)
- */
-const TDD_REQUIRED_TYPES = ['feature', 'bug', 'tooling', 'enhancement'];
-/**
- * WU types that require existing tests to pass (no new tests mandated)
- */
-const EXISTING_TESTS_TYPES = ['refactor'];
-/**
- * WU types that require smoke tests + manual QA
- */
-const SMOKE_TEST_TYPES = ['visual', 'design', 'ui'];
-/**
- * WU types that only need format checks (no TDD)
- */
-const DOCS_ONLY_TYPES = ['documentation', 'docs', 'config'];
-/**
- * Generate type-aware test guidance (WU-1142)
- *
- * Returns appropriate test guidance based on WU type:
- * - feature/bug/tooling: Full TDD directive
- * - documentation: Format check only
- * - visual/design: Smoke test + manual QA
- * - refactor: Existing tests must pass
- *
- * @param {string} wuType - WU type from YAML
- * @returns {string} Test guidance section
- */
-export function generateTestGuidance(wuType) {
-    const type = (wuType || 'feature').toLowerCase();
-    // Documentation WUs - no TDD, just format checks
-    if (DOCS_ONLY_TYPES.includes(type)) {
-        return `## Documentation Standards
-
-**Format check only** - No TDD required for documentation WUs.
-
-### Requirements
-
-1. Run \`pnpm gates --docs-only\` before completion
-2. Ensure markdown formatting is correct
-3. Verify links are valid
-4. Check spelling and grammar`;
-    }
-    // Visual/Design WUs - smoke tests + manual QA
-    if (SMOKE_TEST_TYPES.includes(type)) {
-        return `## Visual/Design Testing
-
-**Smoke test + manual QA** - Visual WUs require different verification.
-
-### Requirements
-
-1. Create smoke test for component rendering (if applicable)
-2. Verify visual appearance manually
-3. Test responsive behavior across breakpoints
-4. Check accessibility (keyboard navigation, screen reader)
-5. Document manual QA results in completion notes`;
-    }
-    // Refactor WUs - existing tests must pass
-    if (EXISTING_TESTS_TYPES.includes(type)) {
-        return `## Refactor Testing
-
-**Existing tests must pass** - Refactoring must not break current behavior.
-
-### Requirements
-
-1. Run all existing tests BEFORE refactoring
-2. Run all existing tests AFTER refactoring
-3. No new tests required unless behavior changes
-4. If tests fail after refactor, the refactor introduced a bug`;
-    }
-    // Default: TDD required (feature, bug, tooling, enhancement)
-    return generateTDDDirective();
-}
-/**
- * Generate the TDD directive section (WU-1585)
- *
- * Positioned immediately after </task> preamble per "Lost in the Middle" research.
- * Critical instructions at START and END of prompt improve adherence.
- *
- * @returns {string} TDD directive section
- */
-function generateTDDDirective() {
-    return `## ⛔ TDD DIRECTIVE — READ BEFORE CODING
-
-**IF YOU WRITE IMPLEMENTATION CODE BEFORE A FAILING TEST, YOU HAVE FAILED THIS WU.**
-
-### Test-First Workflow (MANDATORY)
-
-1. Write a failing test for the acceptance criteria
-2. Run the test to confirm it fails (RED)
-3. Implement the minimum code to pass the test
-4. Run the test to confirm it passes (GREEN)
-5. Refactor if needed, keeping tests green
-
-### Why This Matters
-
-- Tests document expected behavior BEFORE implementation
-- Prevents scope creep and over-engineering
-- Ensures every feature has verification
-- Failing tests prove the test actually tests something`;
-}
+// WU-1192: generateTestGuidance and related constants moved to @lumenflow/core
+// See imports from '@lumenflow/core/dist/wu-spawn.js' above
 /**
  * Generate the context loading preamble
  *
@@ -438,7 +327,7 @@ CRITICAL RULES - ENFORCE BEFORE EVERY ACTION:
    - For ordinary errors: fix and retry autonomously (up to 3 attempts)
 
 4. VERIFY COMPLETION before reporting success
-   - Run: node tools/lib/agent-verification.mjs ${id} (from shared checkout)
+   - Run: node packages/@lumenflow/agent/dist/agent-verification.js ${id} (from shared checkout)
    - Exit 0 = passed, Exit 1 = INCOMPLETE
    - Never report "done" if verification fails
 
@@ -471,7 +360,7 @@ function generateCodexConstraints(id) {
 
 1. **TDD checkpoint**: tests BEFORE implementation; never skip RED
 2. **Stop on errors**: if any command fails, report BLOCKED (never DONE) with the error
-3. **Verify before success**: run \`pnpm gates\` in the worktree, then run \`node tools/lib/agent-verification.mjs ${id}\` (from the shared checkout)
+3. **Verify before success**: run \`pnpm gates\` in the worktree, then run \`node packages/@lumenflow/agent/dist/agent-verification.js ${id}\` (from the shared checkout)
 4. **No fabrication**: if blockers remain or verification fails, report INCOMPLETE
 5. **Git workflow**: avoid merge commits; let \`pnpm wu:done\` handle completion
 6. **Scope discipline**: stay within \`code_paths\`; capture out-of-scope issues via \`pnpm mem:create\`
@@ -481,10 +370,10 @@ function generateCodexConstraints(id) {
  * Generate mandatory agent advisory section
  *
  * @param {string[]} mandatoryAgents - Array of mandatory agent names
- * @param {string} id - WU ID
+ * @param {string} _id - WU ID (reserved for future use)
  * @returns {string} Mandatory agent section or empty string
  */
-function generateMandatoryAgentSection(mandatoryAgents, id) {
+function generateMandatoryAgentSection(mandatoryAgents, _id) {
     if (mandatoryAgents.length === 0) {
         return '';
     }
@@ -496,7 +385,7 @@ Based on code_paths, the following agents MUST be invoked:
 
 ${agentList}
 
-Run: pnpm orchestrate:suggest --wu ${id}
+Run: pnpm orchestrate:monitor to check agent status
 `;
 }
 /**
@@ -613,54 +502,8 @@ When finishing, provide structured output:
 
 This format enables orchestrator to track progress across waves.`;
 }
-/**
- * Generate agent coordination section (WU-1987)
- *
- * Provides guidance on mem:signal for parallel agent coordination,
- * orchestrate:status for dashboard checks, and abandoned WU handling.
- *
- * @param {string} id - WU ID
- * @returns {string} Agent coordination section
- */
-export function generateAgentCoordinationSection(id) {
-    return `## Agent Coordination (Parallel Work)
-
-### ⚠️ CRITICAL: Use mem:signal, NOT TaskOutput
-
-**DO NOT** use TaskOutput to check agent progress - it returns full transcripts
-and causes "prompt too long" errors. Always use the memory layer instead:
-
-\`\`\`bash
-# ✅ CORRECT: Compact signals (~6 lines)
-pnpm mem:inbox --since 30m
-
-# ❌ WRONG: Full transcripts (context explosion)
-# TaskOutput with block=false  <-- NEVER DO THIS FOR MONITORING
-\`\`\`
-
-### Automatic Completion Signals
-
-\`wu:done\` automatically broadcasts completion signals. You do not need to
-manually signal completion - just run \`wu:done\` and orchestrators will
-see your signal via \`mem:inbox\`.
-
-### Progress Signals (Optional)
-
-For long-running work, send progress signals at milestones:
-
-\`\`\`bash
-pnpm mem:signal "50% complete: tests passing, implementing adapter" --wu ${id}
-pnpm mem:signal "Blocked: waiting for WU-XXX dependency" --wu ${id}
-\`\`\`
-
-### Checking Status
-
-\`\`\`bash
-pnpm orchestrate:init-status -i INIT-XXX  # Initiative progress (compact)
-pnpm mem:inbox --since 1h                  # Recent signals from all agents
-pnpm mem:inbox --lane "Experience: Web"    # Lane-specific signals
-\`\`\``;
-}
+// WU-1203: generateAgentCoordinationSection is now imported from @lumenflow/core
+// The core version reads config and generates dynamic guidance based on progress_signals settings
 /**
  * Generate quick fix commands section (WU-1987)
  *
@@ -698,7 +541,7 @@ If you encounter a "worktree required" or "commit blocked" error:
 1. **Check existing worktrees**: \`git worktree list\`
 2. **Navigate to the worktree**: \`cd ${worktreePath || 'worktrees/<lane>-wu-xxx'}\`
 3. **Retry your operation** from within the worktree
-4. **Use relative paths only** (never absolute paths like \`/home/...\`)
+4. **Use relative paths only** (never absolute paths starting with /)
 
 ### Common Causes
 
@@ -850,7 +693,7 @@ pnpm mem:triage --wu ${id}           # List discoveries for this WU
 pnpm mem:triage --promote <node-id> --lane "<lane>"  # Create Bug WU (human action)
 \`\`\`
 
-See: docs/04-operations/_frameworks/lumenflow/agent/onboarding/agent-invocation-guide.md §Bug Discovery`;
+See: https://lumenflow.dev/reference/agent-invocation-guide/ §Bug Discovery`;
 }
 /**
  * Generate lane-specific guidance
@@ -949,6 +792,57 @@ pnpm wu:done --id ${id}
 
 **Do not ask** "should I run wu:done?" — just run it when gates pass.`;
 }
+/**
+ * WU-1253: Try to load templates for spawn prompt sections.
+ *
+ * Implements shadow mode: tries templates first, returns empty map
+ * if templates aren't available (caller uses hardcoded fallback).
+ *
+ * @param clientName - Client name for overrides (e.g., 'claude-code', 'cursor')
+ * @param context - Token values for replacement
+ * @returns Map of template id to processed content, empty if templates unavailable
+ */
+function tryLoadTemplates(clientName, context) {
+    const result = new Map();
+    try {
+        const baseDir = process.cwd();
+        const templates = loadTemplatesWithOverrides(baseDir, clientName);
+        // Process each template: replace tokens
+        for (const [id, template] of templates) {
+            const processed = replaceTokens(template.content, context);
+            result.set(id, processed);
+        }
+    }
+    catch {
+        // Template loading failed - return empty map for hardcoded fallback
+    }
+    return result;
+}
+/**
+ * WU-1253: Build template context from WU document.
+ *
+ * @param doc - WU YAML document
+ * @param id - WU ID
+ * @returns Context for template token replacement
+ */
+function buildSpawnTemplateContext(doc, id) {
+    const lane = doc.lane || '';
+    const laneParent = lane.split(':')[0]?.trim() || '';
+    const type = (doc.type || 'feature').toLowerCase();
+    return {
+        WU_ID: id,
+        LANE: lane,
+        TYPE: type,
+        TITLE: doc.title || '',
+        DESCRIPTION: doc.description || '',
+        WORKTREE_PATH: doc.worktree_path || '',
+        laneParent,
+        // Lowercase aliases for condition evaluation
+        type,
+        lane,
+        worktreePath: doc.worktree_path || '',
+    };
+}
 function generateClientBlocksSection(clientContext) {
     if (!clientContext?.config?.blocks?.length)
         return '';
@@ -972,38 +866,63 @@ function generateClientBlocksSection(clientContext) {
 export function generateTaskInvocation(doc, id, strategy, options = {}) {
     const codePaths = doc.code_paths || [];
     const mandatoryAgents = detectMandatoryAgents(codePaths);
+    // WU-1253: Try loading templates (shadow mode - falls back to hardcoded if unavailable)
+    const clientName = options.client?.name || 'claude-code';
+    const templateContext = buildSpawnTemplateContext(doc, id);
+    const templates = tryLoadTemplates(clientName, templateContext);
     const preamble = generatePreamble(id, strategy);
-    // WU-1142: Use type-aware test guidance instead of hardcoded TDD directive
-    const testGuidance = generateTestGuidance(doc.type);
     const clientContext = options.client;
     const config = options.config || getConfig();
+    // WU-1288: Resolve methodology policy from config
+    const policy = resolvePolicy(config);
+    // WU-1142: Use type-aware test guidance instead of hardcoded TDD directive
+    // WU-1288: Use policy-based test guidance that respects methodology.testing config
+    // WU-1253: Try template first, fall back to policy-based guidance
+    const testGuidance = templates.get('tdd-directive') || generatePolicyBasedTestGuidance(doc.type, policy);
+    // WU-1288: Generate enforcement summary from resolved policy
+    const enforcementSummary = generateEnforcementSummary(policy);
+    // WU-1288: Generate mandatory standards based on resolved policy
+    const mandatoryStandards = generateMandatoryStandards(policy);
     // WU-1142: Pass lane to get byLane skills
     const clientSkillsGuidance = generateClientSkillsGuidance(clientContext, doc.lane);
-    const skillsSection = generateSkillsSelectionSection(doc, config, clientContext?.name) +
-        (clientSkillsGuidance ? `\n${clientSkillsGuidance}` : '');
+    // WU-1253: Try template for skills-selection, build skills section
+    const skillsTemplateContent = templates.get('skills-selection');
+    const skillsGuidanceSuffix = clientSkillsGuidance ? '\n' + clientSkillsGuidance : '';
+    const skillsBaseContent = skillsTemplateContent || generateSkillsSelectionSection(doc, config, clientContext?.name);
+    const skillsSection = skillsBaseContent + skillsGuidanceSuffix;
     const clientBlocks = generateClientBlocksSection(clientContext);
     const mandatorySection = generateMandatoryAgentSection(mandatoryAgents, id);
     const laneGuidance = generateLaneGuidance(doc.lane);
-    const bugDiscoverySection = generateBugDiscoverySection(id);
-    const constraints = generateConstraints(id);
+    // WU-1253: Try template for bug-discovery
+    const bugDiscoverySection = templates.get('bug-discovery') || generateBugDiscoverySection(id);
+    // WU-1253: Try template for constraints
+    const constraints = templates.get('constraints') || generateConstraints(id);
     const implementationContext = generateImplementationContext(doc);
     // WU-2252: Generate invariants/prior-art section for code_paths
     const invariantsPriorArt = generateInvariantsPriorArtSection(codePaths);
     // WU-1986: Anthropic multi-agent best practices sections
-    const effortScaling = generateEffortScalingRules();
-    const parallelToolCalls = generateParallelToolCallGuidance();
-    const searchHeuristics = generateIterativeSearchHeuristics();
-    const tokenBudget = generateTokenBudgetAwareness(id);
+    // WU-1253: Try templates for these sections
+    const effortScaling = templates.get('effort-scaling') || generateEffortScalingRules();
+    const parallelToolCalls = templates.get('parallel-tool-calls') || generateParallelToolCallGuidance();
+    const searchHeuristics = templates.get('search-heuristics') || generateIterativeSearchHeuristics();
+    const tokenBudget = templates.get('token-budget') || generateTokenBudgetAwareness(id);
     const completionFormat = generateCompletionFormat(id);
     // WU-1987: Agent coordination and quick fix sections
     const agentCoordination = generateAgentCoordinationSection(id);
-    const quickFix = generateQuickFixCommands();
+    // WU-1253: Try template for quick-fix-commands
+    const quickFix = templates.get('quick-fix-commands') || generateQuickFixCommands();
     // WU-2107: Lane selection guidance
-    const laneSelection = generateLaneSelectionSection();
+    // WU-1253: Try template for lane-selection
+    const laneSelection = templates.get('lane-selection') || generateLaneSelectionSection();
     // WU-2362: Worktree path guidance for sub-agents
     const worktreeGuidance = generateWorktreePathGuidance(doc.worktree_path);
     // WU-1134: Worktree block recovery guidance
-    const worktreeBlockRecovery = generateWorktreeBlockRecoverySection(doc.worktree_path);
+    // WU-1253: Try template for worktree-recovery
+    const worktreeBlockRecovery = templates.get('worktree-recovery') || generateWorktreeBlockRecoverySection(doc.worktree_path);
+    // WU-1240: Memory context section
+    // Include if explicitly enabled and not disabled via noContext
+    const shouldIncludeMemoryContext = options.includeMemoryContext && !options.noContext;
+    const memoryContextSection = shouldIncludeMemoryContext ? options.memoryContextContent || '' : '';
     // Generate thinking mode sections if applicable
     const executionModeSection = generateExecutionModeSection(options);
     const thinkToolGuidance = generateThinkToolGuidance(options);
@@ -1049,19 +968,13 @@ ${codePaths.length > 0 ? codePaths.map((p) => `- ${p}`).join('\n') : '- No code
 ${mandatorySection}${invariantsPriorArt ? `---\n\n${invariantsPriorArt}\n\n` : ''}${implementationContext ? `---\n\n${implementationContext}\n\n` : ''}---
 
 ${thinkingBlock}${skillsSection}
----
+${memoryContextSection ? `---\n\n${memoryContextSection}\n\n` : ''}---
+
+${mandatoryStandards}
 
-## Mandatory Standards
+---
 
-- **LumenFlow**: Follow trunk-based flow, WIP=1, worktree discipline
-- **TDD**: Failing test first, then implementation, then passing test. 90%+ coverage on new application code
-- **Hexagonal Architecture**: Ports-first design. No application -> infrastructure imports
-- **SOLID/DRY/YAGNI/KISS**: No over-engineering, no premature abstraction
-- **Library-First**: Search context7 before writing custom code. No reinventing wheels
-- **Code Quality**: No string literals, no magic numbers, no brittle regexes when libraries exist
-- **Worktree Discipline**: ALWAYS use \`pnpm wu:claim\` to create worktrees (never \`git worktree add\` directly). Work ONLY in the worktree, never edit main
-- **Documentation**: Update tooling docs if changing tools. Keep docs in sync with code
-- **Sub-agents**: Use Explore agent for codebase investigation. Activate mandatory agents (security-auditor for PHI/auth, beacon-guardian for LLM/prompts)
+${enforcementSummary}
 
 ${clientBlocks ? `---\n\n${clientBlocks}\n\n` : ''}${worktreeGuidance ? `---\n\n${worktreeGuidance}\n\n` : ''}---
 
@@ -1161,6 +1074,9 @@ export function generateCodexPrompt(doc, id, strategy, options = {}) {
     const thinkingBlock = thinkingSections ? `${thinkingSections}\n\n---\n\n` : '';
     // WU-1134: Worktree block recovery guidance
     const worktreeBlockRecovery = generateWorktreeBlockRecoverySection(doc.worktree_path);
+    // WU-1240: Memory context section
+    const shouldIncludeMemoryContext = options.includeMemoryContext && !options.noContext;
+    const memoryContextSection = shouldIncludeMemoryContext ? options.memoryContextContent || '' : '';
     // WU-1131: Warning banner at start, end sentinel after constraints
     // WU-1142: Type-aware test guidance
     return `${TRUNCATION_WARNING_BANNER}# ${id}: ${doc.title || 'Untitled'}
@@ -1200,8 +1116,7 @@ ${formatAcceptance(doc.acceptance)}
 ---
 
 ${skillsSection}
-
----
+${memoryContextSection ? `---\n\n${memoryContextSection}\n\n` : ''}---
 
 ## Action
 
@@ -1212,7 +1127,7 @@ ${action}
 ## Verification
 
 - Run in worktree: \`pnpm gates\`
-- From shared checkout: \`node tools/lib/agent-verification.mjs ${id}\`
+- From shared checkout: \`node packages/@lumenflow/agent/dist/agent-verification.js ${id}\`
 
 ---
 
@@ -1256,16 +1171,7 @@ export function generateLaneOccupationWarning(lockMetadata, targetWuId, options
     warning += `   3. Block ${lockMetadata.wuId} if work is stalled: pnpm wu:block --id ${lockMetadata.wuId}`;
     return warning;
 }
-/**
- * Main entry point
- */
-async function main() {
-    // WU-2202: Validate dependencies BEFORE any other operation
-    // This prevents false lane occupancy reports when yaml package is missing
-    const depResult = await validateSpawnDependencies();
-    if (!depResult.valid) {
-        die(formatDependencyError('wu:spawn', depResult.missing));
-    }
+function parseAndValidateArgs() {
     const args = createWUParser({
         name: 'wu-spawn',
         description: 'Generate Task tool invocation for sub-agent WU execution',
@@ -1278,6 +1184,7 @@ async function main() {
             WU_OPTIONS.parentWu, // WU-1945: Parent WU for spawn registry tracking
             WU_OPTIONS.client,
             WU_OPTIONS.vendor,
+            WU_OPTIONS.noContext, // WU-1240: Skip memory context injection
         ],
         required: ['id'],
         allowPositionalId: true,
@@ -1289,42 +1196,92 @@ async function main() {
     catch (e) {
         die(e.message);
     }
-    const id = args.id.toUpperCase();
-    if (!PATTERNS.WU_ID.test(id)) {
-        die(`Invalid WU id '${args.id}'. Expected format WU-123`);
-    }
-    const WU_PATH = WU_PATHS.WU(id);
+    return args;
+}
+/**
+ * Load and validate WU document from YAML file
+ */
+function loadWUDocument(id, wuPath) {
     // Check if WU file exists
-    if (!existsSync(WU_PATH)) {
-        die(`WU file not found: ${WU_PATH}\n\n` +
+    if (!existsSync(wuPath)) {
+        die(`WU file not found: ${wuPath}\n\n` +
             `Cannot spawn a sub-agent for a WU that doesn't exist.\n\n` +
             `Options:\n` +
             `  1. Create the WU first: pnpm wu:create --id ${id} --lane <lane> --title "..."\n` +
             `  2. Check if the WU ID is correct`);
     }
-    // Read and parse WU YAML
-    let doc;
+    // Read WU file
     let text;
     try {
-        text = readFileSync(WU_PATH, { encoding: FILE_SYSTEM.UTF8 });
+        text = readFileSync(wuPath, { encoding: FILE_SYSTEM.UTF8 });
     }
     catch (e) {
-        die(`Failed to read WU file: ${WU_PATH}\n\n` +
+        die(`Failed to read WU file: ${wuPath}\n\n` +
             `Error: ${e.message}\n\n` +
             `Options:\n` +
-            `  1. Check file permissions: ls -la ${WU_PATH}\n` +
+            `  1. Check file permissions: ls -la ${wuPath}\n` +
             `  2. Ensure the file exists and is readable`);
     }
+    // Parse YAML
     try {
-        doc = parseYAML(text);
+        return parseYAML(text);
     }
     catch (e) {
-        die(`Failed to parse WU YAML ${WU_PATH}\n\n` +
+        die(`Failed to parse WU YAML ${wuPath}\n\n` +
             `Error: ${e.message}\n\n` +
             `Options:\n` +
             `  1. Validate YAML syntax: pnpm wu:validate --id ${id}\n` +
             `  2. Fix YAML errors manually and retry`);
     }
+}
+/**
+ * Resolve the client name from args and config
+ */
+function resolveClientName(args, config) {
+    let clientName = args.client;
+    if (!clientName && args.vendor) {
+        console.warn(`${LOG_PREFIX} ${EMOJI.WARNING} Warning: --vendor is deprecated. Use --client.`);
+        clientName = args.vendor;
+    }
+    // Codex handling (deprecated legacy flag)
+    if (args.codex && !clientName) {
+        console.warn(`${LOG_PREFIX} ${EMOJI.WARNING} Warning: --codex is deprecated. Use --client codex-cli.`);
+        clientName = 'codex-cli';
+    }
+    return clientName || config.agents.defaultClient || 'claude-code';
+}
+/**
+ * Check lane occupation and warn if occupied by a different WU
+ */
+async function checkAndWarnLaneOccupation(lane, id) {
+    if (!lane)
+        return;
+    const existingLock = checkLaneOccupation(lane);
+    if (existingLock && existingLock.wuId !== id) {
+        // Lane is occupied by a different WU
+        const { isLockStale } = await import('@lumenflow/core/dist/lane-lock.js');
+        const isStale = isLockStale(existingLock);
+        const warning = generateLaneOccupationWarning(existingLock, id, { isStale });
+        console.warn(`${LOG_PREFIX} ${EMOJI.WARNING}\n${warning}\n`);
+    }
+}
+/**
+ * Main entry point
+ */
+async function main() {
+    // WU-2202: Validate dependencies BEFORE any other operation
+    // This prevents false lane occupancy reports when yaml package is missing
+    const depResult = await validateSpawnDependencies();
+    if (!depResult.valid) {
+        die(formatDependencyError('wu:spawn', depResult.missing));
+    }
+    const args = parseAndValidateArgs();
+    const id = args.id.toUpperCase();
+    if (!PATTERNS.WU_ID.test(id)) {
+        die(`Invalid WU id '${args.id}'. Expected format WU-123`);
+    }
+    const wuPath = WU_PATHS.WU(id);
+    const doc = loadWUDocument(id, wuPath);
     // Warn if WU is not in ready or in_progress status
     const validStatuses = [WU_STATUS.READY, WU_STATUS.IN_PROGRESS];
     if (!validStatuses.includes(doc.status)) {
@@ -1333,17 +1290,7 @@ async function main() {
         console.warn('');
     }
     // WU-1603: Check if lane is already occupied and warn
-    const lane = doc.lane;
-    if (lane) {
-        const existingLock = checkLaneOccupation(lane);
-        if (existingLock && existingLock.wuId !== id) {
-            // Lane is occupied by a different WU
-            const { isLockStale } = await import('@lumenflow/core/dist/lane-lock.js');
-            const isStale = isLockStale(existingLock);
-            const warning = generateLaneOccupationWarning(existingLock, id, { isStale });
-            console.warn(`${LOG_PREFIX} ${EMOJI.WARNING}\n${warning}\n`);
-        }
-    }
+    await checkAndWarnLaneOccupation(doc.lane, id);
     // Build thinking mode options for task invocation
     const thinkingOptions = {
         thinking: args.thinking,
@@ -1352,21 +1299,25 @@ async function main() {
     };
     // Client Resolution
     const config = getConfig();
-    let clientName = args.client;
-    if (!clientName && args.vendor) {
-        console.warn(`${LOG_PREFIX} ${EMOJI.WARNING} Warning: --vendor is deprecated. Use --client.`);
-        clientName = args.vendor;
-    }
-    // Codex handling (deprecated legacy flag)
-    if (args.codex) {
-        if (!clientName) {
-            console.warn(`${LOG_PREFIX} ${EMOJI.WARNING} Warning: --codex is deprecated. Use --client codex-cli.`);
-            clientName = 'codex-cli';
+    const clientName = resolveClientName(args, config);
+    // WU-1240: Generate memory context if not skipped
+    const baseDir = process.cwd();
+    let memoryContextContent = '';
+    const shouldIncludeMemoryContext = !args.noContext;
+    if (shouldIncludeMemoryContext) {
+        const isMemoryInitialized = await checkMemoryLayerInitialized(baseDir);
+        if (isMemoryInitialized) {
+            const maxSize = getMemoryContextMaxSize(config);
+            memoryContextContent = await generateMemoryContextSection(baseDir, {
+                wuId: id,
+                lane: doc.lane,
+                maxSize,
+            });
+            if (memoryContextContent) {
+                console.log(`${LOG_PREFIX} Memory context loaded (${memoryContextContent.length} bytes)`);
+            }
         }
     }
-    if (!clientName) {
-        clientName = config.agents.defaultClient || 'claude-code';
-    }
     // Create strategy
     const strategy = SpawnStrategyFactory.create(clientName);
     const clientContext = { name: clientName, config: resolveClientConfig(config, clientName) };
@@ -1386,6 +1337,11 @@ async function main() {
         ...thinkingOptions,
         client: clientContext,
         config,
+        // WU-1240: Include memory context in spawn prompt
+        baseDir,
+        includeMemoryContext: shouldIncludeMemoryContext && memoryContextContent.length > 0,
+        memoryContextContent,
+        noContext: args.noContext,
     });
     console.log(`${LOG_PREFIX} Generated Task tool invocation for ${id}`);
     console.log(`${LOG_PREFIX} Copy the block below to spawn a sub-agent:\n`);
@@ -1409,5 +1365,5 @@ async function main() {
 // path but import.meta.url resolves to the real path - they never match
 import { runCLI } from './cli-entry-point.js';
 if (import.meta.main) {
-    runCLI(main);
+    void runCLI(main);
 }