@lumenflow/cli 3.12.5 → 3.12.6

package/dist/chunk-K2DIWWDM.js

@@ -0,0 +1,1766 @@
+import {
+  checkSizingAdvisory
+} from "./chunk-DSYBDHYH.js";
+import {
+  resolveStateDir
+} from "./chunk-NRAXROED.js";
+import {
+  isInWorktree
+} from "./chunk-E3REJTAJ.js";
+import {
+  SpawnStrategyFactory,
+  WUStateStore,
+  WU_BRIEF_EVIDENCE_NOTE_PREFIX,
+  WU_OPTIONS,
+  createWUParser,
+  formatDependencyError,
+  validateSpawnDependencies
+} from "./chunk-2GXVIN57.js";
+import {
+  SPAWN_END_SENTINEL,
+  TRUNCATION_WARNING_BANNER,
+  evaluateCondition,
+  formatSpawnRecordedMessage,
+  generateAgentCoordinationSection,
+  generateClientSkillsGuidance,
+  generateExecutionModeSection,
+  generateSkillsSelectionSection,
+  generateThinkToolGuidance,
+  loadTemplatesWithOverrides,
+  recordSpawnToRegistry,
+  replaceTokens,
+  resolveClientConfig,
+  validateSpawnArgs
+} from "./chunk-6W5XHWYV.js";
+import {
+  checkLaneLock,
+  getLockPolicyForLane,
+  getWipLimitForLane
+} from "./chunk-JONWQUB5.js";
+import {
+  createGitForPath
+} from "./chunk-2UFQ3A3C.js";
+import {
+  TEST_METHODOLOGY_HINTS,
+  classifyWork,
+  generateCodeCraftGuidance,
+  generateDesignContextSection,
+  generateEnforcementSummary,
+  generateMandatoryStandards,
+  generatePolicyBasedTestGuidance,
+  generateReadBeforeWriteDiscipline,
+  generateSelfReviewDirective
+} from "./chunk-NMG736UR.js";
+import {
+  INVARIANT_TYPES,
+  loadInvariants
+} from "./chunk-EZ6ZBYBM.js";
+import {
+  parseYAML
+} from "./chunk-NRIZR3A7.js";
+import {
+  WU_PATHS
+} from "./chunk-6HO4GWJE.js";
+import {
+  BRANCHES,
+  CONFIG_FILES,
+  DIRECTORIES,
+  EMOJI,
+  FILE_SYSTEM,
+  LUMENFLOW_PATHS,
+  PATTERNS,
+  REMOTES
+} from "./chunk-DWMLTXKQ.js";
+import {
+  WU_STATUS,
+  findProjectRoot,
+  getConfig,
+  resolvePolicy
+} from "./chunk-V6OJGLBA.js";
+import {
+  ErrorCodes,
+  createError,
+  die
+} from "./chunk-RXRKBBSM.js";
+
+// src/wu-spawn-strategy-resolver.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+
+// ../core/dist/wu-spawn-context.js
+import { existsSync, statSync } from "fs";
+import path from "path";
+var DEFAULT_MAX_SIZE = 4096;
+var MEMORY_PATHS = {
+  MEMORY_DIR: LUMENFLOW_PATHS.MEMORY_DIR,
+  MEMORY_FILE: "memory.jsonl"
+};
+var MEMORY_CONTEXT_ERRORS = {
+  DEPRECATED_SPAWN_CONTEXT_MAX_SIZE: "memory.spawn_context_max_size is no longer supported. Use memory.delegation_context_max_size instead."
+};
+var MEMORY_CONTEXT_SECTION_HEADER = "## Memory Context";
+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;
+  }
+}
+function getMemoryContextMaxSize(config) {
+  const memoryConfig = config;
+  if (memoryConfig?.memory?.spawn_context_max_size !== void 0) {
+    throw createError(ErrorCodes.DEPRECATED_API, MEMORY_CONTEXT_ERRORS.DEPRECATED_SPAWN_CONTEXT_MAX_SIZE);
+  }
+  return memoryConfig?.memory?.delegation_context_max_size ?? DEFAULT_MAX_SIZE;
+}
+function hasGenerateContext(module) {
+  if (!module || typeof module !== "object") {
+    return false;
+  }
+  const candidate = module;
+  return typeof candidate.generateContext === "function";
+}
+async function callMemContextCore(baseDir, options) {
+  try {
+    const memoryModuleName = "@lumenflow/memory";
+    const memModule = await import(memoryModuleName);
+    if (!hasGenerateContext(memModule)) {
+      return null;
+    }
+    return await memModule.generateContext(baseDir, options);
+  } catch {
+    return null;
+  }
+}
+function formatForSpawnPrompt(contextBlock, wuId) {
+  if (!contextBlock || contextBlock.trim() === "") {
+    return "";
+  }
+  let content = contextBlock.replace(/^<!--\s*mem:context[^>]*-->\s*\n*/m, "");
+  content = content.replace(/^## /gm, "### ");
+  const header = `${MEMORY_CONTEXT_SECTION_HEADER}
+
+`;
+  const intro = `Prior context from memory layer for ${wuId}:
+
+`;
+  return header + intro + content.trim() + "\n";
+}
+async function generateMemoryContextSection(baseDir, options) {
+  const { wuId, lane, maxSize = DEFAULT_MAX_SIZE, sortByDecay = false, trackAccess = false, maxRecentSummaries, maxProjectNodes } = options;
+  const isInitialized = await checkMemoryLayerInitialized(baseDir);
+  if (!isInitialized) {
+    return "";
+  }
+  const result = await callMemContextCore(baseDir, {
+    wuId,
+    maxSize,
+    sortByDecay,
+    trackAccess,
+    lane,
+    maxRecentSummaries,
+    maxProjectNodes
+  });
+  if (!result) {
+    return "";
+  }
+  if (!result.success || result.stats.totalNodes === 0) {
+    return "";
+  }
+  return formatForSpawnPrompt(result.contextBlock, wuId);
+}
+
+// src/wu-spawn-prompt-builders.ts
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import { minimatch } from "minimatch";
+
+// src/wu-spawn-completion.ts
+var COMPLETION_COMMANDS = {
+  GATES: "pnpm gates",
+  STATUS_PREFIX: "pnpm wu:status --id",
+  DONE_PREFIX: "pnpm wu:done --id",
+  RECOVER_PREFIX: "pnpm wu:recover --id"
+};
+var WU_STATUS_VALUES = {
+  DONE: "done",
+  IN_PROGRESS: "in_progress"
+};
+function formatWuCommand(commandPrefix, id) {
+  return `${commandPrefix} ${id}`;
+}
+function generateCompletionWorkflowSection(id) {
+  const statusCommand = formatWuCommand(COMPLETION_COMMANDS.STATUS_PREFIX, id);
+  const doneCommand = formatWuCommand(COMPLETION_COMMANDS.DONE_PREFIX, id);
+  const recoverCommand = formatWuCommand(COMPLETION_COMMANDS.RECOVER_PREFIX, id);
+  return `## Completion Workflow
+
+**CRITICAL: Complete autonomously. Do NOT ask for permission.**
+
+After all acceptance criteria are satisfied:
+
+1. Run gates in the worktree: \`${COMPLETION_COMMANDS.GATES}\`
+2. If gates pass, cd back to main checkout
+3. Verify status from main: \`${statusCommand}\`
+4. If status is \`${WU_STATUS_VALUES.DONE}\`, stop and report already completed.
+   do NOT run \`${doneCommand}\`.
+   do NOT run \`${recoverCommand}\`.
+5. If status is \`${WU_STATUS_VALUES.IN_PROGRESS}\`, continue autonomously with \`${doneCommand}\`.
+
+\`\`\`bash
+# From worktree, after gates pass:
+cd /path/to/main  # NOT the worktree
+${statusCommand}
+
+# Status decision:
+# - done: report already completed, stop.
+# - in_progress: complete now.
+${doneCommand}
+\`\`\`
+
+**wu:done** handles: merge to main, stamp creation, worktree cleanup.
+
+**Do not ask** "should I run wu:done?" \u2014 just run it when gates pass.`;
+}
+
+// src/wu-spawn-prompt-builders.ts
+var SPAWN_PROMPT_BUILDERS_DIR = path2.dirname(fileURLToPath(import.meta.url));
+var DEFAULT_TEMPLATE_BASE_DIR = findProjectRoot(SPAWN_PROMPT_BUILDERS_DIR);
+var DEFAULT_WORKTREES_DIR_SEGMENT = DIRECTORIES.WORKTREES.replace(/\/+$/g, "");
+var PRIMARY_MAIN_REF = `${REMOTES.ORIGIN}/${BRANCHES.MAIN}`;
+var LANE_GUIDANCE_TEMPLATE_ID_PREFIX = "lane-guidance-";
+var DESIGN_CONTEXT_TEMPLATE_ID_PREFIX = "design-context-";
+var VERIFICATION_TEMPLATE_ID_PREFIX = "verification-";
+var REQUIRED_VERIFICATION_TEMPLATE_ID = "verification-requirements";
+var VERIFICATION_TEMPLATE_IDS = /* @__PURE__ */ new Set([
+  "documentation-directive",
+  "visual-directive",
+  "refactor-directive",
+  "structured-content-directive"
+]);
+function normalizeDirectorySegment(value, fallback) {
+  const normalized = value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  return normalized.length > 0 ? normalized : fallback;
+}
+function resolveWorktreesDirSegment(config) {
+  const configuredWorktreesDir = config?.directories.worktrees;
+  if (configuredWorktreesDir) {
+    return normalizeDirectorySegment(configuredWorktreesDir, DEFAULT_WORKTREES_DIR_SEGMENT);
+  }
+  return DEFAULT_WORKTREES_DIR_SEGMENT;
+}
+function resolveWorktreePathHint(doc, id, config) {
+  if (doc.worktree_path) {
+    return doc.worktree_path;
+  }
+  return `${resolveWorktreesDirSegment(config)}/<lane>-${id.toLowerCase()}`;
+}
+function resolveClaimWorktreePathHint(lane, id, config) {
+  const laneSlug = (lane || "unknown").toLowerCase().replace(/[:\s]+/g, "-").replace(/-+/g, "-");
+  return `${resolveWorktreesDirSegment(config)}/${laneSlug}-${id.toLowerCase()}`;
+}
+function usesNonTddHint(testMethodologyHint) {
+  return testMethodologyHint === TEST_METHODOLOGY_HINTS.SMOKE_TEST || testMethodologyHint === TEST_METHODOLOGY_HINTS.STRUCTURED_CONTENT;
+}
+function resolveLaneGuidanceSection(templates, lane) {
+  const templateSections = collectTemplateSections(
+    templates,
+    (id) => id.startsWith(LANE_GUIDANCE_TEMPLATE_ID_PREFIX)
+  );
+  if (templateSections.length > 0) {
+    return templateSections.join("\n\n---\n\n");
+  }
+  return generateLaneGuidance(lane);
+}
+function collectTemplateSections(templates, matcher) {
+  return Array.from(templates.entries()).filter(([id]) => matcher(id)).map(([, content]) => content.trim()).filter((content) => content.length > 0);
+}
+function resolveVerificationGuidanceSection(templates, fallback) {
+  const requiredVerificationSections = collectTemplateSections(
+    templates,
+    (id) => id === REQUIRED_VERIFICATION_TEMPLATE_ID
+  );
+  const strategySections = collectTemplateSections(
+    templates,
+    (id) => id !== REQUIRED_VERIFICATION_TEMPLATE_ID && (id.startsWith("methodology-") || id.startsWith(VERIFICATION_TEMPLATE_ID_PREFIX) || VERIFICATION_TEMPLATE_IDS.has(id))
+  );
+  const templateSections = [...requiredVerificationSections, ...strategySections];
+  if (templateSections.length > 0) {
+    return templateSections.join("\n\n---\n\n");
+  }
+  return fallback;
+}
+function resolveDesignContextSection(templates, classification) {
+  const templateSections = collectTemplateSections(
+    templates,
+    (id) => id.startsWith(DESIGN_CONTEXT_TEMPLATE_ID_PREFIX)
+  );
+  if (templateSections.length > 0) {
+    return templateSections.join("\n\n---\n\n");
+  }
+  return generateDesignContextSection(classification);
+}
+var MANDATORY_TRIGGERS = {
+  // No mandatory triggers for LumenFlow framework development.
+};
+function detectMandatoryAgents(codePaths) {
+  if (!codePaths || codePaths.length === 0) {
+    return [];
+  }
+  const triggeredAgents = /* @__PURE__ */ new Set();
+  for (const [agentName, patterns] of Object.entries(MANDATORY_TRIGGERS)) {
+    const isTriggered = codePaths.some(
+      (filePath) => patterns.some((pattern) => minimatch(filePath, pattern))
+    );
+    if (isTriggered) {
+      triggeredAgents.add(agentName);
+    }
+  }
+  return Array.from(triggeredAgents);
+}
+function formatAcceptance(acceptance) {
+  if (!acceptance || acceptance.length === 0) {
+    return "- No acceptance criteria defined";
+  }
+  return acceptance.map((item) => `- [ ] ${item}`).join("\n");
+}
+function formatSpecRefs(specRefs) {
+  if (!specRefs || specRefs.length === 0) {
+    return "";
+  }
+  return specRefs.map((ref) => `- ${ref}`).join("\n");
+}
+function formatRisks(risks) {
+  if (!risks || risks.length === 0) {
+    return "";
+  }
+  return risks.map((risk) => `- ${risk}`).join("\n");
+}
+function formatManualTests(manualTests) {
+  if (!manualTests || manualTests.length === 0) {
+    return "";
+  }
+  return manualTests.map((test) => `- [ ] ${test}`).join("\n");
+}
+function formatTestPaths(testPaths) {
+  if (!testPaths || testPaths.length === 0) {
+    return "";
+  }
+  return testPaths.map((testPath) => `- \`${testPath}\``).join("\n");
+}
+function formatRequiredVerification(doc) {
+  const sections = [];
+  const unitTests = formatTestPaths(doc.tests?.unit);
+  if (unitTests) {
+    sections.push(`### Unit Test Paths
+
+${unitTests}`);
+  }
+  const e2eTests = formatTestPaths(doc.tests?.e2e);
+  if (e2eTests) {
+    sections.push(`### E2E Test Paths
+
+${e2eTests}`);
+  }
+  const manualTests = formatManualTests(doc.tests?.manual);
+  if (manualTests) {
+    sections.push(`### Manual Verification
+
+${manualTests}`);
+  }
+  return sections.join("\n\n");
+}
+function generateRequiredVerificationSection(doc) {
+  const requiredVerification = formatRequiredVerification(doc);
+  if (!requiredVerification) {
+    return "";
+  }
+  return `## Required Verification From WU Spec
+
+${requiredVerification}`;
+}
+function generateImplementationContext(doc) {
+  const sections = [];
+  const refs = formatSpecRefs(doc.spec_refs);
+  if (refs) {
+    sections.push(`## References
+
+${refs}`);
+  }
+  if (doc.notes && doc.notes.trim()) {
+    sections.push(`## Implementation Notes
+
+${doc.notes.trim()}`);
+  }
+  const risks = formatRisks(doc.risks);
+  if (risks) {
+    sections.push(`## Risks
+
+${risks}`);
+  }
+  if (sections.length === 0) {
+    return "";
+  }
+  return sections.join("\n\n---\n\n");
+}
+function codePathMatchesInvariant(invariant, codePaths) {
+  switch (invariant.type) {
+    case INVARIANT_TYPES.FORBIDDEN_FILE:
+    case INVARIANT_TYPES.REQUIRED_FILE: {
+      const invariantPath = invariant.path;
+      if (!invariantPath) {
+        return false;
+      }
+      return codePaths.some(
+        (p) => p === invariantPath || minimatch(p, invariantPath) || minimatch(invariantPath, p)
+      );
+    }
+    case INVARIANT_TYPES.MUTUAL_EXCLUSIVITY: {
+      const invariantPaths = invariant.paths;
+      if (!invariantPaths || invariantPaths.length === 0) {
+        return false;
+      }
+      return codePaths.some(
+        (p) => invariantPaths.some((invPath) => p === invPath || minimatch(p, invPath))
+      );
+    }
+    case INVARIANT_TYPES.FORBIDDEN_PATTERN:
+    case INVARIANT_TYPES.REQUIRED_PATTERN:
+      return invariant.scope?.some(
+        (scopePattern) => codePaths.some((p) => minimatch(p, scopePattern))
+      ) ?? false;
+    // WU-2254: forbidden-import uses 'from' glob instead of 'scope'
+    case INVARIANT_TYPES.FORBIDDEN_IMPORT:
+      return invariant.from ? codePaths.some((p) => minimatch(p, invariant.from)) : false;
+    default:
+      return false;
+  }
+}
+function formatInvariantForOutput(inv) {
+  const lines = [`### ${inv.id} (${inv.type})`, "", inv.description, ""];
+  if (inv.message) {
+    lines.push(`**Action:** ${inv.message}`, "");
+  }
+  if (inv.path) {
+    lines.push(`**Path:** \`${inv.path}\``);
+  }
+  if (inv.paths) {
+    const formattedPaths = inv.paths.map((p) => `\`${p}\``).join(", ");
+    lines.push(`**Paths:** ${formattedPaths}`);
+  }
+  if (inv.from) {
+    lines.push(`**From:** \`${inv.from}\``);
+  }
+  if (inv.cannot_import && Array.isArray(inv.cannot_import)) {
+    const formattedImports = inv.cannot_import.map((m) => `\`${m}\``).join(", ");
+    lines.push(`**Cannot Import:** ${formattedImports}`);
+  }
+  if (inv.pattern && (inv.type === INVARIANT_TYPES.REQUIRED_PATTERN || inv.type === INVARIANT_TYPES.FORBIDDEN_PATTERN)) {
+    lines.push(`**Pattern:** \`${inv.pattern}\``);
+  }
+  if (inv.scope && Array.isArray(inv.scope)) {
+    const formattedScope = inv.scope.map((s) => `\`${s}\``).join(", ");
+    lines.push(`**Scope:** ${formattedScope}`);
+  }
+  lines.push("");
+  return lines;
+}
+function generateInvariantsPriorArtSection(codePaths) {
+  if (!codePaths || codePaths.length === 0) {
+    return "";
+  }
+  const invariantsPath = path2.resolve("tools/invariants.yml");
+  if (!existsSync2(invariantsPath)) {
+    return "";
+  }
+  let invariants;
+  try {
+    invariants = loadInvariants(invariantsPath);
+  } catch {
+    return "";
+  }
+  if (!invariants || invariants.length === 0) {
+    return "";
+  }
+  const relevantInvariants = invariants.filter((inv) => codePathMatchesInvariant(inv, codePaths));
+  if (relevantInvariants.length === 0) {
+    return "";
+  }
+  const lines = [
+    "## Invariants/Prior-Art (WU-2252)",
+    "",
+    "The following repo invariants are relevant to your code_paths:",
+    "",
+    ...relevantInvariants.flatMap(formatInvariantForOutput),
+    "**IMPORTANT:** Do not create specs or acceptance criteria that conflict with these invariants."
+  ];
+  return lines.join("\n");
+}
+function generatePreamble(id, strategy) {
+  return strategy.getPreamble(id);
+}
+function generateConstraints(id, options) {
+  const includeTdd = options?.includeTddCheckpoint !== false;
+  const tddCheckpointBlock = includeTdd ? `
+1. TDD CHECKPOINT (VERIFY BEFORE IMPLEMENTATION)
+   - Did you write tests BEFORE implementation?
+   - Is there at least one failing test for each acceptance criterion?
+   - Never skip the RED phase \u2014 failing tests prove the test works
+
+` : "";
+  const antiLoopNum = includeTdd ? 2 : 1;
+  const stopAskNum = includeTdd ? 3 : 2;
+  const verifyNum = includeTdd ? 4 : 3;
+  const neverFabNum = includeTdd ? 5 : 4;
+  const gitNum = includeTdd ? 6 : 5;
+  const memNum = includeTdd ? 7 : 6;
+  const skipGatesNum = includeTdd ? 8 : 7;
+  return `---
+
+<constraints>
+CRITICAL RULES - ENFORCE BEFORE EVERY ACTION:
+${tddCheckpointBlock}${antiLoopNum}. ANTI-LOOP GUARD (LumenFlow \xA77.3)
+   - Max 3 attempts per unique error before escalating
+   - If same error repeats 3x, STOP and report with full context
+   - Retry with different approach, not same command
+
+${stopAskNum}. STOP-AND-ASK TRIGGERS (LumenFlow \xA77.2 - narrow scope)
+   - Policy changes, auth/permissions modifications
+   - PII/safety issues, cloud spend, secrets, backups
+   - Same error repeats 3x
+   - For ordinary errors: fix and retry autonomously (up to 3 attempts)
+
+${verifyNum}. VERIFY COMPLETION before reporting success
+   - 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
+
+${neverFabNum}. NEVER FABRICATE COMPLETION
+   - If blockers remain, report INCOMPLETE
+   - If verification fails, summarize failures
+   - Honesty over false completion
+
+${gitNum}. GIT WORKFLOW (CRITICAL - GitHub rules reject merge commits)
+   - GitHub REJECTS merge commits on main
+   - ALWAYS use \`git rebase ${PRIMARY_MAIN_REF}\` before push
+   - Push to main via \`git push origin lane/...:main\` (fast-forward only)
+   - NEVER use \`git merge\` on main branch
+   - Let \`pnpm wu:done\` handle the merge workflow
+
+${memNum}. MEMORY LAYER COORDINATION (INIT-007)
+   - Use \`pnpm mem:checkpoint --wu ${id}\` to save progress before risky operations
+   - Check \`pnpm mem:inbox --wu ${id}\` periodically for parallel signals from other agents
+   - Checkpoint triggers (WU-1943): checkpoint after each acceptance criterion completed, checkpoint before gates, checkpoint every 30 tool calls
+
+${skipGatesNum}. SKIP-GATES AUTONOMY (WU-1142)
+   - If gates fail, first check if failure is pre-existing on main: \`git checkout main && pnpm gates\`
+   - If failure exists on main (not your change), use: \`pnpm wu:done --id ${id} --skip-gates --reason "pre-existing on main" --fix-wu WU-XXXX\`
+   - Do NOT ask for approval - autonomous skip-gates for pre-existing failures is correct
+   - This prevents getting stuck on infrastructure debt
+</constraints>`;
+}
+function generateCodexConstraints(id, options) {
+  const includeTdd = options?.includeTddCheckpoint !== false;
+  const tddLine = includeTdd ? "1. **TDD checkpoint**: tests BEFORE implementation; never skip RED" : "";
+  const stopNum = includeTdd ? 2 : 1;
+  const verifyNum = includeTdd ? 3 : 2;
+  const fabricateNum = includeTdd ? 4 : 3;
+  const gitNum = includeTdd ? 5 : 4;
+  const scopeNum = includeTdd ? 6 : 5;
+  const skipGatesNum = includeTdd ? 7 : 6;
+  return `## Constraints (Critical)
+
+${tddLine}${tddLine ? "\n" : ""}${stopNum}. **Stop on errors**: if UnsafeAny command fails, report BLOCKED (never DONE) with the error
+${verifyNum}. **Verify before success**: run \`pnpm gates\` in the worktree, then run \`node packages/@lumenflow/agent/dist/agent-verification.js ${id}\` (from the shared checkout)
+${fabricateNum}. **No fabrication**: if blockers remain or verification fails, report INCOMPLETE
+${gitNum}. **Git workflow**: avoid merge commits; let \`pnpm wu:done\` handle completion
+${scopeNum}. **Scope discipline**: stay within \`code_paths\`; capture out-of-scope issues via \`pnpm mem:create\`
+${skipGatesNum}. **Skip-gates for pre-existing**: if gates fail due to pre-existing issue on main, use \`--skip-gates --reason "pre-existing" --fix-wu WU-XXX\``;
+}
+function generateMandatoryAgentSection(mandatoryAgents, _id) {
+  if (mandatoryAgents.length === 0) {
+    return "";
+  }
+  const agentList = mandatoryAgents.map((agent) => `  - ${agent}`).join("\n");
+  return `
+## Mandatory Agents (MUST invoke before wu:done)
+
+Based on code_paths, the following agents MUST be invoked:
+
+${agentList}
+
+Run: pnpm orchestrate:monitor to check agent status
+`;
+}
+function generateEffortScalingRules() {
+  return `## Effort Scaling (When to Spawn Sub-Agents)
+
+Use this heuristic to decide complexity:
+
+| Complexity | Approach | Tool Calls |
+|------------|----------|------------|
+| **Simple** (single file, <50 lines) | Handle inline | 3-10 |
+| **Moderate** (2-3 files, clear scope) | Handle inline | 10-20 |
+| **Complex** (4+ files, exploration needed) | Spawn Explore agent first | 20+ |
+| **Multi-domain** (cross-cutting concerns) | Spawn specialized sub-agents | Varies |
+
+**Rule**: If you need >30 tool calls for a subtask, consider spawning a sub-agent with a focused scope.`;
+}
+function generateParallelToolCallGuidance() {
+  return `## Parallel Tool Calls (Performance)
+
+**IMPORTANT**: Make 3+ tool calls in parallel when operations are independent.
+
+Good examples:
+- Reading multiple files simultaneously
+- Running independent grep searches
+- Spawning multiple Explore agents for different areas
+
+Bad examples:
+- Reading a file then editing it (sequential dependency)
+- Running tests then checking results (sequential)
+
+Parallelism reduces latency by 50-90% for complex tasks.`;
+}
+function generateIterativeSearchHeuristics() {
+  return `## Search Strategy (Broad to Narrow)
+
+When exploring the codebase:
+
+1. **Start broad**: Use Explore agent or glob patterns to understand structure
+2. **Evaluate findings**: What patterns exist? What's relevant?
+3. **Narrow focus**: Target specific files/functions based on findings
+4. **Iterate**: Refine if initial approach misses the target
+
+Avoid: Jumping directly to specific file edits without understanding context.`;
+}
+function generateTokenBudgetAwareness(id) {
+  return `## Token Budget Awareness
+
+Context limit is ~200K tokens. Monitor your usage:
+
+- **At 50+ tool calls**: Create a checkpoint (\`pnpm mem:checkpoint --wu ${id}\`)
+- **At 100+ tool calls**: Consider spawning fresh sub-agent with focused scope
+- **Before risky operations**: Always checkpoint first
+
+If approaching limits, summarize progress and spawn continuation agent.`;
+}
+function generateCompletionFormat(_id) {
+  return `## Completion Report Format
+
+When finishing, provide structured output:
+
+\`\`\`
+## Summary
+<1-3 sentences describing what was accomplished>
+
+## Artifacts
+- Files modified: <list>
+- Tests added: <list>
+- Documentation updated: <list>
+
+## Verification
+- Gates: <pass/fail>
+- Tests: <X passing, Y failing>
+
+## Blockers (if UnsafeAny)
+- <blocker description>
+
+## Follow-up (if needed)
+- <suggested next WU or action>
+\`\`\`
+
+This format enables orchestrator to track progress across waves.`;
+}
+function generateQuickFixCommands() {
+  return `## Quick Fix Commands
+
+If gates fail, try these before investigating:
+
+\`\`\`bash
+pnpm format      # Auto-fix formatting issues
+pnpm lint        # Check linting (use --fix for auto-fix)
+pnpm typecheck   # Check TypeScript types
+\`\`\`
+
+**Use before gates** to catch simple issues early. These are faster than full \`pnpm gates\`.`;
+}
+function generateWorktreeBlockRecoverySection(worktreePath, config) {
+  const worktreePathHint = worktreePath || `${resolveWorktreesDirSegment(config)}/<lane>-wu-xxx`;
+  return `## When Blocked by Worktree Hook
+
+If you encounter a "worktree required" or "commit blocked" error:
+
+1. **Check existing worktrees**: \`git worktree list\`
+2. **Navigate to the worktree**: \`cd ${worktreePathHint}\`
+3. **Retry your operation** from within the worktree
+4. **Use relative paths only** (never absolute paths starting with /)
+
+### Common Causes
+
+- Running \`git commit\` from main checkout instead of worktree
+- Using absolute paths that bypass worktree isolation
+- Forgetting to \`cd\` to worktree after \`wu:claim\`
+
+### Quick Fix
+
+\`\`\`bash
+# Check where you are
+pwd
+git worktree list
+
+# Navigate to your worktree
+cd ${worktreePathHint}
+
+# Retry your commit
+git add . && git commit -m "your message"
+\`\`\``;
+}
+function generateLaneSelectionSection(laneInferencePath = CONFIG_FILES.LANE_INFERENCE) {
+  return `## Lane Selection
+
+When creating new WUs, use the correct lane to enable parallelization:
+
+\`\`\`bash
+# Get lane suggestion based on code paths and description
+pnpm wu:infer-lane --id WU-XXX
+
+# Or infer from manual inputs
+pnpm wu:infer-lane --paths "tools/**" --desc "CLI improvements"
+\`\`\`
+
+**Lane taxonomy**: See \`${laneInferencePath}\` for valid lanes and patterns.
+
+**Why lanes matter**: WIP=1 per lane means correct lane selection enables parallel work across lanes.`;
+}
+function generateWorktreePathGuidance(worktreePath) {
+  if (!worktreePath) {
+    return "";
+  }
+  return `## Worktree Path Guidance (WU-2362)
+
+**Your worktree:** \`${worktreePath}\`
+
+### Finding the Worktree Root
+
+Sub-agents may inherit the parent's cwd (main checkout). To find the actual worktree root:
+
+\`\`\`bash
+# Get the worktree root (not main checkout)
+git rev-parse --show-toplevel
+\`\`\`
+
+### Stamp Creation
+
+When creating \`.lumenflow/\` stamps or other artifacts:
+
+1. **ALWAYS** create stamps in the **worktree**, not main
+2. Use \`git rev-parse --show-toplevel\` to get the correct base path
+3. Stamps created on main will be lost when the worktree merges
+
+\`\`\`bash
+# CORRECT: Create stamp in worktree
+WORKTREE_ROOT=$(git rev-parse --show-toplevel)
+mkdir -p "$WORKTREE_ROOT/.lumenflow/agent-runs"
+touch "$WORKTREE_ROOT/.lumenflow/agent-runs/code-reviewer.stamp"
+
+# WRONG: Hardcoded path to main
+# touch /path/to/main/.lumenflow/agent-runs/code-reviewer.stamp
+\`\`\`
+
+### Why This Matters
+
+- Stamps on main get overwritten by worktree merge
+- \`wu:done\` validates stamps exist in the worktree branch
+- Parallel WUs in other lanes won't see your stamps if on main`;
+}
+function generateBugDiscoverySection(id) {
+  return `## Bug Discovery (Mid-WU Issue Capture)
+
+If you discover a bug or issue **outside the scope of this WU**:
+
+1. **Capture it immediately** using:
+   \`\`\`bash
+   pnpm mem:create 'Bug: <description>' --type discovery --tags bug,scope-creep --wu ${id}
+   \`\`\`
+
+2. **Continue with your WU** \u2014 do not fix bugs outside your scope
+3. **Reference in notes** \u2014 mention the mem node ID in your completion notes
+
+### NEVER use wu:create for discovered issues
+
+**Do NOT use \`wu:create\` directly for bugs discovered mid-WU.**
+
+- \`mem:create\` = **capture** (immediate, no human approval needed)
+- \`wu:create\` = **planned work** (requires human triage and approval)
+
+Discovered issues MUST go through human triage before becoming WUs.
+Using \`wu:create\` directly bypasses the triage workflow and creates
+unreviewed work items.
+
+### When to Capture
+
+- Found a bug in code NOT in your \`code_paths\`
+- Discovered an issue that would require >10 lines to fix
+- Encountered broken behaviour unrelated to your acceptance criteria
+
+### Triage Workflow
+
+After WU completion, bugs can be promoted to Bug WUs by humans:
+\`\`\`bash
+pnpm mem:triage --wu ${id}           # List discoveries for this WU
+pnpm mem:triage --promote <node-id> --lane "<lane>"  # Create Bug WU (human action)
+\`\`\`
+
+See: https://lumenflow.dev/reference/agent-invocation-guide/ \xA7Bug Discovery`;
+}
+function generateLaneGuidance(lane) {
+  if (!lane) return "";
+  const laneParent = lane.split(":")[0].trim();
+  const guidance = {
+    Operations: `## Lane-Specific: Tooling
+
+- Update tool documentation in tools/README.md or relevant docs if adding new CLI commands`,
+    Intelligence: `## Lane-Specific: Intelligence
+
+- For prompt/classification work, run the project-specific evaluation command defined by your local templates/config
+- Follow prompt versioning guidelines documented for this project`,
+    Experience: `## Lane-Specific: Experience
+
+- Follow design system tokens defined in the project
+- Ensure accessibility compliance (WCAG 2.1 AA)`,
+    Core: `## Lane-Specific: Core
+
+- Maintain hexagonal architecture boundaries
+- Update domain model documentation if changing entities`
+  };
+  return guidance[laneParent] || "";
+}
+function generateActionSection(doc, id, config) {
+  const isAlreadyClaimed = doc.claimed_at && doc.worktree_path;
+  if (isAlreadyClaimed) {
+    return `This WU is already claimed. Continue implementation in worktree following all standards above.
+
+cd ${doc.worktree_path}`;
+  }
+  const claimWorktreePathHint = resolveClaimWorktreePathHint(doc.lane, id, config);
+  return `**FIRST: Claim this WU before starting work:**
+
+\`\`\`bash
+pnpm wu:claim --id ${id} --lane "${doc.lane}"
+cd ${claimWorktreePathHint}
+\`\`\`
+
+Then implement following all standards above.
+
+**CRITICAL:** Never use \`git worktree add\` directly. Always use \`pnpm wu:claim\` to ensure:
+- Event tracking in ${LUMENFLOW_PATHS.WU_EVENTS}
+- Lane lock acquisition (WIP=1 enforcement)
+- Session tracking for context recovery`;
+}
+function generateCompletionWorkflowSection2(id) {
+  return generateCompletionWorkflowSection(id);
+}
+function generateClientBlocksSection(clientContext) {
+  if (!clientContext?.config?.blocks?.length) return "";
+  const blocks = clientContext.config.blocks.map((block) => `### ${block.title}
+
+${block.content}`).join("\n\n");
+  return `## Client Guidance (${clientContext.name})
+
+${blocks}`;
+}
+function tryLoadTemplates(clientName, context, baseDir = DEFAULT_TEMPLATE_BASE_DIR) {
+  const result = /* @__PURE__ */ new Map();
+  try {
+    const templates = loadTemplatesWithOverrides(baseDir, clientName);
+    for (const [id, template] of templates) {
+      const condition = template.frontmatter.condition;
+      if (!evaluateCondition(condition, context)) {
+        continue;
+      }
+      const processed = replaceTokens(template.content, context);
+      result.set(id, processed);
+    }
+  } catch {
+  }
+  return result;
+}
+function buildSpawnTemplateContext(doc, id, policy, classification) {
+  const lane = doc.lane || "";
+  const laneParent = lane.split(":")[0]?.trim() || "";
+  const type = (doc.type || "feature").toLowerCase();
+  const requiredVerification = formatRequiredVerification(doc);
+  const workDomain = classification?.domain || "";
+  const workTestMethodologyHint = classification?.testMethodologyHint || "";
+  const context = {
+    WU_ID: id,
+    LANE: lane,
+    TYPE: type,
+    TITLE: doc.title || "",
+    DESCRIPTION: doc.description || "",
+    WORKTREE_PATH: doc.worktree_path || "",
+    laneParent,
+    WORK_DOMAIN: workDomain,
+    WORK_TEST_METHODOLOGY_HINT: workTestMethodologyHint,
+    REQUIRED_VERIFICATION: requiredVerification,
+    // Lowercase aliases for condition evaluation
+    type,
+    lane,
+    worktreePath: doc.worktree_path || "",
+    "work.domain": workDomain,
+    "work.testMethodologyHint": workTestMethodologyHint,
+    hasRequiredVerification: requiredVerification ? "true" : void 0,
+    "tests.hasUnit": doc.tests?.unit?.length ? "true" : void 0,
+    "tests.hasE2E": doc.tests?.e2e?.length ? "true" : void 0,
+    "tests.hasManual": doc.tests?.manual?.length ? "true" : void 0
+  };
+  if (policy) {
+    context["policy.testing"] = policy.testing;
+    context["policy.architecture"] = policy.architecture;
+  }
+  return context;
+}
+function generateTaskInvocation(doc, id, strategy, options = {}) {
+  const codePaths = doc.code_paths || [];
+  const mandatoryAgents = detectMandatoryAgents(codePaths);
+  const preamble = generatePreamble(id, strategy);
+  const clientContext = options.client;
+  const config = options.config || getConfig();
+  const policy = resolvePolicy(config);
+  const classificationConfig = config?.methodology?.work_classification;
+  const classification = classifyWork(
+    {
+      code_paths: doc.code_paths,
+      lane: doc.lane,
+      type: doc.type,
+      description: doc.description
+    },
+    classificationConfig
+  );
+  const clientName = options.client?.name || "claude-code";
+  const templateContext = buildSpawnTemplateContext(doc, id, policy, classification);
+  const templateBaseDir = options.baseDir || DEFAULT_TEMPLATE_BASE_DIR;
+  const templates = tryLoadTemplates(clientName, templateContext, templateBaseDir);
+  const testGuidanceFallback = [
+    generateRequiredVerificationSection(doc),
+    generatePolicyBasedTestGuidance(doc.type || "feature", policy, {
+      testMethodologyHint: classification.testMethodologyHint
+    })
+  ].filter((section) => section.length > 0).join("\n\n---\n\n");
+  const testGuidance = resolveVerificationGuidanceSection(templates, testGuidanceFallback);
+  const enforcementSummary = generateEnforcementSummary(policy, {
+    testMethodologyHint: classification.testMethodologyHint
+  });
+  const mandatoryStandards = generateMandatoryStandards(policy, {
+    testMethodologyHint: classification.testMethodologyHint
+  });
+  const codeCraftGuidance = templates.get("code-craft") || generateCodeCraftGuidance();
+  const readBeforeWrite = templates.get("read-before-write") || generateReadBeforeWriteDiscipline();
+  const selfReviewDirective = templates.get("self-review") || generateSelfReviewDirective(id);
+  const clientSkillsGuidance = generateClientSkillsGuidance(clientContext, doc.lane);
+  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 bugDiscoverySection = templates.get("bug-discovery") || generateBugDiscoverySection(id);
+  const shouldIncludeTddCheckpoint = !usesNonTddHint(classification.testMethodologyHint) && policy.testing !== "none";
+  const constraints = templates.get("constraints") || generateConstraints(id, {
+    includeTddCheckpoint: shouldIncludeTddCheckpoint
+  });
+  const implementationContext = generateImplementationContext(doc);
+  const designContextSection = resolveDesignContextSection(templates, classification);
+  const invariantsPriorArt = generateInvariantsPriorArtSection(codePaths);
+  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);
+  const completionWorkflow = templates.get("completion-workflow") || generateCompletionWorkflowSection2(id);
+  const agentCoordination = generateAgentCoordinationSection(id);
+  const quickFix = templates.get("quick-fix-commands") || generateQuickFixCommands();
+  const laneSelection = templates.get("lane-selection") || generateLaneSelectionSection(CONFIG_FILES.LANE_INFERENCE);
+  const worktreePathHint = resolveWorktreePathHint(doc, id, config);
+  const worktreeGuidance = generateWorktreePathGuidance(doc.worktree_path);
+  const worktreeBlockRecovery = templates.get("worktree-recovery") || generateWorktreeBlockRecoverySection(worktreePathHint, config);
+  const laneGuidance = resolveLaneGuidanceSection(templates, doc.lane);
+  const shouldIncludeMemoryContext = options.includeMemoryContext && !options.noContext;
+  const memoryContextSection = shouldIncludeMemoryContext ? options.memoryContextContent || "" : "";
+  const executionModeSection = generateExecutionModeSection(options);
+  const thinkToolGuidance = generateThinkToolGuidance(options);
+  const thinkingSections = [executionModeSection, thinkToolGuidance].filter((section) => section.length > 0).join("\n\n---\n\n");
+  const thinkingBlock = thinkingSections ? `${thinkingSections}
+
+---
+
+` : "";
+  const taskPrompt = `${TRUNCATION_WARNING_BANNER}<task>
+${preamble}
+</task>
+
+---
+
+${testGuidance}
+
+---
+
+# ${id}: ${doc.title || "Untitled"}
+
+## WU Details
+
+- **ID:** ${id}
+- **Lane:** ${doc.lane || "Unknown"}
+- **Type:** ${doc.type || "feature"}
+- **Status:** ${doc.status || "unknown"}
+- **Worktree:** ${worktreePathHint}
+
+## Description
+
+${doc.description || "No description provided."}
+
+## Acceptance Criteria
+
+${formatAcceptance(doc.acceptance)}
+
+## Code Paths
+
+${codePaths.length > 0 ? codePaths.map((p) => `- ${p}`).join("\n") : "- No code paths defined"}
+${mandatorySection}${invariantsPriorArt ? `---
+
+${invariantsPriorArt}
+
+` : ""}${implementationContext ? `---
+
+${implementationContext}
+
+` : ""}---
+
+${thinkingBlock}${skillsSection}
+${memoryContextSection ? `---
+
+${memoryContextSection}
+
+` : ""}---
+
+${mandatoryStandards}
+
+---
+
+${enforcementSummary}
+
+---
+
+${codeCraftGuidance}
+
+---
+
+${readBeforeWrite}
+
+${designContextSection ? `---
+
+${designContextSection}
+
+` : ""}${clientBlocks ? `---
+
+${clientBlocks}
+
+` : ""}${worktreeGuidance ? `---
+
+${worktreeGuidance}
+
+` : ""}---
+
+${bugDiscoverySection}
+
+---
+
+${effortScaling}
+
+---
+
+${parallelToolCalls}
+
+---
+
+${searchHeuristics}
+
+---
+
+${tokenBudget}
+
+---
+
+${completionFormat}
+
+---
+
+${completionWorkflow}
+
+---
+
+${agentCoordination}
+
+---
+
+${quickFix}
+
+---
+
+${laneSelection}
+
+---
+
+${laneGuidance}${laneGuidance ? "\n\n---\n\n" : ""}## Action
+
+${generateActionSection(doc, id, config)}
+
+---
+
+${selfReviewDirective}
+
+---
+
+${worktreeBlockRecovery}
+
+${constraints}
+
+${SPAWN_END_SENTINEL}`;
+  const escapedPrompt = taskPrompt.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const openTag = '<antml:invoke name="Task">';
+  const closeTag = "</antml:invoke>";
+  const paramOpen = '<antml:parameter name="';
+  const paramClose = "</antml:parameter>";
+  const invocation = [
+    "<antml:function_calls>",
+    openTag,
+    `${paramOpen}subagent_type">general-purpose${paramClose}`,
+    `${paramOpen}description">Execute ${id}${paramClose}`,
+    `${paramOpen}prompt">${escapedPrompt}${paramClose}`,
+    closeTag,
+    "</antml:function_calls>"
+  ].join("\n");
+  return invocation;
+}
+function generateCodexPrompt(doc, id, strategy, options = {}) {
+  const codePaths = doc.code_paths || [];
+  const mandatoryAgents = detectMandatoryAgents(codePaths);
+  const config = options.config || getConfig();
+  const clientContext = options.client;
+  const policy = resolvePolicy(config);
+  const classificationConfig = config?.methodology?.work_classification;
+  const classification = classifyWork(
+    {
+      code_paths: doc.code_paths,
+      lane: doc.lane,
+      type: doc.type,
+      description: doc.description
+    },
+    classificationConfig
+  );
+  const preamble = generatePreamble(id, strategy);
+  const mandatoryStandards = generateMandatoryStandards(policy, {
+    testMethodologyHint: classification.testMethodologyHint
+  });
+  const enforcementSummary = generateEnforcementSummary(policy, {
+    testMethodologyHint: classification.testMethodologyHint
+  });
+  const mandatorySection = generateMandatoryAgentSection(mandatoryAgents, id);
+  const implementationContext = generateImplementationContext(doc);
+  const action = generateActionSection(doc, id, config);
+  const shouldIncludeTddCheckpoint = !usesNonTddHint(classification.testMethodologyHint) && policy.testing !== "none";
+  const constraints = generateCodexConstraints(id, {
+    includeTddCheckpoint: shouldIncludeTddCheckpoint
+  });
+  const worktreePathHint = resolveWorktreePathHint(doc, id, config);
+  const clientName = options.client?.name || "claude-code";
+  const templateContext = buildSpawnTemplateContext(doc, id, policy, classification);
+  const templateBaseDir = options.baseDir || DEFAULT_TEMPLATE_BASE_DIR;
+  const templates = tryLoadTemplates(clientName, templateContext, templateBaseDir);
+  const testGuidanceFallback = [
+    generateRequiredVerificationSection(doc),
+    generatePolicyBasedTestGuidance(doc.type || "feature", policy, {
+      testMethodologyHint: classification.testMethodologyHint
+    })
+  ].filter((section) => section.length > 0).join("\n\n---\n\n");
+  const testGuidance = resolveVerificationGuidanceSection(templates, testGuidanceFallback);
+  const codeCraftGuidance = templates.get("code-craft") || generateCodeCraftGuidance();
+  const readBeforeWrite = templates.get("read-before-write") || generateReadBeforeWriteDiscipline();
+  const selfReviewDirective = templates.get("self-review") || generateSelfReviewDirective(id);
+  const bugDiscoverySection = templates.get("bug-discovery") || generateBugDiscoverySection(id);
+  const completionWorkflow = templates.get("completion-workflow") || generateCompletionWorkflowSection2(id);
+  const clientSkillsGuidance = generateClientSkillsGuidance(clientContext, doc.lane);
+  const skillsTemplateContent = templates.get("skills-selection");
+  const skillsBaseContent = skillsTemplateContent || generateSkillsSelectionSection(doc, config, clientContext?.name);
+  const skillsSection = skillsBaseContent + (clientSkillsGuidance ? `
+${clientSkillsGuidance}` : "");
+  const clientBlocks = generateClientBlocksSection(clientContext);
+  const laneGuidance = resolveLaneGuidanceSection(templates, doc.lane);
+  const designContextSection = resolveDesignContextSection(templates, classification);
+  const executionModeSection = generateExecutionModeSection(options);
+  const thinkToolGuidance = generateThinkToolGuidance(options);
+  const thinkingSections = [executionModeSection, thinkToolGuidance].filter((section) => section.length > 0).join("\n\n---\n\n");
+  const thinkingBlock = thinkingSections ? `${thinkingSections}
+
+---
+
+` : "";
+  const worktreeBlockRecovery = generateWorktreeBlockRecoverySection(worktreePathHint, config);
+  const shouldIncludeMemoryContext = options.includeMemoryContext && !options.noContext;
+  const memoryContextSection = shouldIncludeMemoryContext ? options.memoryContextContent || "" : "";
+  return `${TRUNCATION_WARNING_BANNER}# ${id}: ${doc.title || "Untitled"}
+
+${testGuidance}
+
+---
+
+## Context
+
+${preamble}
+
+---
+
+## WU Details
+
+- **ID:** ${id}
+- **Lane:** ${doc.lane || "Unknown"}
+- **Type:** ${doc.type || "feature"}
+- **Status:** ${doc.status || "unknown"}
+- **Worktree:** ${worktreePathHint}
+
+## Description
+
+${doc.description || "No description provided."}
+
+## Scope (code_paths)
+
+Only change files within these paths:
+
+${codePaths.length > 0 ? codePaths.map((p) => `- ${p}`).join("\n") : "- No code paths defined"}
+
+## Acceptance Criteria
+
+${formatAcceptance(doc.acceptance)}
+
+---
+
+${mandatoryStandards}
+
+---
+
+${enforcementSummary}
+
+---
+
+${codeCraftGuidance}
+
+---
+
+${readBeforeWrite}
+
+${designContextSection ? `---
+
+${designContextSection}
+
+` : ""}${skillsSection}
+${memoryContextSection ? `---
+
+${memoryContextSection}
+
+` : ""}---
+
+## Action
+
+${action}
+
+---
+
+${completionWorkflow}
+
+---
+
+## Verification
+
+- Run in worktree: \`pnpm gates\`
+- From shared checkout: \`node packages/@lumenflow/agent/dist/agent-verification.js ${id}\`
+
+---
+
+${mandatorySection}${implementationContext ? `${implementationContext}
+
+---
+
+` : ""}${clientBlocks ? `${clientBlocks}
+
+---
+
+` : ""}${thinkingBlock}${bugDiscoverySection}
+
+---
+
+${laneGuidance}${laneGuidance ? "\n\n---\n\n" : ""}${selfReviewDirective}
+
+---
+
+${worktreeBlockRecovery}
+
+---
+
+${constraints}
+
+${SPAWN_END_SENTINEL}
+`;
+}
+
+// src/wu-brief-sizing.ts
+function checkBriefSizing(input) {
+  const { wuId, logPrefix, strictSizing, sizingEstimate } = input;
+  const warnings = [];
+  const errors = [];
+  if (!sizingEstimate) {
+    if (strictSizing) {
+      errors.push(
+        `${wuId}: --strict-sizing requires sizing_estimate metadata in WU YAML. Add sizing_estimate with estimated_files, estimated_tool_calls, and strategy.`
+      );
+      return { pass: false, warnings, errors };
+    }
+    return { pass: true, warnings, errors };
+  }
+  const advisory = checkSizingAdvisory(sizingEstimate);
+  if (advisory.oversize) {
+    if (strictSizing) {
+      errors.push(...advisory.warnings.map((w) => `${wuId}: ${w}`));
+      return { pass: false, warnings, errors };
+    }
+    for (const w of advisory.warnings) {
+      const message = `${logPrefix} WARNING (${wuId}): ${w}`;
+      warnings.push(message);
+      console.warn(message);
+    }
+    return { pass: true, warnings, errors };
+  }
+  return { pass: true, warnings, errors };
+}
+
+// src/wu-spawn-strategy-resolver.ts
+import crypto from "crypto";
+var BRIEF_LOG_PREFIX = "[wu:brief]";
+var DELEGATE_LOG_PREFIX = "[wu:delegate]";
+var BRIEF_EVIDENCE_PROGRESS = "wu:brief executed";
+function buildBriefAttestation(output, clientName, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    algorithm: "sha256",
+    promptHash: crypto.createHash("sha256").update(output, "utf8").digest("hex"),
+    promptLength: output.length,
+    generatedAt,
+    clientName
+  };
+}
+function checkLaneOccupation(lane) {
+  const lockPolicy = getLockPolicyForLane(lane);
+  if (lockPolicy === "none") {
+    return null;
+  }
+  const lockStatus = checkLaneLock(lane);
+  if (lockStatus.locked && lockStatus.metadata) {
+    return lockStatus.metadata;
+  }
+  return null;
+}
+function generateLaneOccupationWarning(lockMetadata, targetWuId, options = {}) {
+  const { isStale = false } = options;
+  let warning = `\u26A0\uFE0F  Lane "${lockMetadata.lane}" is occupied by ${lockMetadata.wuId}
+`;
+  const lockPolicy = options.lockPolicy ?? getLockPolicyForLane(lockMetadata.lane);
+  const wipLimit = options.wipLimit ?? getWipLimitForLane(lockMetadata.lane);
+  warning += `   This violates WIP=${wipLimit} (lock_policy=${lockPolicy}).
+
+`;
+  if (isStale) {
+    warning += `   \u23F0 This lock is STALE (>24 hours old) - the WU may be abandoned.
+`;
+    warning += `   Consider using pnpm wu:block --id ${lockMetadata.wuId} if work is stalled.
+
+`;
+  }
+  warning += `   Options:
+`;
+  warning += `   1. Wait for ${lockMetadata.wuId} to complete or block
+`;
+  warning += `   2. Choose a different lane for ${targetWuId}
+`;
+  warning += `   3. Block ${lockMetadata.wuId} if work is stalled: pnpm wu:block --id ${lockMetadata.wuId}`;
+  return warning;
+}
+var BRIEF_PARSER_CONFIG = {
+  name: "wu-brief",
+  description: "Generate handoff prompt for sub-agent WU execution"
+};
+var DELEGATE_PARSER_CONFIG = {
+  name: "wu-delegate",
+  description: "Generate delegation prompt and record explicit lineage intent"
+};
+function parseAndValidateArgs(parserConfig = BRIEF_PARSER_CONFIG) {
+  const args = createWUParser({
+    name: parserConfig.name,
+    description: parserConfig.description,
+    options: [
+      WU_OPTIONS.id,
+      WU_OPTIONS.thinking,
+      WU_OPTIONS.noThinking,
+      WU_OPTIONS.budget,
+      WU_OPTIONS.codex,
+      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
+      WU_OPTIONS.evidenceOnly,
+      // WU-2222: Evidence recording without prompt generation
+      WU_OPTIONS.strictSizing
+      // WU-2141: Strict sizing enforcement
+    ],
+    required: ["id"],
+    allowPositionalId: true
+  });
+  try {
+    validateSpawnArgs(args);
+  } catch (e) {
+    die(e.message);
+  }
+  return args;
+}
+function loadWUDocument(id, wuPath) {
+  if (!existsSync3(wuPath)) {
+    die(
+      `WU file not found: ${wuPath}
+
+Cannot spawn a sub-agent for a WU that doesn't exist.
+
+Options:
+  1. Create the WU first: pnpm wu:create --id ${id} --lane <lane> --title "..."
+  2. Check if the WU ID is correct`
+    );
+  }
+  let text;
+  try {
+    text = readFileSync(wuPath, { encoding: FILE_SYSTEM.UTF8 });
+  } catch (e) {
+    die(
+      `Failed to read WU file: ${wuPath}
+
+Error: ${e.message}
+
+Options:
+  1. Check file permissions: ls -la ${wuPath}
+  2. Ensure the file exists and is readable`
+    );
+  }
+  try {
+    return parseYAML(text);
+  } catch (e) {
+    die(
+      `Failed to parse WU YAML ${wuPath}
+
+Error: ${e.message}
+
+Options:
+  1. Validate YAML syntax: pnpm wu:validate --id ${id}
+  2. Fix YAML errors manually and retry`
+    );
+  }
+}
+function resolveClientName(args, config, logPrefix = BRIEF_LOG_PREFIX) {
+  let clientName = args.client;
+  if (!clientName && args.vendor) {
+    console.warn(`${logPrefix} ${EMOJI.WARNING} Warning: --vendor is deprecated. Use --client.`);
+    clientName = args.vendor;
+  }
+  if (args.codex && !clientName) {
+    console.warn(
+      `${logPrefix} ${EMOJI.WARNING} Warning: --codex is deprecated. Use --client codex-cli.`
+    );
+    clientName = "codex-cli";
+  }
+  const resolved = clientName || config.agents.defaultClient || "claude-code";
+  if (!clientName && !config.agents.defaultClient) {
+    console.warn(
+      `${logPrefix} Warning: No --client specified. Falling back to 'claude-code'. Available clients: claude-code, codex-cli, cursor, gemini-cli, windsurf`
+    );
+  }
+  return resolved;
+}
+async function checkAndWarnLaneOccupation(lane, id, logPrefix = BRIEF_LOG_PREFIX) {
+  if (!lane) return;
+  const existingLock = checkLaneOccupation(lane);
+  if (existingLock && existingLock.wuId !== id) {
+    const { isLockStale } = await import("./lane-lock-6J36HD5O.js");
+    const isStale = isLockStale(existingLock);
+    const warning = generateLaneOccupationWarning(existingLock, id, { isStale });
+    console.warn(`${logPrefix} ${EMOJI.WARNING}
+${warning}
+`);
+  }
+}
+async function recordWuBriefEvidence(options, dependencies = {}) {
+  const { wuId, workspaceRoot, clientName, promptHash, forceRecord, claimedMode, claimedBranch } = options;
+  const checkWorktree = dependencies.isInWorktree ?? isInWorktree;
+  const isInWorktree2 = checkWorktree({ cwd: workspaceRoot });
+  let shouldRecordEvidence = forceRecord === true || isInWorktree2;
+  if (!shouldRecordEvidence) {
+    const normalizedClaimedMode = typeof claimedMode === "string" ? claimedMode.trim() : "";
+    const isBranchClaim = normalizedClaimedMode === "branch-pr" || normalizedClaimedMode === "branch-only";
+    if (isBranchClaim) {
+      const getCurrentBranch = dependencies.getCurrentBranch ?? (async (cwd) => {
+        return createGitForPath(cwd).getCurrentBranch();
+      });
+      const activeBranch = await getCurrentBranch(workspaceRoot).then((branch) => branch.trim()).catch(() => "");
+      const normalizedClaimedBranch = typeof claimedBranch === "string" ? claimedBranch.trim() : "";
+      if (normalizedClaimedBranch.length > 0) {
+        shouldRecordEvidence = activeBranch === normalizedClaimedBranch;
+      } else {
+        shouldRecordEvidence = activeBranch.length > 0 && activeBranch !== BRANCHES.MAIN && activeBranch !== BRANCHES.MASTER;
+      }
+    }
+  }
+  if (!shouldRecordEvidence) {
+    return;
+  }
+  const stateDir = resolveStateDir(workspaceRoot);
+  const createStore = dependencies.createStore ?? ((dir) => new WUStateStore(dir));
+  const store = createStore(stateDir);
+  const note = `${WU_BRIEF_EVIDENCE_NOTE_PREFIX} generated via ${clientName}`;
+  const nextSteps = promptHash ? `client=${clientName};hash=${promptHash}` : `client=${clientName}`;
+  await store.checkpoint(wuId, note, {
+    progress: BRIEF_EVIDENCE_PROGRESS,
+    nextSteps
+  });
+}
+async function emitSpawnOutputWithRegistry(options, dependencies = {}) {
+  const {
+    id,
+    output,
+    isCodexClient,
+    parentWu,
+    lane,
+    briefAttestation,
+    recordDelegationIntent = false,
+    logPrefix: prefix = BRIEF_LOG_PREFIX
+  } = options;
+  const log = dependencies.log ?? console.log;
+  const recordSpawn = dependencies.recordSpawn ?? recordSpawnToRegistry;
+  const formatSpawnMessage = dependencies.formatSpawnMessage ?? formatSpawnRecordedMessage;
+  if (isCodexClient) {
+    log(`${prefix} Generated Codex/GPT prompt for ${id}`);
+    log(`${prefix} Copy the Markdown below:
+`);
+    log(output.trimEnd());
+  } else {
+    log(`${prefix} Generated Task tool invocation for ${id}`);
+    log(`${prefix} Copy the block below to spawn a sub-agent:
+`);
+    log(output);
+  }
+  if (!recordDelegationIntent || !parentWu) {
+    return;
+  }
+  const config = getConfig({ projectRoot: process.cwd() });
+  const registryResult = await recordSpawn({
+    parentWuId: parentWu,
+    targetWuId: id,
+    lane: lane || "Unknown",
+    baseDir: config.state.stateDir,
+    briefAttestation
+  });
+  const registryMessage = formatSpawnMessage(registryResult.spawnId, registryResult.error);
+  log(`
+${registryMessage}`);
+}
+async function runBriefLogic(options = {}) {
+  const {
+    mode = "brief",
+    parserConfig = mode === "delegate" ? DELEGATE_PARSER_CONFIG : BRIEF_PARSER_CONFIG,
+    logPrefix = BRIEF_LOG_PREFIX
+  } = options;
+  const args = parseAndValidateArgs(parserConfig);
+  const explicitDelegation = mode === "delegate";
+  const effectiveLogPrefix = explicitDelegation ? DELEGATE_LOG_PREFIX : logPrefix;
+  const commandLabel = explicitDelegation ? "wu:delegate" : "wu:brief";
+  const depResult = await validateSpawnDependencies();
+  if (!depResult.valid) {
+    die(formatDependencyError(commandLabel, depResult.missing));
+  }
+  if (explicitDelegation && !args.parentWu) {
+    die(
+      "wu:delegate requires --parent-wu to record delegation lineage intent.\n\nExample:\n  pnpm wu:delegate --id WU-123 --parent-wu WU-100 --client <client>"
+    );
+  }
+  if (explicitDelegation && args.evidenceOnly) {
+    die(
+      "wu:delegate does not support --evidence-only.\n\nUse:\n  - pnpm wu:delegate --id WU-123 --parent-wu WU-100 --client <client>  # delegation prompt + lineage\n  - pnpm wu:brief --id WU-123 --evidence-only                           # self-implementation evidence only"
+    );
+  }
+  if (!explicitDelegation && args.parentWu) {
+    console.warn(
+      `${effectiveLogPrefix} ${EMOJI.WARNING} --parent-wu does not record lineage in generation-only mode.`
+    );
+    console.warn(
+      `${effectiveLogPrefix} ${EMOJI.WARNING} Use wu:delegate for explicit, side-effectful delegation intent tracking.`
+    );
+    console.warn("");
+  }
+  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);
+  const validStatuses = [WU_STATUS.READY, WU_STATUS.IN_PROGRESS];
+  const status = doc.status || "unknown";
+  if (!validStatuses.includes(status)) {
+    console.warn(`${effectiveLogPrefix} ${EMOJI.WARNING} Warning: ${id} has status '${status}'.`);
+    console.warn(
+      `${effectiveLogPrefix} ${EMOJI.WARNING} Sub-agents typically work on ready or in_progress WUs.`
+    );
+    console.warn("");
+  }
+  await checkAndWarnLaneOccupation(doc.lane, id, effectiveLogPrefix);
+  const sizingEstimate = doc.sizing_estimate;
+  const sizingResult = checkBriefSizing({
+    wuId: id,
+    logPrefix: effectiveLogPrefix,
+    strictSizing: Boolean(args.strictSizing),
+    sizingEstimate
+  });
+  if (!sizingResult.pass) {
+    const errorList = sizingResult.errors.map((e) => `  - ${e}`).join("\n");
+    die(
+      `${effectiveLogPrefix} Sizing check failed (--strict-sizing):
+
+${errorList}
+
+Options:
+  1. Add sizing_estimate metadata to WU YAML
+  2. Add exception_type and exception_reason if thresholds are intentionally exceeded
+  3. Remove --strict-sizing to use advisory mode`
+    );
+  }
+  const thinkingOptions = {
+    thinking: args.thinking,
+    noThinking: args.noThinking,
+    budget: args.budget
+  };
+  const config = getConfig();
+  const clientName = resolveClientName(args, config, effectiveLogPrefix);
+  const baseDir = process.cwd();
+  const recordEvidenceOrFail = async (options2 = {}) => {
+    try {
+      await recordWuBriefEvidence({
+        wuId: id,
+        workspaceRoot: baseDir,
+        clientName,
+        promptHash: options2.promptHash,
+        forceRecord: options2.forceRecord,
+        claimedMode: typeof doc.claimed_mode === "string" ? doc.claimed_mode : void 0,
+        claimedBranch: typeof doc.claimed_branch === "string" ? doc.claimed_branch : void 0
+      });
+    } catch (error) {
+      die(
+        `${effectiveLogPrefix} Failed to record wu:brief evidence for ${id}: ${error.message}
+
+Fix options:
+  1. Ensure state directory is writable
+  2. Retry: pnpm wu:brief --id ${id}`
+      );
+    }
+  };
+  if (args.evidenceOnly) {
+    await recordEvidenceOrFail();
+    console.log(
+      `${effectiveLogPrefix} Recorded wu:brief evidence for ${id} (evidence-only mode; no handoff prompt generated).`
+    );
+    console.log(`${effectiveLogPrefix} Continue implementing ${id} in the current session.`);
+    return;
+  }
+  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(
+          `${effectiveLogPrefix} Memory context loaded (${memoryContextContent.length} bytes)`
+        );
+      }
+    }
+  }
+  const strategy = SpawnStrategyFactory.create(clientName);
+  const clientContext = { name: clientName, config: resolveClientConfig(config, clientName) };
+  const isCodexClient = clientName === "codex-cli" || args.codex;
+  if (isCodexClient) {
+    const prompt = generateCodexPrompt(doc, id, strategy, {
+      ...thinkingOptions,
+      client: clientContext,
+      config
+    });
+    const briefAttestation2 = explicitDelegation ? buildBriefAttestation(prompt, clientName) : void 0;
+    await emitSpawnOutputWithRegistry({
+      id,
+      output: prompt,
+      isCodexClient: true,
+      parentWu: args.parentWu,
+      lane: doc.lane,
+      briefAttestation: briefAttestation2,
+      recordDelegationIntent: explicitDelegation,
+      logPrefix: effectiveLogPrefix
+    });
+    await recordEvidenceOrFail({
+      promptHash: briefAttestation2?.promptHash,
+      forceRecord: explicitDelegation
+    });
+    return;
+  }
+  const invocation = generateTaskInvocation(doc, id, strategy, {
+    ...thinkingOptions,
+    client: clientContext,
+    config,
+    // WU-1240: Include memory context in spawn prompt
+    baseDir,
+    includeMemoryContext: shouldIncludeMemoryContext && memoryContextContent.length > 0,
+    memoryContextContent,
+    noContext: args.noContext
+  });
+  const briefAttestation = explicitDelegation ? buildBriefAttestation(invocation, clientName) : void 0;
+  await emitSpawnOutputWithRegistry({
+    id,
+    output: invocation,
+    isCodexClient: false,
+    parentWu: args.parentWu,
+    lane: doc.lane,
+    briefAttestation,
+    recordDelegationIntent: explicitDelegation,
+    logPrefix: effectiveLogPrefix
+  });
+  await recordEvidenceOrFail({
+    promptHash: briefAttestation?.promptHash,
+    forceRecord: explicitDelegation
+  });
+}
+
+export {
+  recordWuBriefEvidence,
+  runBriefLogic
+};