@adia-ai/gen-ui 0.8.37

package/compose/core/generator.js

@@ -0,0 +1,602 @@
+/**
+ * generate_ui — UI generation from natural language intent.
+ *
+ * Four modes:
+ *   instant  — pattern matching, no LLM (synchronous)
+ *   pro      — pattern search + LLM adaptation (async, blocking)
+ *   thinking — A003 intelligence + LLM adapter (async, blocking)
+ *   stream   — same as thinking but yields progressive updates via async generator
+ *
+ * Multi-turn: pass executionId from a previous run to iterate on the same surface.
+ * The previous A2UI output is fed back as assistant context so the LLM can refine.
+ */
+
+import { validateSchema } from '@adia-ai/a2ui/validate';
+import { getContext, searchBlocks, searchBlocksSemantic, lookupDomain, listPatterns } from './reference.js';
+import { store, engine } from './state.js';
+import { checkIntentAlignment } from '../../retrieval/intent/intent-alignment.js';
+import { decomposeIntent, composeSubtasks } from '../../retrieval/intent/decomposer.js';
+import { getWiringCatalog } from '../../retrieval/wiring-catalog.js';
+
+import { StubLLMAdapter } from '@adia-ai/llm/stub';
+import { createAdapter } from '@adia-ai/llm/bridge';
+import { assessClarity } from '../../retrieval/intent/clarity.js';
+import { isConversational } from '../../retrieval/intent/intent-gate.js';
+import { classifyIntent } from '../../retrieval/domain-router.js';
+import { researchIntent, detectReferences } from '../../retrieval/authoring/web-research.js';
+import { feedbackStore } from '../../retrieval/feedback/feedback-store.js';
+import { pick as pickEngine, registerMonolithicEngines } from '../strategies/registry.js';
+import { analyzePrompt } from '../../retrieval/intent/prompt-analyzer.js';
+import { recordTurn, isRecording } from '../../retrieval/feedback/dialog-recorder.js';
+import {
+  buildSystemPrompt,
+  buildChatMessages,
+  tryParsePartial,
+  mergeCanvasDiff,
+  buildCanvasDiffPrompt,
+  parseA2UIResponse,
+  buildRepairPrompt,
+  generateSuggestions,
+  foldInAntiPatterns,
+} from '../strategies/monolithic/_shared.js';
+import { validateAndRepair } from '../shared/validate-and-repair.js';
+import { generateInstant }  from '../strategies/monolithic/generate-instant.js';
+import { generatePro }      from '../strategies/monolithic/generate-pro.js';
+import { generateThinking } from '../strategies/monolithic/generate-thinking.js';
+
+
+/**
+ * Generate a UI surface from a natural language intent.
+ *
+ * @param {object} opts
+ * @param {string} opts.intent — Natural language intent
+ * @param {'instant'|'pro'|'thinking'|'stream'} [opts.mode='instant'] — Generation mode
+ * @param {string} [opts.executionId] — Existing execution ID (for multi-turn iteration)
+ * @param {object} [opts.currentCanvas] — Client-owned canvas state, enables
+ *   stateless iteration. Shape is a discriminated union:
+ *     { components: A2UIComponent[] }   — flat component array
+ *     { messages:   A2UIMessage[]   }   — full message sequence
+ *   When provided, the pipeline uses this as the iteration baseline instead
+ *   of looking up prior turns in the ArtifactStore. This makes generation
+ *   stateless — the client can iterate across server restarts, multiple tabs,
+ *   or from a saved-canvas JSON file. Backward compatible: if omitted, the
+ *   store lookup via `executionId` still works.
+ * @param {object} [opts.llmAdapter] — LLM adapter (defaults to auto-detected)
+ * @param {object} [opts.context] — Ontology context parsed by plan_app_state:
+ *   the four-block shape { intent, domain, tasks, experience } validated by
+ *   @adia-ai/mcp's gen-ui surface's ontologyContextSchema (REQ-03, gh#1208). Only
+ *   domain.entities, domain.metrics, tasks.primary, experience.mode, and
+ *   experience.shell are currently interpolated into the monolithic system
+ *   prompt (strategies/monolithic/_shared.js); intent.* and tasks.inspection
+ *   validate but are not yet read downstream (gh#1208 review finding 4/6).
+ * @returns {Promise<{ executionId: string, messages: object[], validation: object, suggestions: string[] }>}
+ */
+export async function generateUI({ intent, engine: engineName = 'monolithic', mode = 'instant', executionId, currentCanvas, llmAdapter, model, sessionId, context }) {
+  // Iteration signal: either an executionId (server-stateful path) OR a
+  // currentCanvas (client-stateless path). Both mean "refine existing UI".
+  const hasClientCanvas = !!(currentCanvas && (currentCanvas.components?.length || currentCanvas.messages?.length));
+  const isIteration = !!executionId || hasClientCanvas;
+
+  // ── Intent gate: reject non-UI prompts before entering the pipeline ──
+  // This prevents the LLM from hallucinating UIs from vague/abstract text.
+  // EXCEPTION: skip the gate on iteration turns. Modifiers like "make it 3D",
+  // "remove the avatar", "try a rose theme" rarely contain UI nouns the gate
+  // recognizes — they're refinements of the prior canvas, not fresh intents.
+  if (!isIteration) {
+    const classification = classifyIntent(intent);
+    const intentCheck = isConversational(intent, classification);
+    if (intentCheck.conversational) {
+      const clarity = assessClarity(intent, classification);
+      return {
+        executionId: executionId || 'rejected',
+        messages: [],
+        validation: { score: 0, valid: false, errors: [`Intent rejected: ${intentCheck.reason}`] },
+        suggestions: clarity.questions.map(q => q.text),
+        rejected: true,
+        reason: intentCheck.reason,
+      };
+    }
+  }
+
+  // For multi-turn: keep the old executionId for artifact history,
+  // but always start a fresh pipeline execution for stage tracking.
+  const previousExecId = executionId;
+  executionId = engine.start({ intent, mode, previousExecId });
+
+  // ── Engine dispatch (Phase 5) ──
+  // Zettel engine: single mode (instant), fragment-graph composition.
+  // Monolithic engine: three modes (instant | pro | thinking | stream→thinking).
+  // Analyzer is BASELINE for every reasoning level — every mode gets an LLM
+  // adapter (instant included). The analyzer call adds ~1-2s to the floor but
+  // the structured signals it produces (steelman, concepts, impliedComponents)
+  // dramatically improve downstream pattern retrieval and LLM generation
+  // quality. Adapter is always created upfront so all modes can analyze.
+  const effectiveMode = mode === 'stream' ? 'thinking' : mode;
+  const adapter = llmAdapter || await createAdapter({ model });
+
+  // ── Stage 0: Prompt Analysis (baseline ingestion) ──
+  // Extract structured signals from the raw prompt so every downstream stage
+  // — pattern search, concept-mapping retrieval, system prompt construction
+  // — reasons against an enriched brief instead of the raw text.
+  // Skipped on iteration turns where the user's modifier ("make it 3D") is
+  // most useful as-is for the LLM iteration prompt.
+  let analysis = null;
+  if (!isIteration) {
+    analysis = await analyzePrompt({ intent, llmAdapter: adapter });
+  }
+
+  // ── Normalize currentCanvas into a uniform priorComponents array ──
+  // Engines consume a single array; the shape union is collapsed here so
+  // engine code doesn't branch on input form.
+  let priorComponentsFromPayload = null;
+  if (hasClientCanvas) {
+    if (Array.isArray(currentCanvas.components)) {
+      priorComponentsFromPayload = currentCanvas.components;
+    } else if (Array.isArray(currentCanvas.messages)) {
+      priorComponentsFromPayload = currentCanvas.messages.flatMap(m => m?.components || []);
+    }
+  }
+
+  const fn = pickEngine({ engine: engineName, mode: effectiveMode });
+  const t0 = Date.now();
+  const result = await fn({
+    intent,
+    executionId,
+    storeId: previousExecId || executionId,
+    llmAdapter: adapter,
+    sessionId,
+    analysis,
+    priorComponentsFromPayload,
+    context, // Pass the ontology context to the engine
+  });
+  const totalMs = Date.now() - t0;
+
+  // ── Dialog recording (fire-and-forget, gated by ADIA_LOG_DIALOGS) ──
+  // Captures the entire turn — intent, analysis, system prompt, raw LLM
+  // response, parsed messages, validation, drift, telemetry — to disk for
+  // debugging, regression analysis, and training-data bootstrapping. The
+  // recorder no-ops when the env var is unset; the engine's _debug payload
+  // is also only populated when recording is on (see generate-pro.js).
+  if (isRecording()) {
+    const debug = result._debug || {};
+    // Anything the engine put on _debug beyond the canonical fields lands
+    // in engineDebug — useful for engine-specific reasoning (zettel strategy
+    // / composition / fragmentsUsed; instant patternName / strategy).
+    const { systemPrompt, rawLLMResponse, tokens, patterns, ...engineDebug } = debug;
+    recordTurn({
+      sessionId: previousExecId || result.executionId || null,
+      intent,
+      mode: effectiveMode,
+      engine: engineName,
+      model: model || null,
+      analysis,
+      currentCanvas: hasClientCanvas ? currentCanvas : null,
+      patterns: patterns || [],
+      systemPrompt: systemPrompt || null,
+      rawLLMResponse: rawLLMResponse || null,
+      messages: result.messages || [],
+      validation: result.validation || null,
+      drift: result.drift || null,
+      suggestions: result.suggestions || [],
+      timing: { totalMs },
+      tokens: tokens || null,
+      engineDebug: Object.keys(engineDebug).length ? engineDebug : null,
+      isIteration,
+    }).catch(() => { /* logger swallows internally; this is just last-resort */ });
+  }
+
+  // Strip the _debug payload before returning — it's an internal collaboration
+  // channel between engines and the recorder, not part of the public API.
+  // Without this strip the proxy would echo a 12KB+ system prompt to clients.
+  //
+  // Compose-trace flag: A2UI_COMPOSE_TRACE=<dir> writes the full debug payload
+  // (system prompt, raw LLM response, retrieval log, strategy decisions) to
+  // a per-request JSON file BEFORE the strip. Useful for debugging
+  // strategy-label decisions or reproducing eval failures. Off by default;
+  // file writes happen synchronously and add ~1-5ms per request.
+  //
+  // Node-only: `process` is undefined in the browser. Guard the env lookup
+  // so the post-await codepath doesn't throw `ReferenceError: process is
+  // not defined` when generator.js runs in the gen-ui playground. The
+  // dynamic node:fs/path imports below would also fail in the browser, but
+  // the guard short-circuits before we get there.
+  const IS_NODE = typeof process !== 'undefined' && process.versions?.node;
+  const traceDir = IS_NODE ? process.env.A2UI_COMPOSE_TRACE : null;
+  if (traceDir && result._debug) {
+    try {
+      const { writeFile, mkdir } = await import('node:fs/promises');
+      const { join: pathJoin } = await import('node:path');
+      await mkdir(traceDir, { recursive: true });
+      const ts = new Date().toISOString().replace(/[:.]/g, '-');
+      const safeIntent = String(intent || 'unknown').slice(0, 40).replace(/[^a-zA-Z0-9_-]/g, '_');
+      const tracePath = pathJoin(traceDir, `${ts}-${engineName}-${safeIntent}.json`);
+      await writeFile(tracePath, JSON.stringify({
+        timestamp: ts,
+        intent,
+        engine: engineName,
+        mode: effectiveMode,
+        executionId: result.executionId,
+        strategy: result.strategy || null,
+        validation: result.validation || null,
+        messageCount: result.messages?.length || 0,
+        debug: result._debug,
+      }, null, 2));
+    } catch (err) {
+      // Tracing is diagnostic — never let it break the request path.
+      console.error('[compose:trace] failed to write trace:', err.message);
+    }
+  }
+  if (result._debug) delete result._debug;
+  return result;
+}
+
+/**
+ * Streaming UI generation — yields progressive events as the LLM generates.
+ *
+ * Events:
+ *   { type: 'status', stage, message }          — pipeline stage transition
+ *   { type: 'clarify', questions, score, dimensions } — intent needs clarification (consumer should pause)
+ *   { type: 'text_delta', text, snapshot }       — raw LLM text chunk
+ *   { type: 'partial', messages }                — parseable partial A2UI (render immediately)
+ *   { type: 'complete', messages, validation, suggestions, executionId }  — final result
+ *   { type: 'error', error }                     — generation error
+ *
+ * @param {object} opts
+ * @param {string} opts.intent
+ * @param {string} [opts.executionId]
+ * @param {object} [opts.llmAdapter]
+ * @param {(query: string) => Promise<{ results: { title: string, snippet: string, url: string }[] }>} [opts.search] — Web search function
+ * @param {object} [opts.context] — Ontology context parsed by plan_app_state:
+ *   the four-block shape { intent, domain, tasks, experience } validated by
+ *   @adia-ai/mcp's gen-ui surface's ontologyContextSchema (REQ-03, gh#1208). Only
+ *   domain.entities, domain.metrics, tasks.primary, experience.mode, and
+ *   experience.shell are currently interpolated into the monolithic system
+ *   prompt (strategies/monolithic/_shared.js); intent.* and tasks.inspection
+ *   validate but are not yet read downstream (gh#1208 review finding 4/6).
+ * @yields {object}
+ */
+export async function* generateUIStream({ intent, executionId, llmAdapter, model, search, currentCanvas, context }) {
+  // currentCanvas accepted for API parity with generateUI. The streaming
+  // path's downstream consumers don't yet read it, but parity prevents the
+  // client from having to branch its call shape per mode. Tier-2 will
+  // wire it through the same way generatePro does.
+  void currentCanvas;
+  // ── Intent gate: reject non-UI prompts before entering the pipeline ──
+  // Same iteration bypass as generateUI() — modifiers don't need to clear the
+  // conversational gate when there's a prior turn to refine.
+  const isIteration = !!executionId;
+  if (!isIteration) {
+    const classification = classifyIntent(intent);
+    const intentCheck = isConversational(intent, classification);
+    if (intentCheck.conversational) {
+      const clarity = assessClarity(intent, classification);
+      yield {
+        type: 'clarify',
+        questions: clarity.questions.length > 0
+          ? clarity.questions
+          : [{ text: 'What would you like me to build?', dimension: 'domain', priority: 1 }],
+        score: clarity.score,
+        dimensions: clarity.dimensions,
+        summary: `Not a UI request (${intentCheck.reason}). ${clarity.summary}`,
+        rejected: true,
+        reason: intentCheck.reason,
+      };
+      return; // Do NOT continue to generation pipeline
+    }
+  }
+
+  const adapter = llmAdapter || await createAdapter({ model });
+  // For multi-turn: keep the old executionId for artifact history lookup,
+  // but always start a fresh pipeline execution for stage tracking.
+  const previousExecId = executionId;
+  executionId = engine.start({ intent, mode: 'stream', previousExecId });
+
+  // ── Stage 1: Interpret ──
+  // Include confidence + matched signals in the status message so a reader can
+  // distinguish a strong domain match from a 3% tie-breaker. The bare label
+  // "Domain: data" is indistinguishable between "build a data dashboard" (high
+  // confidence, many signals) and "tier pricing page" (0.03 confidence, one
+  // weak signal) — same text, very different reliability.
+  const domain = lookupDomain(intent);
+  engine.submitStage(executionId, 'interpret', { domain, intent, confidence: domain.confidence });
+  const conf = domain.confidence != null ? Math.round(domain.confidence * 100) : null;
+  const signals = Array.isArray(domain.matchedSignals) && domain.matchedSignals.length
+    ? domain.matchedSignals.slice(0, 4)
+    : null;
+  yield {
+    type: 'status',
+    stage: 'interpret',
+    message: `Domain: ${domain.domain}${conf != null ? ` (${conf}% confidence)` : ''}`,
+    outcomes: signals ? [`Matched signals: ${signals.join(', ')}`] : [],
+  };
+
+  // ── Clarity gate: yield clarify event if intent is vague ──
+  // Only for fresh intents (not multi-turn iterations which have prior context)
+  if (!previousExecId) {
+    const clarity = assessClarity(intent, domain);
+    if (!clarity.clear && clarity.questions.length > 0) {
+      yield {
+        type: 'clarify',
+        questions: clarity.questions,
+        score: clarity.score,
+        dimensions: clarity.dimensions,
+        summary: clarity.summary,
+      };
+      // The consumer decides whether to pause or continue.
+      // If they continue iterating, generation proceeds with what we have.
+      // If they stop iterating and re-submit with more detail, a new stream starts.
+    }
+  }
+
+  // ── Stage 2: Analyze ──
+  // Surface the actual top-N retrieval candidates with scores. Two reasons the
+  // previous `${...patterns.length} patterns` line was misleading:
+  //   (a) `getContext(intent, 2)` runs at tier=2, but the context-assembler
+  //       only populates `result.patterns` at tier≥3 — so `context.patterns`
+  //       was STRUCTURALLY empty. "0 patterns" wasn't a retrieval result; it
+  //       was a tier mismatch. Fixed by running a fast keyword search here.
+  //   (b) The synthesizer composes from below-threshold patterns too; "0
+  //       patterns" reading as "nothing relevant" actively misleads the user.
+  const catalogContext = await getContext(intent, 2);
+  const topPatternsRaw = searchBlocks(intent).slice(0, 5);
+  const candidateLines = topPatternsRaw.length
+    ? topPatternsRaw.map(p => {
+        const score = p.score != null ? ` · ${Number(p.score).toFixed(2)}` : '';
+        const domainTag = p.domain ? ` (${p.domain})` : '';
+        return `  • ${p.name}${domainTag}${score}`;
+      })
+    : ['  (no keyword match — synthesizer will compose from components)'];
+  engine.submitStage(executionId, 'analyze', {
+    context: catalogContext, componentCount: catalogContext.components.length, patternCount: topPatternsRaw.length,
+    topPatterns: topPatternsRaw.map(p => ({ name: p.name, score: p.score, domain: p.domain })),
+    confidence: catalogContext.components.length > 0 ? 0.85 : 0.5,
+  });
+  yield {
+    type: 'status',
+    stage: 'analyze',
+    message: `${catalogContext.components.length} components inspected · ${topPatternsRaw.length} pattern candidate${topPatternsRaw.length === 1 ? '' : 's'}`,
+    outcomes: ['Top retrievals:', ...candidateLines],
+  };
+
+  // ── Research: web search enrichment (optional) ──
+  let researchContext = '';
+  const { references } = detectReferences(intent);
+  if (references.length > 0 || search) {
+    yield { type: 'status', stage: 'research', message: references.length > 0 ? `Researching: ${references.join(', ')}` : 'Searching for patterns...' };
+    try {
+      const research = await researchIntent(intent, { search, llmAdapter: adapter });
+      researchContext = research.context;
+      if (research.references.length > 0) {
+        yield { type: 'research', references: research.references, insights: research.insights };
+      }
+    } catch {
+      // Research failed — continue without it
+    }
+  }
+
+  // ── Stage 3: Plan ──
+  // Use semantic search in LLM modes — feeds pattern index to LLM for conceptual matching
+  const { matches: patterns, remix: remixSuggestion } = await searchBlocksSemantic(intent, { llmAdapter: adapter, remix: true });
+  engine.submitStage(executionId, 'plan', {
+    patterns: patterns.map(p => p.name),
+    strategy: patterns.length > 0 ? 'adapt-pattern' : 'generate-fresh',
+    confidence: patterns.length > 0 ? 0.9 : 0.7,
+    hasRemix: !!remixSuggestion,
+  });
+  yield { type: 'status', stage: 'plan', message: patterns.length > 0 ? `Adapting: ${patterns[0].name}${remixSuggestion ? ' (with remix)' : ''}` : 'Generating fresh' };
+
+  // ── Decomposition: split complex intents into subtasks ──
+  // Skip decomposition when a pattern match exists — the pattern already handles composition
+  const decomposition = patterns.length === 0 ? decomposeIntent(intent) : { shouldDecompose: false, subtasks: [], layout: null, original: intent };
+  if (decomposition.shouldDecompose && decomposition.subtasks.length >= 3) {
+    yield { type: 'status', stage: 'decompose', message: `Splitting into ${decomposition.subtasks.length} subtasks: ${decomposition.subtasks.map(s => s.label).join(', ')}` };
+    yield { type: 'decompose', subtasks: decomposition.subtasks, layout: decomposition.layout };
+
+    // Generate each subtask independently
+    const subtaskResults = [];
+    for (const subtask of decomposition.subtasks) {
+      yield { type: 'status', stage: 'generate', message: `Generating: ${subtask.label}...` };
+      try {
+        const subResult = await adapter.complete({
+          messages: [{ role: 'user', content: subtask.intent }],
+          systemPrompt: await buildSystemPrompt(catalogContext, patterns, researchContext, intent, null, context),
+        });
+        const subMessages = parseA2UIResponse(subResult.content, { executionId, mode: 'stream', intent: subtask.intent });
+        subtaskResults.push({ label: subtask.label, messages: subMessages });
+      } catch {
+        // Failed subtask — skip it
+        subtaskResults.push({ label: subtask.label, messages: [{ type: 'updateComponents', surfaceId: 'default', components: [{ id: 'root', component: 'Text', variant: 'body', textContent: `${subtask.label} (generation failed)` }] }] });
+      }
+    }
+
+    // Compose into layout
+    const composed = composeSubtasks(decomposition.layout, subtaskResults);
+
+    engine.submitStage(executionId, 'generate', {
+      messages: composed, source: 'decomposed', decomposed: true,
+      subtasks: decomposition.subtasks.length, confidence: 0.8,
+    });
+
+    const composedValidation = validateSchema(composed, { intent, context });
+
+    engine.submitStage(executionId, 'validate', {
+      ...composedValidation, confidence: composedValidation.score / 100,
+    });
+
+    // Alignment check
+    const alignment = checkIntentAlignment(intent, composed[0]?.components || []);
+
+    const storeId = previousExecId || executionId;
+    store.record(storeId, { messages: composed, summary: intent, validation: composedValidation, intent });
+    engine.submitStage(executionId, 'render', { stored: true, decomposed: true, subtasks: decomposition.subtasks.length });
+
+    // Fire-and-forget feedback logging (decomposed stream)
+    feedbackStore.logExecution({
+      executionId: storeId, intent, mode: 'stream',
+      domain: domain.domain, patternMatch: null,
+      score: composedValidation?.score, componentCount: composed[0]?.components?.length || 0,
+    }).catch(() => {});
+
+    yield {
+      type: 'complete',
+      executionId: storeId,
+      messages: composed,
+      validation: composedValidation,
+      alignment,
+      suggestions: generateSuggestions(intent, domain, composed),
+      pipeline: engine.getState(executionId),
+    };
+    return;
+  }
+
+  // ── Stage 4: Generate via LLM stream ──
+  const systemPrompt = await buildSystemPrompt(catalogContext, patterns, researchContext, intent, null, context);
+  const chatMessages = buildChatMessages(intent, previousExecId || executionId);
+
+  yield { type: 'status', stage: 'generate', message: 'Streaming from LLM...' };
+
+  let fullText = '';
+  let lastPartialRender = '';
+
+  try {
+    if (typeof adapter.stream === 'function') {
+      for await (const chunk of adapter.stream({ messages: chatMessages, systemPrompt })) {
+        if (chunk.type === 'text') {
+          fullText += chunk.content;
+          yield { type: 'text_delta', text: chunk.content, snapshot: fullText };
+
+          // Try to parse partial JSON and render incrementally
+          const partial = tryParsePartial(fullText);
+          if (partial && JSON.stringify(partial) !== lastPartialRender) {
+            lastPartialRender = JSON.stringify(partial);
+            yield { type: 'partial', messages: partial };
+          }
+        }
+      }
+    } else {
+      // Fallback: non-streaming adapter
+      const response = await adapter.complete({ messages: chatMessages, systemPrompt });
+      fullText = response.content;
+      yield { type: 'text_delta', text: fullText, snapshot: fullText };
+    }
+  } catch (err) {
+    yield { type: 'error', error: err };
+    return;
+  }
+
+  // ── Stage 5: Parse final + validate ──
+  let messages = parseA2UIResponse(fullText, { executionId, mode: 'stream', intent });
+  engine.submitStage(executionId, 'generate', {
+    messages, source: 'llm-stream', confidence: 0.8,
+  });
+
+  // gh#583 (GK-3): this used to be a hand-rolled ONE-shot repair calling
+  // `adapter.complete()` directly and re-running only `validateSchema` — it
+  // never ran the catalog check, so a schema-valid-but-catalog-invalid
+  // candidate (unknown component, prop the YAML contract doesn't declare)
+  // could reach the wire from this streaming path alone, unlike every other
+  // engine (see validate-and-repair.js's docstring: this generator was the
+  // only one skipping it). Routing through the shared loop closes that gap
+  // and gets the same bounded multi-attempt retry every other LLM-calling
+  // engine already has, instead of exactly one attempt.
+  const repairResult = await validateAndRepair({
+    messages,
+    llmAdapter: adapter,
+    buildRepairPrompt,
+    parseResponse: (repairResponse) => parseA2UIResponse(
+      repairResponse.content,
+      { executionId, mode: 'stream', intent },
+    ),
+    systemPrompt,
+    validateContext: { intent, context },
+    foldInAntiPatterns,
+    maxAttempts: 3,
+    onAttempt: () => {
+      // No dialog-recorder hook here (unlike generate-thinking.js) — the
+      // streaming path already emits its own `text_delta`/`partial` events
+      // as the primary trace surface; adding a second capture point would
+      // duplicate, not improve, that record.
+    },
+  });
+  messages = repairResult.messages;
+  let validation = repairResult.validation;
+  if (repairResult.attempts > 0) {
+    yield { type: 'status', stage: 'validate', message: `Score ${validation.score}/100 — repaired in ${repairResult.attempts} attempt(s)` };
+  }
+
+  engine.submitStage(executionId, 'validate', {
+    ...validation, confidence: validation.score / 100,
+  });
+
+  // ── Stage 6: Store artifact ──
+  // Store under the previous execution ID if iterating (keeps multi-turn history together)
+  const storeId = previousExecId || executionId;
+  store.record(storeId, { messages, summary: intent, validation, intent });
+  engine.submitStage(executionId, 'render', { stored: true, success: validation.valid, confidence: validation.valid ? 1 : 0.5 });
+
+  // ── Intent alignment check ──
+  const alignment = checkIntentAlignment(intent, messages[0]?.components || []);
+
+  const suggestions = generateSuggestions(intent, domain, messages);
+
+  // Fire-and-forget feedback logging (stream mode)
+  feedbackStore.logExecution({
+    executionId: storeId, intent, mode: 'stream',
+    domain: domain.domain, patternMatch: patterns[0]?.name,
+    score: validation?.score, componentCount: messages[0]?.components?.length || 0,
+  }).catch(() => {});
+
+  // ── Drift detection ──
+  const driftMetrics = store.getDriftMetrics(storeId);
+
+  yield {
+    type: 'complete',
+    executionId: storeId,
+    messages,
+    validation,
+    alignment,
+    drift: driftMetrics,
+    suggestions,
+    pipeline: engine.getState(executionId),
+  };
+}
+
+// ── Pro mode (pattern-aware LLM adaptation) ─────────────────────────
+
+
+// ═══════════════════════════════════════════════════════════════════════
+// SYSTEM PROMPT (Feature 2: improved with card-ui rules)
+// ═══════════════════════════════════════════════════════════════════════
+
+/**
+ * Build a concise system prompt for the LLM with component catalog,
+ * card-ui content model, layout rules, and example patterns.
+ *
+ * @param {object} context — Assembled context from A003
+ * @param {object[]} patterns — Matched patterns from pattern library
+ * @returns {string}
+ */
+
+/**
+ * Get the shared artifact store (for external inspection).
+ * @returns {ArtifactStore}
+ */
+export function getArtifactStore() {
+  return store;
+}
+
+/**
+ * Get the shared pipeline engine (for external inspection).
+ * @returns {PipelineEngine}
+ */
+export function getPipelineEngine() {
+  return engine;
+}
+
+// ── Register the three monolithic engines with the dispatcher ──
+// Done at module load so the registry is ready before the first generateUI() call.
+registerMonolithicEngines({
+  instant: generateInstant,
+  pro: generatePro,
+  thinking: generateThinking,
+});