@adia-ai/gen-ui 0.8.37

package/compose/strategies/monolithic/generate-pro.js

@@ -0,0 +1,490 @@
+/**
+ * @adia-ai/gen-ui — monolithic engine, pro mode.
+ *
+ * Extracted from core/generator.js per spec §11 Phase 2. Shares state
+ * (ArtifactStore, PipelineEngine) via core/state.js. Pure helpers live
+ * in strategies/monolithic/_shared.js.
+ */
+
+import { validateAndRepair, buildFailures } from '../../shared/validate-and-repair.js';
+import { getContext, searchBlocks, lookupDomain } from '../../core/reference.js';
+import { decomposeIntent } from '../../../retrieval/intent/decomposer.js';
+import { assessClarity } from '../../../retrieval/intent/clarity.js';
+import { isConversational } from '../../../retrieval/intent/intent-gate.js';
+import { feedbackStore } from '../../../retrieval/feedback/feedback-store.js';
+import { store, engine } from '../../core/state.js';
+import { isRecording } from '../../../retrieval/feedback/dialog-recorder.js';
+import { searchChunks, expandChunkGraph } from '../_shared/chunk-loader.js';
+import {
+  buildSystemPrompt,
+  buildChatMessages,
+  mergeCanvasDiff,
+  buildCanvasDiffPrompt,
+  parseA2UIResponse,
+  buildRepairPrompt,
+  generateSuggestions, foldInAntiPatterns } from './_shared.js';
+
+export async function generatePro({ intent, executionId, storeId, llmAdapter, analysis, priorComponentsFromPayload, context }) {
+  const execId = executionId;
+
+  // The steelman is the enriched brief produced by the prompt-analyzer in
+  // the baseline ingestion stage. Use it for pattern search (denser query =
+  // better hits) and inject the analysis signals into the system prompt so
+  // the LLM sees the implied component set + concept tags. Falls back to raw
+  // intent when analyzer didn't run (iteration turns) or fell back.
+  const searchQuery = analysis?.steelman || intent;
+
+  // Header prepended to every user message sent to the LLM. Surfaces the
+  // analyzer's structured signals so the LLM treats steelman + components +
+  // concepts as ground truth instead of having to re-derive them from a 3-word
+  // prompt. Empty string when no analyzer signal — no behavior change.
+  const analysisHint = (analysis?.analyzed && (
+    analysis.steelman !== analysis.raw ||
+    analysis.impliedComponents?.length ||
+    analysis.concepts?.length
+  ))
+    ? [
+        analysis.steelman && analysis.steelman !== analysis.raw ? `BRIEF: ${analysis.steelman}` : null,
+        analysis.impliedComponents?.length ? `EXPECTED COMPONENTS: ${analysis.impliedComponents.join(', ')}` : null,
+        analysis.concepts?.length ? `CONCEPTS: ${analysis.concepts.join(', ')}` : null,
+        analysis.styleHints?.length ? `STYLE: ${analysis.styleHints.join(', ')}` : null,
+      ].filter(Boolean).join('\n') + '\n\n'
+    : '';
+
+  // ── Stage 1: Interpret ──
+  const domain = lookupDomain(intent);
+  engine.submitStage(execId, 'interpret', { domain, intent, confidence: domain.confidence });
+
+  // ── Clarity gate (defense-in-depth) ──
+  // If intent has zero domain signals and clarity is below threshold,
+  // return a clarification response instead of hallucinating UI.
+  // This catches cases where the intent gate upstream didn't intercept
+  // (e.g. direct API calls bypassing isConversational).
+  // EXCEPTION: skip on iteration turns. Refinements like "make it 3D" or
+  // "remove the avatar" have zero domain signals but are valid modifications
+  // of the prior canvas — they should pass straight through to the LLM with
+  // history context. Iteration is detected by the presence of prior turns in
+  // the artifact store keyed by storeId. Same intent as F1 in generator.js.
+  const priorTurnCount = store.getAll(storeId || execId)?.length || 0;
+  const isIteration = priorTurnCount > 0;
+  const clarity = assessClarity(intent, domain);
+  if (!isIteration && !clarity.clear && domain.confidence === 0) {
+    // Note: 'clarify' is not a registered pipeline stage, so we skip submitStage
+    // here to avoid throwing — the clarification surfaces in the return payload.
+    return {
+      executionId: storeId,
+      messages: [],
+      validation: { score: 0, errors: [], warnings: ['Intent does not describe a UI component'] },
+      suggestions: clarity.questions.map(q => q.text),
+      clarify: {
+        needed: true,
+        questions: clarity.questions,
+        score: clarity.score,
+        dimensions: clarity.dimensions,
+        summary: clarity.summary,
+      },
+      pipeline: engine.getState(execId),
+    };
+  }
+
+  // ── Stage 2: Analyze ──
+  const catalogContext = await getContext(intent, 2);
+  engine.submitStage(execId, 'analyze', {
+    context: catalogContext, componentCount: catalogContext.components.length, patternCount: catalogContext.patterns.length,
+    confidence: 0.85,
+  });
+
+  // ── Stage 3: Plan — search for best pattern + best chunk ──
+  const patterns = searchBlocks(searchQuery, { domain: domain.domain });
+  const bestPattern = patterns[0];
+
+  // ── Parallel chunk retrieval (training-corpus path) ──
+  // The chunks corpus at packages/gen-ui/corpus/chunks/*.json captures real
+  // page-shape blocks harvested from working apps (auth/sign-in,
+  // settings pages, dashboards, etc.). When a query strongly matches a
+  // chunk, we inject the chunk's HTML as a STRUCTURAL REFERENCE into the
+  // adapt prompt — so the LLM has the canonical shape, not just a
+  // description of it. This closes the gap where monolithic-pro was
+  // describing chunks (via the score-card's pattern-match telemetry) but
+  // never actually using them in generation.
+  //
+  // Threshold rationale: searchChunks's keyword-score scale is the same
+  // family as the existing STRONG_RETRIEVAL_SCORE=8 in zettel's chunk
+  // synthesizer. We use a slightly lower threshold (5) for monolithic
+  // because the chunk is REFERENCE, not authoritative — the LLM still
+  // adapts, so we'd rather over-inject and let the LLM judge relevance.
+  let chunkMatch = null;
+  let chunkRefHtml = null;
+  try {
+    const chunkHits = await searchChunks(searchQuery, { limit: 1 });
+    if (chunkHits.length && chunkHits[0].score >= 5) {
+      chunkMatch = chunkHits[0];
+      // Expand the chunk's nested refs so the LLM sees the complete
+      // structural context, not just the outer shell. Depth-capped to
+      // protect against the recursive nested chain blowing token budget.
+      const graph = await expandChunkGraph(chunkMatch.record, { maxDepth: 3 });
+      chunkRefHtml = graph
+        .map((g) => `<!-- chunk: ${g.name} (${g.kind}/${g.primary}) -->\n${g.html || ''}`)
+        .join('\n\n');
+    }
+  } catch {
+    // Chunk loader is best-effort — never block generation on its failures
+  }
+
+  // ── Compositional reasoning: decompose multi-section intents ──
+  // ALWAYS attempt decomposition for compound intents — even when a single
+  // best pattern matches.  This lets the LLM receive fragment patterns for
+  // each sub-section (e.g. "invoice table", "payment form") alongside the
+  // overall best pattern, producing richer multi-section output.
+  let fragmentPatterns = [];
+  let decomposition = decomposeIntent(intent);
+
+  // Determine if intent is compound: decomposer says so, OR 3+ meaningful words
+  const meaningfulWords = intent.replace(/\b(a|an|the|with|and|or|for|of|in|on|to|by)\b/gi, '').trim().split(/\s+/).filter(w => w.length > 2);
+  const isCompound = (decomposition.shouldDecompose && decomposition.subtasks.length >= 2)
+    || meaningfulWords.length >= 3;
+
+  if (isCompound && decomposition.subtasks.length >= 2) {
+    for (const subtask of decomposition.subtasks) {
+      const subPatterns = searchBlocks(subtask.intent, { domain: domain.domain });
+      const topMatch = subPatterns[0];
+      if (topMatch?.template) {
+        fragmentPatterns.push({
+          label: subtask.label,
+          subtaskIntent: subtask.intent,
+          pattern: topMatch,
+        });
+      }
+    }
+  }
+
+  const hasFragments = fragmentPatterns.length >= 2;
+  engine.submitStage(execId, 'plan', {
+    strategy: bestPattern?.template ? (hasFragments ? 'adapt-with-fragments' : 'adapt-pattern') : hasFragments ? 'compose-fragments' : 'generate-fresh',
+    patternName: bestPattern?.name ?? (chunkMatch?.name ?? null),
+    chunkRef: chunkMatch ? { name: chunkMatch.name, score: chunkMatch.score, kind: chunkMatch.kind, primary: chunkMatch.primary } : null,
+    fragments: hasFragments ? fragmentPatterns.map(f => f.pattern.name) : undefined,
+    layout: hasFragments ? decomposition?.layout : undefined,
+    confidence: bestPattern?.template ? 0.9 : hasFragments ? 0.85 : chunkMatch ? 0.8 : 0.7,
+  });
+
+  // ── Stage 4: Generate ──
+
+  // Check if this is a multi-turn iteration with existing canvas state.
+  // This runs BEFORE branching so ALL paths (adapt, compose, generate-fresh)
+  // can inject the current canvas when iterating.
+  // Priority order:
+  //   1. priorComponentsFromPayload — client-owned canvas (stateless path)
+  //   2. ArtifactStore lookup via storeId — server-stateful path (legacy)
+  // The payload path wins when both present so the client is the source of
+  // truth (it knows its current canvas; the store may be stale, e.g. after
+  // a server restart or when iterating across tabs).
+  let priorComponents = [];
+  if (Array.isArray(priorComponentsFromPayload) && priorComponentsFromPayload.length > 0) {
+    priorComponents = priorComponentsFromPayload;
+  } else {
+    const prevTurns = store.getAll(storeId || execId);
+    if (prevTurns && prevTurns.length > 0) {
+      const lastTurn = prevTurns[prevTurns.length - 1];
+      priorComponents = lastTurn.messages?.flatMap(m => m.components || []) || [];
+    }
+  }
+  const hasPriorCanvas = priorComponents.length > 0;
+
+  // ── Drift guard: detect scope creep and inject guardrails into prompt ──
+  const preDriftMetrics = hasPriorCanvas ? store.getDriftMetrics(storeId || execId) : null;
+  const originalIntent = preDriftMetrics?.originalIntent || null;
+  const driftGuard = preDriftMetrics?.driftScore >= 0.4
+    ? `\n\nSCOPE GUARD: This canvas has grown significantly from the original brief ("${preDriftMetrics.originalIntent}"). Component count: ${priorComponents.length}. Only make changes the user EXPLICITLY requested. Do NOT add new sections, cards, or structural elements beyond what the user asked for in this turn.`
+    : '';
+
+  let messages, systemPrompt;
+  // Captured for the dialog recorder when ADIA_LOG_DIALOGS is on. Holds the
+  // raw text from whichever LLM branch produced the final result. No-op when
+  // recording is off — the assignments are cheap; the size cost only matters
+  // when the recorder actually persists them to disk.
+  let lastRawResponse = null;
+  let lastTokens = null;
+
+  // Pattern templates are pre-inlined as of the 2026-05-12 fragment
+  // retirement (§37) — compositions/ no longer carry $fragment refs and
+  // there's nothing left to expand. We pass the template straight to the
+  // LLM. If a stale pattern with $fragment refs sneaks back in, the LLM
+  // will see the literal placeholder string and likely include it in
+  // output (acceptable failure mode; corpus drift is caught by the
+  // verify:corpus script).
+  const expandedPatternTemplate = bestPattern?.template ?? null;
+
+  // ── Chunk reference block — injected into the user prompt when a
+  //    strong chunk match was found at retrieval time. This is the
+  //    structural "look like this" hint that lets the LLM materialize the
+  //    real chunk shape (e.g. auth-signin-card-email) instead of
+  //    hallucinating a passable-but-wrong shape from the brief alone.
+  //
+  //    §56 (v0.4.5): prompt language enriched with provenance + metadata so
+  //    the LLM understands the chunk's domain/keywords context. Tested via
+  //    factory-chat + gen-ui live submit; LLMs produce closer structural
+  //    matches when told what the chunk is + where it came from.
+  const chunkReferenceBlock = chunkRefHtml
+    ? `\nSTRUCTURAL REFERENCE — this chunk was retrieved from the AdiaUI training corpus (annotated production HTML, harvested from real app pages). It matched your intent on keyword/domain ranking:
+
+CHUNK: ${chunkMatch.name}
+  kind=${chunkMatch.kind}, primary=${chunkMatch.primary}, score=${chunkMatch.score}${chunkMatch.metadata?.domain ? `, domain=${chunkMatch.metadata.domain}` : ''}${chunkMatch.metadata?.description ? `\n  description: ${chunkMatch.metadata.description}` : ''}${chunkMatch.metadata?.keywords ? `\n  keywords: ${chunkMatch.metadata.keywords.join(', ')}` : ''}
+
+Match this chunk's component palette, information density, and Card/Header/Section/Footer anatomy. Do NOT copy the HTML verbatim into A2UI — translate its semantic structure into the equivalent A2UI components. The chunk represents the SHAPE the user wants; your job is to instantiate that shape with their content:
+---
+${chunkRefHtml}
+---
+`
+    : '';
+
+  if (bestPattern && bestPattern.template) {
+    // PRO PATH: Adapt the matched pattern via LLM
+    systemPrompt = await buildSystemPrompt(catalogContext, patterns, '', intent, null, context);
+
+    const adaptPrompt = hasPriorCanvas
+      ? `Adapt this UI for the intent: "${intent}"${driftGuard}
+${chunkReferenceBlock}
+${buildCanvasDiffPrompt(intent, priorComponents, { originalIntent })}`
+      : hasFragments
+        ? `Adapt this UI for the intent: "${intent}"
+${chunkReferenceBlock}
+BASE TEMPLATE (use for overall structure — modify, don't generate from scratch):
+${JSON.stringify(expandedPatternTemplate, null, 2)}
+
+Pattern: "${bestPattern.name}" — ${bestPattern.description}
+
+FRAGMENT PATTERNS — incorporate these for specific sections:
+${fragmentPatterns.map(f => `## ${f.label} (from "${f.pattern.name}" pattern)\n${JSON.stringify(f.pattern.template, null, 1)}`).join('\n\n')}
+
+Instructions:
+- Use the base pattern for overall structure and layout
+- Incorporate the fragment patterns above for their respective sections
+- Change text content, labels, icons to match the new intent
+- Add or remove components as needed for the intent
+- Preserve slot attributes and Card anatomy rules
+- Generate a COMPLETE, richly detailed UI with 20-40 components minimum
+- Each section from the intent should have its own Card with Header, Section, and Footer
+- Include realistic text content, labels, and placeholder data — not generic text
+- Output ONLY the JSON array, no explanation`
+        : `Adapt this UI for the intent: "${intent}"
+${chunkReferenceBlock}
+BASE TEMPLATE (modify this, don't generate from scratch):
+${JSON.stringify(expandedPatternTemplate, null, 2)}
+
+Pattern: "${bestPattern.name}" — ${bestPattern.description}
+
+Instructions:
+- Keep the structural skeleton (Card > Header + Section + Footer, nesting, layout)
+- Change text content, labels, icons to match the new intent
+- Add or remove components as needed for the intent
+- Preserve slot attributes and Card anatomy rules
+- Generate at least 15 components. Expand the template with additional fields, buttons, and content as appropriate for the intent.
+- Output ONLY the JSON array, no explanation`;
+
+    const response = await llmAdapter.complete({
+      messages: [{ role: 'user', content: analysisHint + adaptPrompt }],
+      systemPrompt,
+    });
+    messages = parseA2UIResponse(response.content, { executionId: execId, mode: 'pro', intent, stopReason: response.stopReason });
+    if (isRecording()) { lastRawResponse = response.content; lastTokens = response.usage || null; }
+  } else if (hasFragments) {
+    // COMPOSE PATH: multiple fragment patterns found for subtasks — compose in a single LLM call
+    systemPrompt = await buildSystemPrompt(catalogContext, patterns, '', intent, { fragmentPatterns, decomposition }, context);
+
+    const fragmentContext = fragmentPatterns.map(f =>
+      `## ${f.label} (from "${f.pattern.name}" pattern)\n${JSON.stringify(f.pattern.template, null, 1)}`
+    ).join('\n\n');
+
+    const layoutHint = decomposition.layout
+      ? `Use a ${decomposition.layout.component} as the root layout container.`
+      : 'Use a Column as the root layout container.';
+
+    const canvasContext = hasPriorCanvas
+      ? `\n${buildCanvasDiffPrompt(intent, priorComponents, { originalIntent })}${driftGuard}\n`
+      : '';
+
+    const composePrompt = `Compose a UI for: "${intent}"
+${chunkReferenceBlock}${canvasContext}
+This intent has ${fragmentPatterns.length} sections. ${layoutHint}
+
+FRAGMENT PATTERNS — use these as building blocks for each section:
+
+${fragmentContext}
+
+Instructions:
+- ${hasPriorCanvas ? 'Return ONLY diff objects (add/modify/delete) — unchanged components are preserved automatically' : 'Combine ALL fragments into a single cohesive UI under one root'}
+- Re-id all components to avoid collisions (e.g., prefix with section name)
+- ${decomposition.layout?.component === 'Tabs' ? 'Use Tabs as root with Tab children for each section — each section\'s content goes INSIDE its Tab (the parent auto-hides inactive panels)' : `Use ${decomposition.layout?.component || 'Column'} as root, with each section as a child`}
+- Adapt text content, labels, and icons to match the overall intent
+- Add a page-level header above the sections if appropriate
+- Preserve slot attributes and Card anatomy rules from each fragment
+- Generate a COMPLETE, richly detailed UI with 20-40 components minimum. Each section should have its own Card with Header, Section, and Footer.
+- Include realistic text content, labels, placeholder data, and all fields/buttons a real production UI would have.
+- Output ONLY the JSON array, no explanation`;
+
+    const response = await llmAdapter.complete({
+      messages: [{ role: 'user', content: analysisHint + composePrompt }],
+      systemPrompt,
+    });
+    messages = parseA2UIResponse(response.content, { executionId: execId, mode: 'pro', intent, stopReason: response.stopReason });
+    if (isRecording()) { lastRawResponse = response.content; lastTokens = response.usage || null; }
+  } else {
+    // No pattern — fall through to full thinking-style generation
+    systemPrompt = await buildSystemPrompt(catalogContext, patterns, '', intent, null, context);
+
+    if (hasPriorCanvas) {
+      // Multi-turn: inject current canvas as explicit iteration context
+      const iteratePrompt = `Modify this UI for the intent: "${intent}"${driftGuard}
+${chunkReferenceBlock}
+${buildCanvasDiffPrompt(intent, priorComponents, { originalIntent })}`;
+
+      const response = await llmAdapter.complete({
+        messages: [{ role: 'user', content: analysisHint + iteratePrompt }],
+        systemPrompt,
+      });
+      messages = parseA2UIResponse(response.content, { executionId: execId, intent, mode: 'pro', stopReason: response.stopReason });
+      if (isRecording()) { lastRawResponse = response.content; lastTokens = response.usage || null; }
+    } else {
+      // First-turn fresh generation. When we have a chunk match, prepend
+      // the structural reference to the user message so the LLM sees the
+      // canonical shape before the standard chat-built prompt.
+      const chatMessages = buildChatMessages(intent, storeId || execId);
+      if (chunkReferenceBlock && chatMessages.length) {
+        // The last message in chatMessages is the user's brief — prepend
+        // the chunk reference to its content.
+        const lastIdx = chatMessages.length - 1;
+        if (chatMessages[lastIdx].role === 'user') {
+          chatMessages[lastIdx] = {
+            ...chatMessages[lastIdx],
+            content: `${chunkReferenceBlock}\n${chatMessages[lastIdx].content}`,
+          };
+        }
+      }
+      const response = await llmAdapter.complete({ messages: chatMessages, systemPrompt });
+      messages = parseA2UIResponse(response.content, { executionId: execId, intent, mode: 'pro', stopReason: response.stopReason });
+      if (isRecording()) { lastRawResponse = response.content; lastTokens = response.usage || null; }
+    }
+  }
+
+  // ── Canvas diff merge: apply LLM response onto prior canvas ──
+  //
+  // §168 (v0.5.4): merge always runs on iteration turns regardless of canvas
+  // size. Pre-§168 the gate was `priorComponents.length >= 50`, which created
+  // a three-band threshold mismatch:
+  //   0–49   : prompt asked for COMPLETE array, merge skipped → LLM output
+  //            wholesale-replaced canvas (verified 2026-05-14 chart-workflow
+  //            ticket: 32-component canvas + "add a chart" intent →
+  //            202-component response wiped the user's prior work)
+  //   50–299 : prompt asked for COMPLETE array, merge ran treating output
+  //            as DIFF → prompt/code mismatch
+  //   300+   : prompt asked for DIFF only, merge ran (correct band)
+  //
+  // mergeCanvasDiff() is a strict superset of "replace" behaviorally:
+  //   - When LLM returns COMPLETE array: every prior id is present in output
+  //     → merged in-place (no-op if unchanged; updates if changed). Missing
+  //     prior ids preserved. New ids appended. Net behavior = identical to
+  //     wholesale-replace when LLM cooperates, safer when LLM returns subset.
+  //   - When LLM returns DIFF: existing behavior preserved.
+  // Plus the hallucination-detection guards in mergeCanvasDiff (matchRatio
+  // < 0.2 reject + < 0.6 accept-with-warning) discriminate by match ratio,
+  // which is more principled than canvas-size heuristics.
+  if (hasPriorCanvas && messages && messages.length > 0) {
+    for (const msg of messages) {
+      if (msg.type === 'updateComponents' && msg.components) {
+        msg.components = mergeCanvasDiff(priorComponents, msg.components);
+      }
+    }
+  }
+
+  engine.submitStage(execId, 'generate', {
+    messages, source: bestPattern ? (hasFragments ? 'adapt-with-fragments' : 'adapt') : hasFragments ? 'compose' : 'llm', confidence: 0.85,
+    fragments: hasFragments ? fragmentPatterns.length : undefined,
+  });
+
+  // ── Stage 5: Validate + repair ──
+  // Shared with every other LLM-calling engine — see validate-and-repair.js.
+  // maxAttempts: 2 (vs. thinking's 3) reflects pro's cheaper cost tier.
+  // runCatalogCheck adds Ajv catalog-schema coverage pro never had before —
+  // buildRepairPrompt's catalogFailures param already defaults to [] so
+  // this is additive, not a signature break.
+  const repairResult = await validateAndRepair({
+    messages,
+    llmAdapter,
+    buildRepairPrompt,
+    parseResponse: (repairResponse) => parseA2UIResponse(
+      repairResponse.content,
+      { executionId: execId, intent, mode: 'pro', stopReason: repairResponse.stopReason },
+    ),
+    systemPrompt,
+    validateContext: { intent, context },
+    foldInAntiPatterns,
+    maxAttempts: 2,
+  });
+  messages = repairResult.messages;
+  const validation = repairResult.validation;
+  engine.submitStage(execId, 'validate', { ...validation, confidence: validation.score / 100 });
+
+  // REQ-03 (spec-factory-dx-ws4-acceptance): monolithic-pro is the ladder's
+  // terminal engine (cascade.js's ENGINE_LADDER) — its result is the one no
+  // exit gate ever runs against (the floor exemption cascade.js:84-88
+  // documents), so THIS is the one place `repairResult.exhausted` must
+  // survive instead of being silently discarded. "Flagged" means the
+  // returned object carries `acceptance.accepted === false` with a
+  // non-empty `failures` list whenever schema or catalog validation failed.
+  const acceptance = {
+    accepted: repairResult.valid,
+    exhausted: repairResult.exhausted,
+    failures: repairResult.valid ? [] : buildFailures(repairResult.validation, repairResult.catalogValidation),
+  };
+
+  // ── Stage 6: Store ──
+  // First-turn analysis is recorded so iteration turns can recover concepts +
+  // implied components for canvas-aware suggestions. The store keeps only the
+  // first turn's analysis value (later passes are nulls — by design).
+  const artifactId = storeId || execId;
+  store.record(artifactId, { messages, summary: intent, validation, intent, analysis });
+  engine.submitStage(execId, 'render', { stored: true, success: validation.valid });
+
+  // Pull the original analyzer output so suggestions stay anchored to the
+  // initial canvas concept even on iteration turns. Without this, chip
+  // clicks drift the suggestion pool away from the original intent.
+  const originalAnalysis = store.getOriginalAnalysis(artifactId);
+  const suggestions = generateSuggestions({ intent, domain, messages, originalAnalysis, originalIntent });
+
+  // ── Drift detection: warn when canvas structure diverges significantly ──
+  const driftMetrics = store.getDriftMetrics(artifactId);
+  if (driftMetrics?.warning) {
+    console.warn(`[generateUI:pro] ${driftMetrics.warning}`);
+  }
+
+  // Fire-and-forget feedback logging
+  feedbackStore.logExecution({
+    executionId: artifactId, intent, mode: 'pro',
+    domain: domain.domain, patternMatch: bestPattern?.name,
+    chunkMatch: chunkMatch ? chunkMatch.name : null,
+    composedFrom: hasFragments ? fragmentPatterns.map(f => f.pattern.name) : undefined,
+    score: validation?.score, componentCount: messages[0]?.components?.length || 0,
+  }).catch(() => {});
+
+  return {
+    executionId: artifactId,
+    messages,
+    validation,
+    acceptance,
+    suggestions,
+    drift: driftMetrics,
+    pipeline: engine.getState(execId),
+    // Debug payload for the dialog recorder. Only populated when
+    // ADIA_LOG_DIALOGS is on (the engine's capture sites guard with
+    // isRecording()). Underscore-prefixed so consumers can ignore it,
+    // and so it never accidentally appears in serialised API payloads
+    // unless the proxy explicitly forwards it.
+    _debug: isRecording() ? {
+      systemPrompt,
+      rawLLMResponse: lastRawResponse,
+      tokens: lastTokens,
+      patterns: patterns.slice(0, 8).map(p => ({ name: p.name, score: p.score, keywords: p.keywords })),
+    } : undefined,
+  };
+}