@tangle-network/starter-foundry 0.7.2 → 0.13.0

package/dist/lib/planner/projects.js

@@ -6,14 +6,22 @@
 // lives here since the choice is a project-builder concern). Contract-lane
 // builders live in ./contracts.ts alongside the agent-family selection.
 import { detectCapabilities, detectLane, hasAny } from '../keywords.js';
-import { detectAuthSlot, detectDatabaseSlot, detectEvmSupportApiPattern, detectPaymentsSlot, detectQueueSlot, detectSdkSlot, } from './detectors.js';
 import { chooseAgentFamily } from './contracts.js';
+import { detectAuthSlot, detectDatabaseSlot, detectEvmSupportApiPattern, detectPaymentsSlot, detectQueueSlot, detectSdkSlot, } from './detectors.js';
+import { hasEvmDomainPackSupportApiSurface } from './domain-pack-signals.js';
 import { buildSlug, resolvePartnerForFamily } from './helpers.js';
 import { inferImplicitCapabilities } from './implicit-caps.js';
 export function buildWebProject(prompt, partner, text, registry) {
     // WASM-Rust fronts take precedence over React/Next when the prompt
     // specifically asks for Rust-in-browser compute.
-    if (hasAny(text, ['wasm-bindgen', 'wasm-pack', 'rust wasm', 'rust in browser', 'webassembly rust', 'browser wasm'])) {
+    if (hasAny(text, [
+        'wasm-bindgen',
+        'wasm-pack',
+        'rust wasm',
+        'rust in browser',
+        'webassembly rust',
+        'browser wasm',
+    ])) {
         return {
             id: 'web',
             path: 'apps/web',
@@ -32,7 +40,14 @@ export function buildWebProject(prompt, partner, text, registry) {
         };
     }
     // Three.js 3D scene / WebGL game surfaces.
-    if (hasAny(text, ['three.js', 'threejs', 'webgl 3d scene', '3d model viewer', 'gltf viewer', '3d scene editor'])) {
+    if (hasAny(text, [
+        'three.js',
+        'threejs',
+        'webgl 3d scene',
+        '3d model viewer',
+        'gltf viewer',
+        '3d scene editor',
+    ])) {
         return {
             id: 'web',
             path: 'apps/web',
@@ -92,107 +107,165 @@ export function buildWebProject(prompt, partner, text, registry) {
     // so "eleventy blog" etc. don't fall through to react-vite-ts.
     if (hasAny(text, ['eleventy', '11ty', '@11ty', 'nunjucks layout'])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'eleventy-static', layers: ['framework:eleventy-static'],
+                family: 'eleventy-static',
+                layers: ['framework:eleventy-static'],
                 partner: resolvePartnerForFamily(partner, 'eleventy-static'),
                 slots: {},
-                variables: { headline: 'Content in minutes with 11ty', subheadline: 'Eleventy + Nunjucks layouts, no client JS by default.' },
+                variables: {
+                    headline: 'Content in minutes with 11ty',
+                    subheadline: 'Eleventy + Nunjucks layouts, no client JS by default.',
+                },
                 primaryArtifactTargetMs: 2500,
             },
         };
     }
     if (hasAny(text, ['hugo site', 'hugo static', 'hugo blog', 'hugo layout'])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'hugo-static', layers: ['framework:hugo-static'],
+                family: 'hugo-static',
+                layers: ['framework:hugo-static'],
                 partner: resolvePartnerForFamily(partner, 'hugo-static'),
                 slots: {},
-                variables: { headline: 'Hugo — fast, binary-driven static sites', subheadline: 'Go-based SSG with Tera templates and sub-second builds.' },
+                variables: {
+                    headline: 'Hugo — fast, binary-driven static sites',
+                    subheadline: 'Go-based SSG with Tera templates and sub-second builds.',
+                },
                 primaryArtifactTargetMs: 2500,
             },
         };
     }
     if (hasAny(text, ['zola', 'zola site', 'zola static', 'tera template'])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'zola-static', layers: ['framework:zola-static'],
+                family: 'zola-static',
+                layers: ['framework:zola-static'],
                 partner: resolvePartnerForFamily(partner, 'zola-static'),
                 slots: {},
-                variables: { headline: 'Zola — Rust-native SSG', subheadline: 'Single-binary static site generator with built-in SASS.' },
+                variables: {
+                    headline: 'Zola — Rust-native SSG',
+                    subheadline: 'Single-binary static site generator with built-in SASS.',
+                },
                 primaryArtifactTargetMs: 2500,
             },
         };
     }
     if (hasAny(text, ['jupyter book', 'jupyterbook', 'myst-nb', 'executable book'])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'jupyter-book', layers: ['framework:jupyter-book'],
+                family: 'jupyter-book',
+                layers: ['framework:jupyter-book'],
                 partner: resolvePartnerForFamily(partner, 'jupyter-book'),
                 slots: {},
-                variables: { headline: 'Executable book', subheadline: 'Jupyter Book with MyST code cells.' },
+                variables: {
+                    headline: 'Executable book',
+                    subheadline: 'Jupyter Book with MyST code cells.',
+                },
                 primaryArtifactTargetMs: 3500,
             },
         };
     }
     if (hasAny(text, ['observable framework', 'observable notebook', 'observablehq', 'observable plot'])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'observable-notebook', layers: ['framework:observable-notebook'],
+                family: 'observable-notebook',
+                layers: ['framework:observable-notebook'],
                 partner: resolvePartnerForFamily(partner, 'observable-notebook'),
                 slots: {},
-                variables: { headline: 'Data stories with Observable', subheadline: 'Observable Framework + Plot charts, Markdown-first.' },
+                variables: {
+                    headline: 'Data stories with Observable',
+                    subheadline: 'Observable Framework + Plot charts, Markdown-first.',
+                },
                 primaryArtifactTargetMs: 3000,
             },
         };
     }
     // Specialized Streamlit (multipage + caching) must come BEFORE python-data-app
     // so "streamlit multipage" prompts don't fall through to the generic one.
-    if (hasAny(text, ['streamlit multipage', 'multipage streamlit', 'production streamlit', 'streamlit dashboard app'])) {
+    if (hasAny(text, [
+        'streamlit multipage',
+        'multipage streamlit',
+        'production streamlit',
+        'streamlit dashboard app',
+    ])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'streamlit-advanced', layers: ['framework:streamlit-advanced'],
+                family: 'streamlit-advanced',
+                layers: ['framework:streamlit-advanced'],
                 partner: resolvePartnerForFamily(partner, 'streamlit-advanced'),
                 slots: {},
-                variables: { headline: 'Production Streamlit', subheadline: 'Multipage + caching + Plotly.' },
+                variables: {
+                    headline: 'Production Streamlit',
+                    subheadline: 'Multipage + caching + Plotly.',
+                },
                 primaryArtifactTargetMs: 3500,
             },
         };
     }
     // WebGPU compute vs render (both beat generic React path).
-    if (hasAny(text, ['webgpu compute', 'webgpu inference', 'wgsl compute', 'browser ml', 'transformers.js'])) {
+    if (hasAny(text, [
+        'webgpu compute',
+        'webgpu inference',
+        'wgsl compute',
+        'browser ml',
+        'transformers.js',
+    ])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'webgpu-inference', layers: ['framework:webgpu-inference'],
+                family: 'webgpu-inference',
+                layers: ['framework:webgpu-inference'],
                 partner: resolvePartnerForFamily(partner, 'webgpu-inference'),
                 slots: {},
-                variables: { headline: 'GPU compute in the browser', subheadline: 'Raw WebGPU matmul on Float32 buffers.' },
+                variables: {
+                    headline: 'GPU compute in the browser',
+                    subheadline: 'Raw WebGPU matmul on Float32 buffers.',
+                },
                 primaryArtifactTargetMs: 3000,
             },
         };
     }
-    if (hasAny(text, ['webgpu rendering', 'raw webgpu', 'wgsl graphics', 'wgsl vertex', 'low-level gpu graphics', 'webgpu triangle'])) {
+    if (hasAny(text, [
+        'webgpu rendering',
+        'raw webgpu',
+        'wgsl graphics',
+        'wgsl vertex',
+        'low-level gpu graphics',
+        'webgpu triangle',
+    ])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'webgpu-render', layers: ['framework:webgpu-render'],
+                family: 'webgpu-render',
+                layers: ['framework:webgpu-render'],
                 partner: resolvePartnerForFamily(partner, 'webgpu-render'),
                 slots: {},
-                variables: { headline: 'Raw WebGPU renderer', subheadline: 'WGSL vertex + fragment, no three.js.' },
+                variables: {
+                    headline: 'Raw WebGPU renderer',
+                    subheadline: 'WGSL vertex + fragment, no three.js.',
+                },
                 primaryArtifactTargetMs: 3000,
             },
         };
@@ -200,39 +273,54 @@ export function buildWebProject(prompt, partner, text, registry) {
     // Bevy / Godot / Unity web targets.
     if (hasAny(text, ['bevy', 'bevy web', 'rust web game', 'wasm game engine'])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'bevy-web', layers: ['framework:bevy-web'],
+                family: 'bevy-web',
+                layers: ['framework:bevy-web'],
                 partner: resolvePartnerForFamily(partner, 'bevy-web'),
                 slots: {},
-                variables: { headline: 'Bevy + Trunk', subheadline: 'Rust game engine compiled to WASM for the browser.' },
+                variables: {
+                    headline: 'Bevy + Trunk',
+                    subheadline: 'Rust game engine compiled to WASM for the browser.',
+                },
                 primaryArtifactTargetMs: 4000,
             },
         };
     }
     if (hasAny(text, ['godot', 'godot web', 'godot html5', 'godot 4', 'gdscript'])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'godot-web', layers: ['framework:godot-web'],
+                family: 'godot-web',
+                layers: ['framework:godot-web'],
                 partner: resolvePartnerForFamily(partner, 'godot-web'),
                 slots: {},
-                variables: { headline: 'Godot 4 on the web', subheadline: 'HTML5 export with COOP/COEP headers wired.' },
+                variables: {
+                    headline: 'Godot 4 on the web',
+                    subheadline: 'HTML5 export with COOP/COEP headers wired.',
+                },
                 primaryArtifactTargetMs: 4000,
             },
         };
     }
     if (hasAny(text, ['unity webgl', 'unity web build', 'unity batch mode', 'unity html5'])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'unity-web-proxy', layers: ['framework:unity-web-proxy'],
+                family: 'unity-web-proxy',
+                layers: ['framework:unity-web-proxy'],
                 partner: resolvePartnerForFamily(partner, 'unity-web-proxy'),
                 slots: {},
-                variables: { headline: 'Unity WebGL host', subheadline: 'Serving shell + batch-mode build scripts.' },
+                variables: {
+                    headline: 'Unity WebGL host',
+                    subheadline: 'Serving shell + batch-mode build scripts.',
+                },
                 primaryArtifactTargetMs: 4000,
             },
         };
@@ -240,15 +328,28 @@ export function buildWebProject(prompt, partner, text, registry) {
     // Rich mobile (Expo + Skia + Reanimated) must come BEFORE the plain
     // expo-react-native-ts route — tier1 keywords on expo-rn-rich are
     // Skia/Reanimated/gesture-specific.
-    if (hasAny(text, ['skia', 'react native skia', 'reanimated', 'rich animations mobile', 'native gestures mobile', 'expo skia', 'expo reanimated'])) {
+    if (hasAny(text, [
+        'skia',
+        'react native skia',
+        'reanimated',
+        'rich animations mobile',
+        'native gestures mobile',
+        'expo skia',
+        'expo reanimated',
+    ])) {
         return {
-            id: 'web', path: 'apps/mobile',
+            id: 'web',
+            path: 'apps/mobile',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-mobile`,
-                family: 'expo-rn-rich', layers: ['framework:expo-rn-rich'],
+                family: 'expo-rn-rich',
+                layers: ['framework:expo-rn-rich'],
                 partner: resolvePartnerForFamily(partner, 'expo-rn-rich'),
                 slots: {},
-                variables: { headline: 'Mobile app with Skia + Reanimated', subheadline: 'Rich GPU animations + gestures from frame 1.' },
+                variables: {
+                    headline: 'Mobile app with Skia + Reanimated',
+                    subheadline: 'Rich GPU animations + gestures from frame 1.',
+                },
                 primaryArtifactTargetMs: 3500,
             },
         };
@@ -256,94 +357,167 @@ export function buildWebProject(prompt, partner, text, registry) {
     // Tauri variants — menubar (popover) and tray (daemon) must come BEFORE
     // generic tauri-desktop. Electron native-OS variant must come BEFORE
     // plain electron-desktop-ts.
-    if (hasAny(text, ['menu bar app', 'macos menubar', 'floating panel app', 'raycast-like', 'menubar popover'])) {
+    if (hasAny(text, [
+        'menu bar app',
+        'macos menubar',
+        'floating panel app',
+        'raycast-like',
+        'menubar popover',
+    ])) {
         return {
-            id: 'web', path: 'apps/desktop',
+            id: 'web',
+            path: 'apps/desktop',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-desktop`,
-                family: 'tauri-menubar', layers: ['framework:tauri-menubar'],
+                family: 'tauri-menubar',
+                layers: ['framework:tauri-menubar'],
                 partner: resolvePartnerForFamily(partner, 'tauri-menubar'),
                 slots: {},
-                variables: { headline: 'A compact panel in the menu bar', subheadline: 'Tauri popover tuned for Raycast-like flows.' },
+                variables: {
+                    headline: 'A compact panel in the menu bar',
+                    subheadline: 'Tauri popover tuned for Raycast-like flows.',
+                },
                 primaryArtifactTargetMs: 3500,
             },
         };
     }
-    if (hasAny(text, ['system tray app', 'tray icon only', 'background daemon', 'tauri tray', 'tray daemon'])) {
+    if (hasAny(text, [
+        'system tray app',
+        'tray icon only',
+        'background daemon',
+        'tauri tray',
+        'tray daemon',
+    ])) {
         return {
-            id: 'web', path: 'apps/desktop',
+            id: 'web',
+            path: 'apps/desktop',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-desktop`,
-                family: 'tauri-tray', layers: ['framework:tauri-tray'],
+                family: 'tauri-tray',
+                layers: ['framework:tauri-tray'],
                 partner: resolvePartnerForFamily(partner, 'tauri-tray'),
                 slots: {},
-                variables: { headline: 'Tray-only daemon', subheadline: 'No primary window — icon + menu + notifications.' },
+                variables: {
+                    headline: 'Tray-only daemon',
+                    subheadline: 'No primary window — icon + menu + notifications.',
+                },
                 primaryArtifactTargetMs: 3500,
             },
         };
     }
-    if (hasAny(text, ['native os integration', 'custom protocol handler', 'deep links desktop', 'os notifications desktop', 'auto updater electron', 'electron native'])) {
+    if (hasAny(text, [
+        'native os integration',
+        'custom protocol handler',
+        'deep links desktop',
+        'os notifications desktop',
+        'auto updater electron',
+        'electron native',
+    ])) {
         return {
-            id: 'web', path: 'apps/desktop',
+            id: 'web',
+            path: 'apps/desktop',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-desktop`,
-                family: 'electron-native-os', layers: ['framework:electron-native-os'],
+                family: 'electron-native-os',
+                layers: ['framework:electron-native-os'],
                 partner: resolvePartnerForFamily(partner, 'electron-native-os'),
                 slots: {},
-                variables: { headline: 'Native OS integrations in Electron', subheadline: 'Menus, protocols, deep links, auto-update.' },
+                variables: {
+                    headline: 'Native OS integrations in Electron',
+                    subheadline: 'Menus, protocols, deep links, auto-update.',
+                },
                 primaryArtifactTargetMs: 3500,
             },
         };
     }
     // A/V + modality frontends.
-    if (hasAny(text, ['voice agent', 'voice first', 'conversational voice', 'speech to text agent', 'browser mic agent'])) {
+    if (hasAny(text, [
+        'voice agent',
+        'voice first',
+        'conversational voice',
+        'speech to text agent',
+        'browser mic agent',
+    ])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'voice-first-agent', layers: ['framework:voice-first-agent'],
+                family: 'voice-first-agent',
+                layers: ['framework:voice-first-agent'],
                 partner: resolvePartnerForFamily(partner, 'voice-first-agent'),
                 slots: {},
-                variables: { headline: 'Talk to the product', subheadline: 'Browser mic → STT → LLM → TTS loop.' },
+                variables: {
+                    headline: 'Talk to the product',
+                    subheadline: 'Browser mic → STT → LLM → TTS loop.',
+                },
                 primaryArtifactTargetMs: 3000,
             },
         };
     }
     if (hasAny(text, ['vision agent', 'camera agent', 'visual qa', 'screen understanding', 'ocr agent'])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'vision-first-agent', layers: ['framework:vision-first-agent'],
+                family: 'vision-first-agent',
+                layers: ['framework:vision-first-agent'],
                 partner: resolvePartnerForFamily(partner, 'vision-first-agent'),
                 slots: {},
-                variables: { headline: 'See what the user sees', subheadline: 'Camera → multimodal LLM → overlay.' },
+                variables: {
+                    headline: 'See what the user sees',
+                    subheadline: 'Camera → multimodal LLM → overlay.',
+                },
                 primaryArtifactTargetMs: 3000,
             },
         };
     }
-    if (hasAny(text, ['multimodal agent', 'multimodal input', 'text image audio', 'gpt-4o client', 'claude vision voice', 'multimodal chat'])) {
+    if (hasAny(text, [
+        'multimodal agent',
+        'multimodal input',
+        'text image audio',
+        'gpt-4o client',
+        'claude vision voice',
+        'multimodal chat',
+    ])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'multimodal-agent', layers: ['framework:multimodal-agent'],
+                family: 'multimodal-agent',
+                layers: ['framework:multimodal-agent'],
                 partner: resolvePartnerForFamily(partner, 'multimodal-agent'),
                 slots: {},
-                variables: { headline: 'Text + image + audio, one pane', subheadline: 'Unified multipart POST to a multimodal endpoint.' },
+                variables: {
+                    headline: 'Text + image + audio, one pane',
+                    subheadline: 'Unified multipart POST to a multimodal endpoint.',
+                },
                 primaryArtifactTargetMs: 3000,
             },
         };
     }
-    if (hasAny(text, ['realtime audio', 'webaudio visualiz', 'webaudio analyser', 'peer audio', 'webrtc audio'])) {
+    if (hasAny(text, [
+        'realtime audio',
+        'webaudio visualiz',
+        'webaudio analyser',
+        'peer audio',
+        'webrtc audio',
+    ])) {
         return {
-            id: 'web', path: 'apps/web',
+            id: 'web',
+            path: 'apps/web',
             spec: {
                 projectName: `${buildSlug(prompt, 'workspace')}-web`,
-                family: 'realtime-audio-ts', layers: ['framework:realtime-audio-ts'],
+                family: 'realtime-audio-ts',
+                layers: ['framework:realtime-audio-ts'],
                 partner: resolvePartnerForFamily(partner, 'realtime-audio-ts'),
                 slots: {},
-                variables: { headline: 'Live audio on canvas', subheadline: 'WebAudio + analyser + WebRTC peer seam.' },
+                variables: {
+                    headline: 'Live audio on canvas',
+                    subheadline: 'WebAudio + analyser + WebRTC peer seam.',
+                },
                 primaryArtifactTargetMs: 3000,
             },
         };
@@ -379,11 +553,11 @@ export function buildWebProject(prompt, partner, text, registry) {
     const authSlot = detectAuthSlot(text);
     const paymentsSlot = detectPaymentsSlot(text);
     if (authSlot)
-        slots['auth'] = authSlot;
+        slots.auth = authSlot;
     if (paymentsSlot)
-        slots['payments'] = paymentsSlot;
+        slots.payments = paymentsSlot;
     if (sdkSlot)
-        slots['sdk'] = sdkSlot;
+        slots.sdk = sdkSlot;
     const webCapabilities = registry ? detectCapabilities(text, family, registry) : [];
     if (webCapabilities.length > 0)
         layers.push(...webCapabilities);
@@ -417,15 +591,27 @@ export function buildWebProject(prompt, partner, text, registry) {
 }
 function chooseWorkerFamily(text) {
     if (hasAny(text, ['playwright', 'browser automation', 'web scraping', 'scraper', 'crawler'])) {
-        return { family: 'playwright-worker', layers: ['framework:playwright-worker'], path: 'apps/worker' };
+        return {
+            family: 'playwright-worker',
+            layers: ['framework:playwright-worker'],
+            path: 'apps/worker',
+        };
     }
     if (hasAny(text, ['go worker', 'golang worker', 'go cron', 'go queue', 'go background job'])) {
         return { family: 'go-worker', layers: ['framework:go-worker'], path: 'apps/worker' };
     }
-    if (hasAny(text, ['python worker', 'python cron', 'python queue', 'python background job', 'celery', 'python task'])) {
+    if (hasAny(text, [
+        'python worker',
+        'python cron',
+        'python queue',
+        'python background job',
+        'celery',
+        'python task',
+    ])) {
         return { family: 'python-worker', layers: ['framework:python-worker'], path: 'apps/worker' };
     }
-    if (detectLane(text, 'agent') && hasAny(text, ['worker', 'background', 'cron', 'queue', 'runner', 'executor'])) {
+    if (detectLane(text, 'agent') &&
+        hasAny(text, ['worker', 'background', 'cron', 'queue', 'runner', 'executor'])) {
         return { family: 'worker-job', layers: ['framework:node-worker'], path: 'apps/worker' };
     }
     const layers = ['framework:node-worker'];
@@ -434,7 +620,7 @@ function chooseWorkerFamily(text) {
     }
     return { family: 'worker-job', layers, path: 'apps/worker' };
 }
-export function chooseApiFamily(text) {
+export function chooseApiFamily(text, options = {}) {
     if (detectLane(text, 'x402'))
         return { family: 'x402-service', layers: ['framework:x402-service'], path: 'apps/api' };
     if (detectLane(text, 'mcp'))
@@ -443,8 +629,19 @@ export function chooseApiFamily(text) {
         return { family: 'dspy-pipeline-py', layers: ['framework:dspy-pipeline-py'], path: 'apps/ai' };
     // RAG pipeline (Python) — must come BEFORE vllm-server + python-api because
     // "Python RAG pipeline with Chroma and sentence-transformers" is more specific.
-    if (hasAny(text, ['rag pipeline', 'retrieval augmented', 'chroma vector', 'sentence-transformers', 'semantic retrieval', 'rag chroma'])) {
-        return { family: 'rag-pipeline-py', layers: ['framework:rag-pipeline-py'], path: 'apps/inference' };
+    if (hasAny(text, [
+        'rag pipeline',
+        'retrieval augmented',
+        'chroma vector',
+        'sentence-transformers',
+        'semantic retrieval',
+        'rag chroma',
+    ])) {
+        return {
+            family: 'rag-pipeline-py',
+            layers: ['framework:rag-pipeline-py'],
+            path: 'apps/inference',
+        };
     }
     // Inference-serving variants that must beat vllm-server's generic terms.
     if (hasAny(text, ['tgi', 'text generation inference', 'huggingface tgi', 'hf inference server'])) {
@@ -457,48 +654,148 @@ export function chooseApiFamily(text) {
         return { family: 'triton-server', layers: ['framework:triton-server'], path: 'apps/inference' };
     }
     if (hasAny(text, ['skypilot', 'sky serve', 'multi-cloud llm', 'spot inference', 'sky.yaml'])) {
-        return { family: 'skypilot-serving', layers: ['framework:skypilot-serving'], path: 'apps/inference' };
+        return {
+            family: 'skypilot-serving',
+            layers: ['framework:skypilot-serving'],
+            path: 'apps/inference',
+        };
     }
-    if (hasAny(text, ['lora fine-tune', 'lora training', 'qlora', 'peft adapter', 'fine-tune llm', 'sft training'])) {
+    if (hasAny(text, [
+        'lora fine-tune',
+        'lora training',
+        'qlora',
+        'peft adapter',
+        'fine-tune llm',
+        'sft training',
+    ])) {
         return { family: 'lora-training', layers: ['framework:lora-training'], path: 'apps/inference' };
     }
     // Media / realtime infrastructure.
-    if (hasAny(text, ['livekit sfu', 'self-hosted livekit', 'selective forwarding unit', 'webrtc sfu', 'livekit server self-hosted'])) {
+    if (hasAny(text, [
+        'livekit sfu',
+        'self-hosted livekit',
+        'selective forwarding unit',
+        'webrtc sfu',
+        'livekit server self-hosted',
+    ])) {
         return { family: 'livekit-sfu', layers: ['framework:livekit-sfu'], path: 'apps/api' };
     }
-    if (hasAny(text, ['hls origin', 'rtmp ingest', 'm3u8 origin', 'hls live streaming', 'live streaming origin'])) {
+    if (hasAny(text, [
+        'hls origin',
+        'rtmp ingest',
+        'm3u8 origin',
+        'hls live streaming',
+        'live streaming origin',
+    ])) {
         return { family: 'hls-origin', layers: ['framework:hls-origin'], path: 'apps/api' };
     }
     // Chain-specific families.
-    if (hasAny(text, ['celestia', 'data availability node', 'blobstream', 'celestia light node', 'celestia blob'])) {
+    if (hasAny(text, [
+        'celestia',
+        'data availability node',
+        'blobstream',
+        'celestia light node',
+        'celestia blob',
+    ])) {
         return { family: 'celestia-da', layers: ['framework:celestia-da'], path: 'apps/api' };
     }
     // Industry-vertical APIs — opinionated schemas.
-    if (hasAny(text, ['hipaa', 'phi audit', 'patient records', 'healthcare backend', 'healthcare compliance', 'medical records'])) {
-        return { family: 'healthcare-hipaa-backend', layers: ['framework:healthcare-hipaa-backend'], path: 'apps/api' };
+    if (hasAny(text, [
+        'hipaa',
+        'phi audit',
+        'patient records',
+        'healthcare backend',
+        'healthcare compliance',
+        'medical records',
+    ])) {
+        return {
+            family: 'healthcare-hipaa-backend',
+            layers: ['framework:healthcare-hipaa-backend'],
+            path: 'apps/api',
+        };
     }
-    if (hasAny(text, ['double entry', 'double-entry', 'ledger backend', 'fintech accounting', 'debit credit', 'financial ledger'])) {
-        return { family: 'fintech-ledger-backend', layers: ['framework:fintech-ledger-backend'], path: 'apps/api' };
+    if (hasAny(text, [
+        'double entry',
+        'double-entry',
+        'ledger backend',
+        'fintech accounting',
+        'debit credit',
+        'financial ledger',
+    ])) {
+        return {
+            family: 'fintech-ledger-backend',
+            layers: ['framework:fintech-ledger-backend'],
+            path: 'apps/api',
+        };
     }
-    if (hasAny(text, ['legal case', 'case management', 'matter management', 'law practice', 'attorney timekeeping', 'legal billing'])) {
+    if (hasAny(text, [
+        'legal case',
+        'case management',
+        'matter management',
+        'law practice',
+        'attorney timekeeping',
+        'legal billing',
+    ])) {
         return { family: 'legal-case-mgmt', layers: ['framework:legal-case-mgmt'], path: 'apps/api' };
     }
-    if (hasAny(text, ['k-12', 'k12', 'edtech', 'classroom management', 'gradebook', 'student information system'])) {
+    if (hasAny(text, [
+        'k-12',
+        'k12',
+        'edtech',
+        'classroom management',
+        'gradebook',
+        'student information system',
+    ])) {
         return { family: 'k12-edtech', layers: ['framework:k12-edtech'], path: 'apps/api' };
     }
-    if (hasAny(text, ['crm backend', 'sales pipeline', 'sales crm', 'customer relationship', 'deals pipeline'])) {
+    if (hasAny(text, [
+        'crm backend',
+        'sales pipeline',
+        'sales crm',
+        'customer relationship',
+        'deals pipeline',
+    ])) {
         return { family: 'crm-backend', layers: ['framework:crm-backend'], path: 'apps/api' };
     }
-    if (hasAny(text, ['headless commerce', 'ecommerce backend', 'cart api', 'checkout api', 'product catalog api', 'order management api'])) {
-        return { family: 'ecommerce-headless', layers: ['framework:ecommerce-headless'], path: 'apps/api' };
+    if (hasAny(text, [
+        'headless commerce',
+        'ecommerce backend',
+        'cart api',
+        'checkout api',
+        'product catalog api',
+        'order management api',
+    ])) {
+        return {
+            family: 'ecommerce-headless',
+            layers: ['framework:ecommerce-headless'],
+            path: 'apps/api',
+        };
     }
     // Multi-agent swarm — supervisor/worker orchestration. agent-swarm-ts is
     // TypeScript-only (LangGraph-JS). Python swarms (CrewAI, AutoGen) must fall
     // through to chooseAgentFamily which picks agent-service-py. Gate on the
     // absence of a Python language hint so 'Python CrewAI' prompts keep routing
     // to the Python agent family. Preserves held-out id=ho-python-crewai.
-    const swarmSignals = hasAny(text, ['multi-agent', 'agent swarm', 'supervisor agent', 'agent orchestration', 'crewai', 'agent handoff', 'specialist agents', 'agent team', 'role-based agents']);
-    const isPythonHint = hasAny(text, ['python', 'pydanticai', 'autogen', 'agno', 'llamaindex', 'unsloth', 'qlora']);
+    const swarmSignals = hasAny(text, [
+        'multi-agent',
+        'agent swarm',
+        'supervisor agent',
+        'agent orchestration',
+        'crewai',
+        'agent handoff',
+        'specialist agents',
+        'agent team',
+        'role-based agents',
+    ]);
+    const isPythonHint = hasAny(text, [
+        'python',
+        'pydanticai',
+        'autogen',
+        'agno',
+        'llamaindex',
+        'unsloth',
+        'qlora',
+    ]);
     if (swarmSignals && !isPythonHint) {
         return { family: 'agent-swarm-ts', layers: ['framework:agent-swarm-ts'], path: 'apps/swarm' };
     }
@@ -508,21 +805,44 @@ export function chooseApiFamily(text) {
         // Dispatch to the specific zkVM family when the prompt names one; else
         // the generic zk-prover-service. Mirrors prompt-planner.ts workspace
         // branch — keep the two in sync.
-        if (text.includes('risc zero') || text.includes('risc0') || text.includes('risczero') || text.includes('bonsai')) {
+        if (text.includes('risc zero') ||
+            text.includes('risc0') ||
+            text.includes('risczero') ||
+            text.includes('bonsai')) {
             return { family: 'risczero-zkvm', layers: ['framework:risczero-zkvm'], path: 'apps/prover' };
         }
         if (text.includes('sp1') || text.includes('succinct')) {
             return { family: 'sp1-zkvm', layers: ['framework:sp1-zkvm'], path: 'apps/prover' };
         }
-        if (text.includes('arkworks') || text.includes('hand-rolled r1cs') || text.includes('custom snark circuit')) {
-            return { family: 'arkworks-prover', layers: ['framework:arkworks-prover'], path: 'apps/prover' };
+        if (text.includes('arkworks') ||
+            text.includes('hand-rolled r1cs') ||
+            text.includes('custom snark circuit')) {
+            return {
+                family: 'arkworks-prover',
+                layers: ['framework:arkworks-prover'],
+                path: 'apps/prover',
+            };
         }
-        return { family: 'zk-prover-service', layers: ['framework:zk-prover-service'], path: 'apps/prover' };
+        return {
+            family: 'zk-prover-service',
+            layers: ['framework:zk-prover-service'],
+            path: 'apps/prover',
+        };
     }
-    if (detectLane(text, 'evm-infra'))
+    if ((options.registry &&
+        hasEvmDomainPackSupportApiSurface({
+            prompt: options.prompt ?? text,
+            partner: options.partner ?? null,
+            registry: options.registry,
+        })) ||
+        detectLane(text, 'evm-infra'))
         return { family: 'evm-infra-ts', layers: ['framework:evm-infra-ts'], path: 'apps/api' };
     if (hasAny(text, ['cloudflare', 'durable object', 'edge api', 'edge function', 'hono edge'])) {
-        return { family: 'cloudflare-worker-ts', layers: ['framework:cloudflare-worker-ts'], path: 'apps/edge' };
+        return {
+            family: 'cloudflare-worker-ts',
+            layers: ['framework:cloudflare-worker-ts'],
+            path: 'apps/edge',
+        };
     }
     // Bun must be checked before the generic Node path below. "bun" alone is a
     // stronger signal than the fuzzier Node defaults.
@@ -535,13 +855,33 @@ export function chooseApiFamily(text) {
     // Ollama local-first inference — must come BEFORE vllm-server so prompts that
     // explicitly mention ollama/gguf/local llm pick the local-first path instead
     // of the GPU-first vllm path.
-    if (hasAny(text, ['ollama', 'ollama local', 'local llm', 'gguf', 'llama.cpp', 'on-device llm', 'self-hosted inference', 'ollama modelfile'])) {
+    if (hasAny(text, [
+        'ollama',
+        'ollama local',
+        'local llm',
+        'gguf',
+        'llama.cpp',
+        'on-device llm',
+        'self-hosted inference',
+        'ollama modelfile',
+    ])) {
         return { family: 'ollama-server', layers: ['framework:ollama-server'], path: 'apps/inference' };
     }
     // LLM inference server — vLLM / self-hosted model serving / OpenAI-compatible.
     // Must come before python-api so prompts about "python llm inference server"
     // route to vllm-server instead of the generic python HTTP path.
-    if (hasAny(text, ['vllm', 'llm inference server', 'llm serving', 'self-hosted llm', 'model serving', 'serve llama', 'openai-compatible api', 'paged attention', 'gpu inference', 'inference server'])) {
+    if (hasAny(text, [
+        'vllm',
+        'llm inference server',
+        'llm serving',
+        'self-hosted llm',
+        'model serving',
+        'serve llama',
+        'openai-compatible api',
+        'paged attention',
+        'gpu inference',
+        'inference server',
+    ])) {
         return { family: 'vllm-server', layers: ['framework:vllm-server'], path: 'apps/inference' };
     }
     if (hasAny(text, ['rust', 'cargo', 'axum', 'rust api', 'rust backend'])) {
@@ -553,10 +893,14 @@ export function chooseApiFamily(text) {
     if (hasAny(text, ['golang', 'go api', 'go backend', 'go service', 'net/http'])) {
         return { family: 'go-api', layers: ['framework:go-net-http'], path: 'apps/api' };
     }
-    return { family: 'api-service', layers: ['framework:node-http', 'capability:logging'], path: 'apps/api' };
+    return {
+        family: 'api-service',
+        layers: ['framework:node-http', 'capability:logging'],
+        path: 'apps/api',
+    };
 }
 export function buildApiProject(prompt, partner, text, registry) {
-    const choice = chooseApiFamily(text);
+    const choice = chooseApiFamily(text, { prompt, partner, registry });
     const layers = [...choice.layers];
     const slots = {};
     const databaseSlot = detectDatabaseSlot(text);
@@ -565,16 +909,17 @@ export function buildApiProject(prompt, partner, text, registry) {
     const paymentsSlot = detectPaymentsSlot(text);
     const queueSlot = detectQueueSlot(text);
     if (databaseSlot)
-        slots['database'] = databaseSlot;
+        slots.database = databaseSlot;
     if (authSlot)
-        slots['auth'] = authSlot;
+        slots.auth = authSlot;
     if (paymentsSlot)
-        slots['payments'] = paymentsSlot;
+        slots.payments = paymentsSlot;
     if (queueSlot)
-        slots['queue'] = queueSlot;
+        slots.queue = queueSlot;
     if (sdkSlot)
-        slots['sdk'] = sdkSlot;
-    if ((choice.family === 'api-service' || choice.family === 'evm-infra-ts') && detectEvmSupportApiPattern(text)) {
+        slots.sdk = sdkSlot;
+    if ((choice.family === 'api-service' || choice.family === 'evm-infra-ts') &&
+        detectEvmSupportApiPattern(text)) {
         layers.push('capability:evm-protocol-api');
     }
     if (choice.family === 'evm-infra-ts') {
@@ -608,8 +953,10 @@ export function buildWorkerProject(prompt, partner, text) {
     const slots = {};
     const queueSlot = detectQueueSlot(text);
     if (queueSlot)
-        slots['queue'] = queueSlot;
-    if (choice.family === 'worker-job' && hasAny(text, ['solana', 'anchor', 'pyth', 'switchboard', 'keeper', 'liquidation'])) {
+        slots.queue = queueSlot;
+    if (choice.family === 'worker-job' &&
+        hasAny(text, ['keeper', 'liquidation']) &&
+        hasAny(text, ['solana', 'anchor', 'pyth', 'switchboard'])) {
         layers.push('capability:solana-keeper');
     }
     return {