@adia-ai/a2ui-compose 0.0.1

package/engines/monolithic/generate-instant.js

@@ -0,0 +1,229 @@
+/**
+ * @adia-ai/a2ui-compose — monolithic engine, instant mode.
+ *
+ * Extracted from engine/generator.js per spec §11 Phase 2. Shares state
+ * (ArtifactStore, PipelineEngine) via engine/state.js. Pure helpers live
+ * in engines/monolithic/_shared.js.
+ */
+
+import { validateSchema } from '../../../validator/validator.js';
+import { getContext, searchBlocks, lookupDomain } from '../../engine/reference.js';
+import { assessClarity } from '../../../retrieval/clarity.js';
+import { feedbackStore } from '../../../retrieval/feedback-store.js';
+import { store, engine } from '../../engine/state.js';
+import { isRecording } from '../../../retrieval/dialog-recorder.js';
+import {
+  generateSuggestions,
+} from './_shared.js';
+
+export async function generateInstant({ intent, executionId, storeId, analysis, priorComponentsFromPayload }) {
+  // Forward-compat: instant mode is pattern-match-only and doesn't iterate
+  // on a prior canvas yet. Accept the param so callers can pass uniformly.
+  void priorComponentsFromPayload;
+  const execId = executionId;
+  // Use the analyzer's steelman as the search query for denser keyword hits.
+  // Pattern matching is deterministic, so the analysis lifts retrieval quality
+  // without changing any other instant-mode behavior.
+  const searchQuery = analysis?.steelman || intent;
+
+  // ── Interpret stage ──
+  const domain = lookupDomain(intent);
+  engine.submitStage(execId, 'interpret', {
+    domain,
+    intent,
+    confidence: domain.confidence,
+  });
+
+  // ── Clarity gate (defense-in-depth) ──
+  if (domain.confidence === 0) {
+    const clarity = assessClarity(intent, domain);
+    if (!clarity.clear) {
+      engine.submitStage(execId, 'clarify', { clarity, reason: 'no-ui-signals' });
+      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),
+      };
+    }
+  }
+
+  // ── Analyze stage ──
+  const context = await getContext(intent, 1);
+  engine.submitStage(execId, 'analyze', {
+    context,
+    componentCount: context.components.length,
+    patternCount: context.patterns.length,
+    confidence: context.patterns.length > 0 ? 0.9 : 0.6,
+  });
+
+  // ── Plan stage ──
+  const patterns = searchBlocks(searchQuery, { domain: domain.domain });
+  // Quality gate: only use a pattern if an intent keyword matches a whole
+  // word in the pattern name. Prevents substring matches like "button" in
+  // "toolbar-buttons" from hijacking unrelated intents.
+  const GATE_STOPS = new Set(['the','and','with','for','from','that','this','its','are','all','can','has','each','show','using','based','into','like','make','your','type','just','only','also','more','most','some','very','much','many','will','about','been','when','they','them','what','would','could','should','different','simple','basic','custom','display','controls','group','selection','content','state']);
+  const intentWords = intent.toLowerCase().split(/\s+/).filter(w => w.length > 2 && !GATE_STOPS.has(w));
+  let bestMatch = patterns[0] || null;
+  if (bestMatch) {
+    const nameWords = bestMatch.name.toLowerCase().split(/[-_\s]+/);
+    const matchTags = (bestMatch.tags || []).map(t => t.toLowerCase());
+    const matchDomain = (bestMatch.domain || '').toLowerCase();
+    // Tiered matching: strong hit (exact word or 4+ char prefix), or weak hit (3-char word, domain match, substring)
+    // Strong hit = high confidence, weak hit = use as suggestion with lower confidence
+    const hasStrongHit = intentWords.some(w => {
+      if (w.length < 3) return false;
+      // Exact word match in name or tags (any length >= 3)
+      if (nameWords.includes(w) || matchTags.includes(w)) return true;
+      // Prefix match for longer words (4+ chars)
+      if (w.length >= 4) {
+        return nameWords.some(n => n.length >= 3 && (w.startsWith(n) || n.startsWith(w))) ||
+               matchTags.some(t => t.length >= 3 && (w.startsWith(t) || t.startsWith(w)));
+      }
+      return false;
+    });
+    const hasWeakHit = !hasStrongHit && intentWords.some(w => {
+      // Substring match — intent word appears inside a name/tag word or vice versa
+      return nameWords.some(n => n.length >= 3 && (n.includes(w) || w.includes(n))) ||
+             matchTags.some(t => t.length >= 3 && (t.includes(w) || w.includes(t))) ||
+             matchDomain.includes(w);
+    });
+    if (!hasStrongHit && !hasWeakHit) {
+      bestMatch = null;
+    }
+  }
+  engine.submitStage(execId, 'plan', {
+    strategy: bestMatch ? 'pattern-match' : 'fallback',
+    patternName: bestMatch?.name ?? null,
+    confidence: bestMatch ? 0.95 : 0.5,
+  });
+
+  // ── Generate stage ──
+  let components;
+  const suggestions = [];
+
+  if (bestMatch && bestMatch.template) {
+    components = bestMatch.template;
+  } else {
+    // No exact match — try to compose from partial matches
+    // Take top 2 patterns that passed domain filter (even if they failed the gate)
+    // and merge their component types into a reasonable Card layout
+    const partials = patterns.slice(0, 2);
+    const partialNames = partials.map(p => p.name);
+
+    if (partials.length > 0 && partials[0].template) {
+      // Use the best partial match as the base — it's imperfect but better than a stub
+      components = partials[0].template;
+      suggestions.push(`Adapted from "${partials[0].name}" pattern — may not be exact. Use "thinking" mode for better results.`);
+    } else {
+      // True fallback — build a card scaffolding from the intent
+      const titleText = intent.length > 50 ? intent.slice(0, 47) + '...' : intent;
+      components = [
+        { id: 'root', component: 'Card', children: ['hdr', 'sec'] },
+        { id: 'hdr', component: 'Header', children: ['title', 'desc'] },
+        { id: 'title', component: 'Text', slot: 'heading', textContent: titleText },
+        { id: 'desc', component: 'Text', slot: 'description', textContent: 'Generated from intent — use thinking mode for full fidelity.' },
+        { id: 'sec', component: 'Section', children: ['col'] },
+        { id: 'col', component: 'Column', children: ['body'], gap: '3' },
+        { id: 'body', component: 'Text', variant: 'body', textContent: `Describe what you'd like to see here.` },
+      ];
+      suggestions.push('Use "thinking" mode for LLM-powered generation');
+      if (partialNames.length > 0) {
+        suggestions.push(`Closest patterns: ${partialNames.join(', ')}`);
+      }
+    }
+  }
+
+  const messages = [
+    {
+      type: 'updateComponents',
+      surfaceId: 'default',
+      components,
+    },
+  ];
+
+  // Include wireComponents if the matched pattern has wiring data
+  if (bestMatch?.wiring) {
+    messages.push({
+      type: 'wireComponents',
+      surfaceId: 'default',
+      ...(bestMatch.wiring.data_sources ? { data: { sources: bestMatch.wiring.data_sources } } : {}),
+      ...(bestMatch.wiring.controllers ? { state: { controllers: bestMatch.wiring.controllers } } : {}),
+      ...(bestMatch.wiring.actions ? { actions: bestMatch.wiring.actions } : {}),
+    });
+  }
+
+  engine.submitStage(execId, 'generate', {
+    messages,
+    source: bestMatch ? 'pattern-library' : 'fallback',
+    confidence: bestMatch ? 0.95 : 0.4,
+  });
+
+  // ── Validate stage ──
+  const validation = validateSchema(messages, { intent });
+  engine.submitStage(execId, 'validate', {
+    ...validation,
+    confidence: validation.score / 100,
+  });
+
+  // ── Render stage (record artifact) ──
+  // Store under storeId (previous execution) for multi-turn history continuity.
+  // First-turn analysis is recorded so iteration turns can recover concepts +
+  // implied components for canvas-aware suggestions.
+  const artifactId = storeId || execId;
+  store.record(artifactId, {
+    messages,
+    summary: intent,
+    intent,
+    validation,
+    analysis,
+  });
+
+  engine.submitStage(execId, 'render', {
+    stored: true,
+    confidence: 1,
+  });
+
+  // Canvas-aware suggestions — see generate-pro.js for rationale.
+  const originalAnalysis = store.getOriginalAnalysis(artifactId);
+  const originalIntent = store.getOriginalIntent(artifactId);
+  const domainSuggestions = generateSuggestions({ intent, domain, messages, originalAnalysis, originalIntent });
+  suggestions.push(...domainSuggestions);
+
+  // Fire-and-forget feedback logging
+  feedbackStore.logExecution({
+    executionId: artifactId, intent, mode: 'instant',
+    domain: domain.domain, patternMatch: bestMatch?.name,
+    score: validation?.score, componentCount: components.length,
+  }).catch(() => {});
+
+  return {
+    executionId: artifactId,
+    messages,
+    validation,
+    suggestions,
+    pipeline: engine.getState(execId),
+    // Retrieval surface for eval harness / diff tooling
+    patternName: bestMatch?.name ?? null,
+    strategy: bestMatch ? 'pattern-match' : 'fallback',
+    // Dialog-recorder hook. Instant mode has no LLM call, so systemPrompt /
+    // rawLLMResponse are null — the recorded value is the matched pattern,
+    // which is the only "reasoning" instant mode does.
+    _debug: isRecording() ? {
+      systemPrompt: null,
+      rawLLMResponse: null,
+      tokens: null,
+      patterns: patterns.slice(0, 8).map(p => ({ name: p.name, score: p.score, keywords: p.keywords })),
+      strategy: bestMatch ? 'pattern-match' : 'fallback',
+      patternName: bestMatch?.name || null,
+    } : undefined,
+  };
+}

package/engines/monolithic/generate-pro.js

@@ -0,0 +1,367 @@
+/**
+ * @adia-ai/a2ui-compose — monolithic engine, pro mode.
+ *
+ * Extracted from engine/generator.js per spec §11 Phase 2. Shares state
+ * (ArtifactStore, PipelineEngine) via engine/state.js. Pure helpers live
+ * in engines/monolithic/_shared.js.
+ */
+
+import { validateSchema } from '../../../validator/validator.js';
+import { getContext, searchBlocks, lookupDomain } from '../../engine/reference.js';
+import { decomposeIntent } from '../../../retrieval/decomposer.js';
+import { assessClarity } from '../../../retrieval/clarity.js';
+import { isConversational } from '../../../retrieval/intent-gate.js';
+import { feedbackStore } from '../../../retrieval/feedback-store.js';
+import { store, engine } from '../../engine/state.js';
+import { isRecording } from '../../../retrieval/dialog-recorder.js';
+import {
+  buildSystemPrompt,
+  buildChatMessages,
+  mergeCanvasDiff,
+  buildCanvasDiffPrompt,
+  parseA2UIResponse,
+  buildRepairPrompt,
+  generateSuggestions,
+} from './_shared.js';
+
+export async function generatePro({ intent, executionId, storeId, llmAdapter, analysis, priorComponentsFromPayload }) {
+  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 context = await getContext(intent, 2);
+  engine.submitStage(execId, 'analyze', {
+    context, componentCount: context.components.length, patternCount: context.patterns.length,
+    confidence: 0.85,
+  });
+
+  // ── Stage 3: Plan — search for best pattern ──
+  const patterns = searchBlocks(searchQuery, { domain: domain.domain });
+  const bestPattern = patterns[0];
+
+  // ── 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 ?? null,
+    fragments: hasFragments ? fragmentPatterns.map(f => f.pattern.name) : undefined,
+    layout: hasFragments ? decomposition?.layout : undefined,
+    confidence: bestPattern?.template ? 0.9 : hasFragments ? 0.85 : 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;
+  if (bestPattern && bestPattern.template) {
+    // PRO PATH: Adapt the matched pattern via LLM
+    systemPrompt = await buildSystemPrompt(context, patterns, '', intent);
+
+    const adaptPrompt = hasPriorCanvas
+      ? `Adapt this UI for the intent: "${intent}"${driftGuard}
+
+${buildCanvasDiffPrompt(intent, priorComponents, { originalIntent })}`
+      : hasFragments
+        ? `Adapt this UI for the intent: "${intent}"
+
+BASE TEMPLATE (use for overall structure — modify, don't generate from scratch):
+${JSON.stringify(bestPattern.template, 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}"
+
+BASE TEMPLATE (modify this, don't generate from scratch):
+${JSON.stringify(bestPattern.template, 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(context, patterns, '', intent, { fragmentPatterns, decomposition });
+
+    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}"
+${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 — content panels are SIBLINGS of Tabs, not children' : `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(context, patterns, '', intent);
+
+    if (hasPriorCanvas) {
+      // Multi-turn: inject current canvas as explicit iteration context
+      const iteratePrompt = `Modify this UI for the intent: "${intent}"${driftGuard}
+
+${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 {
+      const chatMessages = buildChatMessages(intent, storeId || execId);
+      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 diff response onto prior canvas ──
+  // Only merge when using diff format (large canvases ≥50 components).
+  // For small canvases, the LLM was asked to return the COMPLETE modified array.
+  if (hasPriorCanvas && priorComponents.length >= 50 && 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 ──
+  let validation = validateSchema(messages, { intent });
+  if (!validation.valid) {
+    try {
+      const failedChecks = validation.checks.filter(c => !c.passed);
+      const repairResponse = await llmAdapter.complete({
+        messages: [{ role: 'user', content: buildRepairPrompt(failedChecks, messages) }],
+        systemPrompt,
+      });
+      messages = parseA2UIResponse(repairResponse.content, { executionId: execId, intent, mode: 'pro', stopReason: repairResponse.stopReason });
+      validation = validateSchema(messages, { intent });
+    } catch { /* keep original */ }
+  }
+  engine.submitStage(execId, 'validate', { ...validation, confidence: validation.score / 100 });
+
+  // ── 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,
+    composedFrom: hasFragments ? fragmentPatterns.map(f => f.pattern.name) : undefined,
+    score: validation?.score, componentCount: messages[0]?.components?.length || 0,
+  }).catch(() => {});
+
+  return {
+    executionId: artifactId,
+    messages,
+    validation,
+    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,
+  };
+}