@tangle-network/starter-foundry 0.5.3 → 0.7.0

package/dist/lib/prompt-planner.js

@@ -1,623 +1,15 @@
-import { sanitizePackageName } from './fs.js';
 import { emit, traced } from './telemetry.js';
 import { loadRegistry } from './registry.js';
 import { selectStarter } from './selection.js';
-import { detectCapabilities, detectIndustry, detectLane, hasAny, matchesKeyword } from './keywords.js';
-function buildSlug(prompt, fallback) {
-    const slug = sanitizePackageName(prompt).slice(0, 40);
-    return slug || fallback;
-}
-function resolvePartnerForFamily(partner, family) {
-    if (!partner) {
-        return null;
-    }
-    const familySets = {
-        coinbase: new Set([
-            'frontend-static',
-            'react-vite-ts',
-            'nextjs-ts',
-            'fullstack-ts',
-            'expo-react-native-ts',
-            'browser-extension-ts',
-            'electron-desktop-ts',
-            'tauri-desktop',
-            'api-service',
-            'cloudflare-worker-ts',
-            'python-api',
-            'rust-service',
-            'go-api',
-            'worker-job',
-            'go-worker',
-            'playwright-worker',
-            'evm-infra-ts',
-            'agent-service-ts',
-            'agent-service-py',
-            'forge-contracts',
-            'hardhat-contracts',
-        ]),
-        tangle: new Set([
-            'frontend-static',
-            'react-vite-ts',
-            'nextjs-ts',
-            'fullstack-ts',
-            'api-service',
-            'python-api',
-            'rust-service',
-            'go-api',
-            'worker-job',
-            'go-worker',
-            'playwright-worker',
-            'evm-infra-ts',
-            'agent-service-ts',
-            'agent-service-py',
-            'agent-service-rust',
-            'tangle-blueprint',
-        ]),
-        eigenlayer: new Set([
-            'frontend-static',
-            'react-vite-ts',
-            'nextjs-ts',
-            'fullstack-ts',
-            'api-service',
-            'python-api',
-            'rust-service',
-            'go-api',
-            'worker-job',
-            'go-worker',
-            'playwright-worker',
-            'evm-infra-ts',
-            'agent-service-ts',
-            'agent-service-py',
-            'agent-service-rust',
-            'eigenlayer-avs',
-        ]),
-        arbitrum: new Set([
-            'frontend-static',
-            'react-vite-ts',
-            'nextjs-ts',
-            'fullstack-ts',
-            'api-service',
-            'python-api',
-            'rust-service',
-            'go-api',
-            'worker-job',
-            'go-worker',
-            'playwright-worker',
-            'evm-infra-ts',
-            'agent-service-ts',
-            'agent-service-py',
-            'agent-service-rust',
-            'forge-contracts',
-            'hardhat-contracts',
-            'stylus-contracts',
-        ]),
-        xlayer: new Set([
-            'frontend-static',
-            'react-vite-ts',
-            'nextjs-ts',
-            'fullstack-ts',
-            'api-service',
-            'python-api',
-            'rust-service',
-            'go-api',
-            'worker-job',
-            'go-worker',
-            'playwright-worker',
-            'evm-infra-ts',
-            'agent-service-ts',
-            'agent-service-py',
-            'agent-service-rust',
-            'forge-contracts',
-            'hardhat-contracts',
-        ]),
-        solana: new Set([
-            'frontend-static',
-            'react-vite-ts',
-            'nextjs-ts',
-            'fullstack-ts',
-            'api-service',
-            'python-api',
-            'rust-service',
-            'go-api',
-            'worker-job',
-            'go-worker',
-            'playwright-worker',
-            'agent-service-ts',
-            'agent-service-py',
-            'agent-service-rust',
-            'solana-program',
-        ]),
-    };
-    return familySets[partner]?.has(family) ? partner : null;
-}
-function detectDatabaseSlot(text) {
-    if (text.includes('convex'))
-        return 'database:convex';
-    if (text.includes('postgres'))
-        return 'database:postgres';
-    if (text.includes('mongodb') || text.includes('mongo'))
-        return 'database:mongodb';
-    if (text.includes('sqlite'))
-        return 'database:sqlite';
-    return null;
-}
-function detectSdkSlot(text, partner) {
-    if (text.includes('solana web3') || text.includes('@solana/web3') || text.includes('wallet adapter')) {
-        return 'sdk:solana-web3';
-    }
-    if (partner === 'coinbase')
-        return 'sdk:coinbase-cdp';
-    if (text.includes('coinbase cdp') || text.includes('coinbase sdk'))
-        return 'sdk:coinbase-cdp';
-    if (partner === 'xlayer' ||
-        partner === 'arbitrum' ||
-        hasAny(text, ['walletconnect', 'wallet connect', 'okx wallet', 'metamask', 'viem', 'ethers'])) {
-        return 'sdk:evm-wallet';
-    }
-    return null;
-}
-function detectAuthSlot(text) {
-    if (text.includes('clerk'))
-        return 'auth:clerk';
-    if (text.includes('better auth') || text.includes('better-auth'))
-        return 'auth:better-auth';
-    if (text.includes('supabase auth') || text.includes('supabase-auth'))
-        return 'auth:supabase-auth';
-    return null;
-}
-function detectPaymentsSlot(text) {
-    if (text.includes('coinbase commerce'))
-        return 'payments:coinbase-commerce';
-    if (text.includes('stripe') || text.includes('subscription') || text.includes('billing') || text.includes('checkout')) {
-        return 'payments:stripe';
-    }
-    return null;
-}
-function detectQueueSlot(text) {
-    if (text.includes('trigger.dev') || text.includes('trigger dev'))
-        return 'queue:trigger-dev';
-    if (text.includes('bullmq') || text.includes('queue') || text.includes('background job'))
-        return 'queue:bullmq';
-    return null;
-}
-function detectTangleOraclePattern(text) {
-    return (hasAny(text, ['tangle', 'tangle network', 'tangle native']) &&
-        hasAny(text, ['oracle', 'price feed', 'attestation', 'feeder', 'operator rewards', 'slashing', 'data source']));
-}
-function detectTangleCustodyPattern(text) {
-    return (hasAny(text, ['tangle', 'tangle network', 'tangle native', 'frost']) &&
-        hasAny(text, ['custody', 'mpc', 'threshold signing', 'key resharing', 'policy engine', 'signing ceremony']));
-}
-function detectEvmDeployPattern(text) {
-    return hasAny(text, [
-        'foundry.toml',
-        'deploy script',
-        'deploy task',
-        'contract verification',
-        'verify',
-        'oklink explorer',
-        '.env template',
-        'private_key',
-        'sample erc20',
-    ]);
-}
-function detectHardhatExplicit(text) {
-    return text.includes('hardhat') && !hasAny(text, ['foundry', 'forge']);
-}
-function detectEvmSupportApiPattern(text) {
-    return hasAny(text, [
-        'indexer',
-        'subgraph',
-        'events',
-        'relayer',
-        'paymaster',
-        'bundler',
-        'keeper',
-        'oracle',
-        'bridge',
-        'bridges',
-        'layerzero',
-        'oft',
-        'sendtokens',
-        'hook',
-        'analytics',
-        'portfolio',
-        'metrics',
-        'multicall',
-        'wallet balance',
-        'transaction count',
-        'gas price',
-        'websocket',
-        '/stats',
-    ]);
-}
-function inferPartner(text) {
-    if (hasAny(text, ['coinbase', 'base network', 'coinbase commerce', 'coinbase wallet', 'coinbase cdp'])) {
-        return 'coinbase';
-    }
-    if (hasAny(text, ['tangle', 'blueprint sdk', 'cargo tangle']))
-        return 'tangle';
-    if (hasAny(text, ['eigenlayer', 'avs']))
-        return 'eigenlayer';
-    if (hasAny(text, ['x layer', 'xlayer', 'okb', 'oklink', 'okx']))
-        return 'xlayer';
-    if (hasAny(text, ['arbitrum', 'stylus']))
-        return 'arbitrum';
-    if (hasAny(text, ['solana', 'anchor', 'pda', 'wallet adapter']))
-        return 'solana';
-    return null;
-}
-function needsSupportApiLane(text) {
-    return hasAny(text, [
-        'order management',
-        'order history',
-        'payment webhook',
-        'quote generation',
-        'claims',
-        'transaction history',
-        'history/audit',
-        'portfolio',
-        'analytics',
-        'monitoring',
-        'indexer',
-        'websocket',
-        'database',
-        'metrics',
-        'p&l',
-        'api endpoints',
-        'consumer integration',
-        'historical data',
-        'data source',
-        'programmatic access',
-        'control plane',
-        'agent state',
-        'tool logs',
-        'memory',
-        'thread history',
-        'execution traces',
-    ]);
-}
-function detectSolanaProductApiPattern(text) {
-    return hasAny(text, [
-        'pyth',
-        'switchboard',
-        'jupiter',
-        'openbook',
-        'analytics',
-        'leaderboard',
-        'activity feed',
-        'creator dashboard',
-        'launch calendar',
-        'pool discovery',
-        'market browser',
-        'market data',
-        'oracle integration',
-        'price feeds',
-        'dashboard',
-        'staking dashboard',
-        'royalty analytics',
-        'position explorer',
-        'pool explorer',
-    ]);
-}
-function detectSolanaWorkerPattern(text) {
-    return hasAny(text, [
-        'keeper',
-        'liquidation',
-        'funding rate',
-        'pyth price feeds',
-        'switchboard',
-        'oracle integration',
-        'disputes',
-        'auto-deleveraging',
-        'rebalance',
-        'rebalancing',
-        'rewards distribution',
-        'reward distribution',
-        'vesting',
-        'sale monitor',
-        'auto-compound',
-    ]);
-}
-function buildEvmContractLayers(text) {
-    const hardhatExplicit = detectHardhatExplicit(text);
-    const layers = [hardhatExplicit ? 'framework:hardhat-ts' : 'framework:forge-foundation'];
-    if (!hardhatExplicit && detectEvmDeployPattern(text)) {
-        layers.push('capability:evm-deploy-foundry');
-    }
-    if (!hardhatExplicit &&
-        hasAny(text, ['layerzero', 'oft', 'bridge tokens', 'sendtokens script', 'omnichain fungible token'])) {
-        layers.push('capability:evm-layerzero-oft');
-    }
-    else if (!hardhatExplicit &&
-        hasAny(text, ['erc-4337', 'erc4337', 'bundler', 'permissionless.js', 'gasless mint', 'account abstraction'])) {
-        layers.push('capability:evm-account-abstraction');
-    }
-    return layers;
-}
-function chooseAgentFamily(text) {
-    if (hasAny(text, ['rust', 'cargo', 'rig', 'rust agent'])) {
-        return {
-            family: 'agent-service-rust',
-            layers: ['framework:agent-service-rust'],
-            path: 'apps/agent',
-            variables: {
-                agentLibrary: matchesKeyword(text, 'rig') ? 'rig' : 'rust-agent',
-            },
-        };
-    }
-    if (hasAny(text, ['python', 'fastapi', 'pydanticai', 'crewai', 'autogen', 'agno', 'llamaindex', 'agentkit', 'python agent', 'unsloth', 'qlora'])) {
-        let agentLibrary = 'pydanticai';
-        if (text.includes('crewai'))
-            agentLibrary = 'crewai';
-        else if (text.includes('autogen'))
-            agentLibrary = 'autogen';
-        else if (text.includes('agno'))
-            agentLibrary = 'agno';
-        else if (text.includes('llamaindex'))
-            agentLibrary = 'llamaindex';
-        else if (text.includes('agentkit'))
-            agentLibrary = 'agentkit';
-        return {
-            family: 'agent-service-py',
-            layers: ['framework:agent-service-py'],
-            path: 'apps/agent',
-            variables: { agentLibrary },
-        };
-    }
-    let agentLibrary = 'openai-agents';
-    if (text.includes('langgraph'))
-        agentLibrary = 'langgraph';
-    else if (text.includes('mastra'))
-        agentLibrary = 'mastra';
-    else if (hasAny(text, ['anthropic sdk', 'claude sdk']))
-        agentLibrary = 'anthropic-sdk';
-    return {
-        family: 'agent-service-ts',
-        layers: ['framework:agent-service-ts'],
-        path: 'apps/agent',
-        variables: { agentLibrary },
-    };
-}
-function buildEvmContractVariables(text) {
-    if (hasAny(text, ['layerzero', 'oft', 'omnichain fungible token']))
-        return { contractName: 'OmnichainToken' };
-    if (hasAny(text, ['erc721', 'erc-721', 'nft collection', 'gasless mint']))
-        return { contractName: 'GaslessCollectible' };
-    if (hasAny(text, ['erc20', 'erc-20', 'sample erc20']))
-        return { contractName: 'XLayerToken' };
-    return { contractName: 'Counter' };
-}
-function buildSolanaProgramLayers(text) {
-    const layers = ['framework:solana-native-rust'];
-    if (hasAny(text, ['perpetual', 'futures', 'funding rate', 'liquidation', 'insurance fund', 'cross-collateral'])) {
-        layers.push('capability:solana-perps');
-    }
-    else if (hasAny(text, ['concentrated liquidity', 'tick-based liquidity', 'swap router', 'position nft'])) {
-        layers.push('capability:solana-amm');
-    }
-    else if (hasAny(text, ['nft marketplace', 'compressed nfts', 'royalty enforcement', 'bundle sales'])) {
-        layers.push('capability:solana-nft');
-    }
-    else if (hasAny(text, ['launchpad', 'fair launches', 'dutch auction', 'bonding curve', 'claim portal'])) {
-        layers.push('capability:solana-launchpad');
-    }
-    else if (hasAny(text, ['staking platform', 'veToken', 'rewards dashboard', 'auto-compound', 'validator delegation'])) {
-        layers.push('capability:solana-staking');
-    }
-    else if (hasAny(text, ['prediction market', 'binary (yes/no)', 'switchboard oracle', 'scalar', 'categorical'])) {
-        layers.push('capability:solana-prediction');
-    }
-    return layers;
-}
-function buildSolanaProgramVariables(text) {
-    if (hasAny(text, ['perpetual', 'futures']))
-        return { instructionName: 'InitializePerpMarket' };
-    if (hasAny(text, ['concentrated liquidity', 'amm dex', 'swap router']))
-        return { instructionName: 'InitializePool' };
-    if (hasAny(text, ['nft marketplace', 'compressed nfts']))
-        return { instructionName: 'CreateListing' };
-    if (hasAny(text, ['launchpad', 'fair launches', 'bonding curve']))
-        return { instructionName: 'CreateLaunch' };
-    if (hasAny(text, ['staking platform', 'veToken', 'auto-compound']))
-        return { instructionName: 'InitializeStakePool' };
-    if (hasAny(text, ['prediction market', 'scalar', 'categorical']))
-        return { instructionName: 'CreateMarket' };
-    return { instructionName: 'InitializeTreasury' };
-}
-function buildWebProject(prompt, partner, text, registry) {
-    const isNext = hasAny(text, ['next', 'next.js', 'nextjs', 'app router', 'seo']);
-    const family = isNext ? 'nextjs-ts' : 'react-vite-ts';
-    const frameworkLayer = isNext ? 'framework:nextjs-app-router' : 'framework:react-vite-ts';
-    const layers = [frameworkLayer];
-    if (hasAny(text, ['dashboard', 'metrics', 'analytics', 'control plane', 'admin'])) {
-        layers.push('capability:chart-widget');
-    }
-    const slots = {};
-    const sdkSlot = detectSdkSlot(text, partner);
-    const authSlot = detectAuthSlot(text);
-    const paymentsSlot = detectPaymentsSlot(text);
-    if (authSlot)
-        slots['auth'] = authSlot;
-    if (paymentsSlot)
-        slots['payments'] = paymentsSlot;
-    if (sdkSlot)
-        slots['sdk'] = sdkSlot;
-    const webCapabilities = registry ? detectCapabilities(text, family, registry) : [];
-    if (webCapabilities.length > 0)
-        layers.push(...webCapabilities);
-    return {
-        id: 'web',
-        path: 'apps/web',
-        spec: {
-            projectName: `${buildSlug(prompt, 'workspace')}-web`,
-            family,
-            layers: [...new Set(layers)],
-            partner: resolvePartnerForFamily(partner, family),
-            slots,
-            variables: {
-                headline: 'Ship the primary product surface first',
-                subheadline: 'This workspace starts with the user-visible surface before deepening the backend and contract lanes.',
-            },
-            primaryArtifactTargetMs: 2500,
-        },
-    };
-}
-function chooseWorkerFamily(text) {
-    if (hasAny(text, ['playwright', 'browser automation', 'web scraping', 'scraper', 'crawler'])) {
-        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'])) {
-        return { family: 'python-worker', layers: ['framework:python-worker'], path: 'apps/worker' };
-    }
-    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'];
-    if (hasAny(text, ['trading', 'market', 'feed', 'stream'])) {
-        layers.push('capability:market-sim');
-    }
-    return { family: 'worker-job', layers, path: 'apps/worker' };
-}
-function chooseApiFamily(text) {
-    if (detectLane(text, 'x402'))
-        return { family: 'x402-service', layers: ['framework:x402-service'], path: 'apps/api' };
-    if (detectLane(text, 'mcp'))
-        return { family: 'mcp-server-ts', layers: ['framework:mcp-server-ts'], path: 'apps/mcp' };
-    if (detectLane(text, 'dspy'))
-        return { family: 'dspy-pipeline-py', layers: ['framework:dspy-pipeline-py'], path: 'apps/ai' };
-    if (detectLane(text, 'agent'))
-        return chooseAgentFamily(text);
-    if (detectLane(text, 'zk'))
-        return { family: 'zk-prover-service', layers: ['framework:zk-prover-service'], path: 'apps/prover' };
-    if (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' };
-    }
-    if (hasAny(text, ['rust', 'cargo', 'axum', 'rust api', 'rust backend'])) {
-        return { family: 'rust-service', layers: ['framework:rust-http'], path: 'apps/api' };
-    }
-    if (hasAny(text, ['python', 'fastapi', 'flask', 'django', 'python api'])) {
-        return { family: 'python-api', layers: ['framework:python-http'], path: 'apps/api' };
-    }
-    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' };
-}
-function buildApiProject(prompt, partner, text, registry) {
-    const choice = chooseApiFamily(text);
-    const layers = [...choice.layers];
-    const slots = {};
-    const databaseSlot = detectDatabaseSlot(text);
-    const sdkSlot = detectSdkSlot(text, partner);
-    const authSlot = detectAuthSlot(text);
-    const paymentsSlot = detectPaymentsSlot(text);
-    const queueSlot = detectQueueSlot(text);
-    if (databaseSlot)
-        slots['database'] = databaseSlot;
-    if (authSlot)
-        slots['auth'] = authSlot;
-    if (paymentsSlot)
-        slots['payments'] = paymentsSlot;
-    if (queueSlot)
-        slots['queue'] = queueSlot;
-    if (sdkSlot)
-        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') {
-        if (hasAny(text, ['block monitor', 'new blocks', 'gas price', 'tps', '/stats'])) {
-            layers.push('capability:evm-chain-monitor');
-        }
-        else if (hasAny(text, ['wallet balance', 'wallet address', 'multicall', 'summary table'])) {
-            layers.push('capability:evm-wallet-dashboard');
-        }
-    }
-    const apiCapabilities = registry ? detectCapabilities(text, choice.family, registry) : [];
-    if (apiCapabilities.length > 0)
-        layers.push(...apiCapabilities);
-    return {
-        id: choice.family.startsWith('agent-service-') ? 'agent' : 'api',
-        path: choice.path,
-        spec: {
-            projectName: `${buildSlug(prompt, 'workspace')}-api`,
-            family: choice.family,
-            layers: [...new Set(layers)],
-            partner: resolvePartnerForFamily(partner, choice.family),
-            slots,
-            variables: choice.variables ?? {},
-            primaryArtifactTargetMs: 2500,
-        },
-    };
-}
-function buildWorkerProject(prompt, partner, text) {
-    const choice = chooseWorkerFamily(text);
-    const layers = [...choice.layers];
-    const slots = {};
-    const queueSlot = detectQueueSlot(text);
-    if (queueSlot)
-        slots['queue'] = queueSlot;
-    if (choice.family === 'worker-job' && hasAny(text, ['solana', 'anchor', 'pyth', 'switchboard', 'keeper', 'liquidation'])) {
-        layers.push('capability:solana-keeper');
-    }
-    return {
-        id: 'worker',
-        path: choice.path,
-        spec: {
-            projectName: `${buildSlug(prompt, 'workspace')}-worker`,
-            family: choice.family,
-            layers,
-            partner: resolvePartnerForFamily(partner, choice.family),
-            slots,
-            variables: {
-                workerName: partner ? `${partner} worker lane` : 'workspace worker lane',
-            },
-            primaryArtifactTargetMs: 2500,
-        },
-    };
-}
-// Single-surface families that never become workspaces
-const SINGLE_LANE_SIGNALS = [
-    'expo', 'react native', 'mobile app', 'ios app', 'android app',
-    'browser extension', 'chrome extension', 'manifest v3',
-    'electron', 'desktop app', 'desktop assistant',
-    'command line', 'terminal tool',
-    'streamlit', 'gradio', 'data app', 'tauri',
-];
-const FRONTEND_SIGNALS = [
-    'frontend', 'ui', 'website', 'landing', 'dashboard', 'web app', 'app',
-    'preview', 'next', 'react', 'platform', 'dapp', 'interface', 'portal',
-];
-const API_SIGNALS = [
-    'api', 'backend', 'server', 'endpoint', 'service', 'webhook', 'health check',
-    'cloudflare', 'durable object', 'edge api', 'edge function', 'payment webhook',
-    'server wallet', 'rest api', 'graphql api',
-];
-const FRAMEWORK_API_TERMS = ['composition api', 'options api', 'signals api', 'context api', 'hooks api'];
-const STRONG_API_TERMS = ['backend', 'server', 'endpoint', 'webhook', 'rest api', 'graphql api', 'api service', 'api endpoint', 'health check'];
-const WORKER_SIGNALS = [
-    'trading bot', 'background job', 'background worker', 'worker for', 'playwright worker',
-    'automation worker', 'go worker', 'golang worker', 'queue', 'cron', 'market stream', 'bot',
-];
-const EXPLICIT_WORKER_SIGNALS = [
-    'trading bot', 'background job', 'background worker', 'worker for', 'playwright worker',
-    'automation worker', 'go worker', 'golang worker', 'queue', 'cron', 'market stream',
-];
-const FULLSTACK_SIGNALS = [
-    'fullstack', 'full stack', 'dashboard with api', 'app with api', 'admin app', 'admin panel',
-    'database-backed', 'dashboard and api', 'admin flows', 'saas', 'saas app', 'saas platform',
-    'internal tool', 'back office', 'crud app',
-];
-const WORKSPACE_SIGNALS = [
-    'workspace', 'monorepo', 'separate backend', 'separate api',
-    'background worker', 'contract lane', 'contract lanes',
-];
+import { detectCapabilities, detectIndustry, detectLane, hasAny } from './keywords.js';
+import { rewritePrompt, rewriteViaBrief } from './prompt-rewriter.js';
+import { API_SIGNALS, EXPLICIT_WORKER_SIGNALS, FRAMEWORK_API_TERMS, FRONTEND_SIGNALS, FULLSTACK_SIGNALS, REACT_FAMILIES, SINGLE_LANE_SIGNALS, STRONG_API_TERMS, WORKER_SIGNALS, WORKSPACE_SIGNALS, } from './planner/signals.js';
+import { detectAuthSlot, detectDatabaseSlot, detectEvmSupportApiPattern, detectHardhatExplicit, detectPaymentsSlot, detectQueueSlot, detectSdkSlot, detectSolanaProductApiPattern, detectSolanaWorkerPattern, detectTangleCustodyPattern, detectTangleOraclePattern, inferPartner, needsSupportApiLane, } from './planner/detectors.js';
+import { buildEvmContractLayers, buildEvmContractVariables, buildSolanaProgramLayers, buildSolanaProgramVariables, } from './planner/contracts.js';
+import { buildSlug, resolvePartnerForFamily } from './planner/helpers.js';
+import { inferImplicitCapabilities } from './planner/implicit-caps.js';
+import { shouldPromotePartnerFirst } from './planner/partner-first.js';
+import { buildApiProject, buildWebProject, buildWorkerProject, chooseApiFamily } from './planner/projects.js';
 function detectLanes(text, partner) {
     const hasApiRaw = hasAny(text, API_SIGNALS);
     const apiIsFalsePositive = hasApiRaw && !hasAny(text, STRONG_API_TERMS) && hasAny(text, FRAMEWORK_API_TERMS);
@@ -746,8 +138,32 @@ function collectServiceProjects(lanes, prompt, partner, text, registry) {
         projects.push({ id: 'api', path: 'apps/api', spec: { projectName: `${buildSlug(prompt, 'workspace')}-api`, family: 'x402-service', layers: ['framework:x402-service'], partner: resolvePartnerForFamily(partner, 'x402-service'), slots: {}, variables: {}, primaryArtifactTargetMs: 2500 } });
     }
     if (lanes.zk && !lanes.api) {
-        const proofSystem = text.includes('circom') ? 'circom' : text.includes('fhenix') ? 'fhenix' : text.includes('risc zero') ? 'risc-zero' : 'sp1';
-        projects.push(buildProtocolProject('zk', 'apps/prover', 'zk-prover-service', ['framework:zk-prover-service'], prompt, null, { proofSystem }));
+        // Dispatch to the specific zkVM family when the prompt names one; fall
+        // back to the generic zk-prover-service for unspecific "zk prover" /
+        // "verifiable ml" / "dark pool" / "mixer" / "private voting" prompts.
+        // Mirrors the single-starter routing path so workspace composition is
+        // consistent with single-family selection.
+        let zkFamily = 'zk-prover-service';
+        let zkFramework = 'framework:zk-prover-service';
+        const zkVars = {};
+        if (text.includes('risc zero') || text.includes('risc0') || text.includes('risczero') || text.includes('bonsai')) {
+            zkFamily = 'risczero-zkvm';
+            zkFramework = 'framework:risczero-zkvm';
+        }
+        else if (text.includes('sp1') || text.includes('succinct')) {
+            zkFamily = 'sp1-zkvm';
+            zkFramework = 'framework:sp1-zkvm';
+        }
+        else if (text.includes('arkworks') || text.includes('hand-rolled r1cs') || text.includes('custom snark circuit')) {
+            zkFamily = 'arkworks-prover';
+            zkFramework = 'framework:arkworks-prover';
+        }
+        else {
+            // Generic fallback — keep the pre-existing proof-system slot logic so
+            // the generic scaffold composes with a proofSystem hint.
+            zkVars.proofSystem = text.includes('circom') ? 'circom' : text.includes('fhenix') ? 'fhenix' : 'sp1';
+        }
+        projects.push(buildProtocolProject('zk', 'apps/prover', zkFamily, [zkFramework], prompt, null, zkVars));
     }
     if (lanes.agent && !projects.some((p) => p.id === 'agent')) {
         projects.push(buildApiProject(prompt, partner, text, registry));
@@ -789,7 +205,47 @@ function buildWorkspacePromptPlan({ prompt, partner, text, registry, }) {
         },
     };
 }
-export async function planPrompt({ prompt, partner = null, forceKind = null, familyHint = null, }) {
+export async function planPrompt({ prompt, partner = null, forceKind = null, familyHint = null, rewriter = false, brief = false, }) {
+    if (brief) {
+        const preCheck = await selectStarter({ prompt, partner });
+        if (preCheck.confidence !== 'high' || preCheck.fallbackUsed) {
+            const registry = await loadRegistry();
+            const knownFamilies = [...registry.families.keys()];
+            const knownCapabilities = [];
+            for (const [key] of registry.layers) {
+                if (key.startsWith('capability:'))
+                    knownCapabilities.push(key);
+            }
+            const briefResult = await rewriteViaBrief({ prompt, partner, knownFamilies, knownCapabilities });
+            if (briefResult) {
+                const plan = await planPrompt({
+                    prompt: briefResult.canonicalPrompt,
+                    partner,
+                    forceKind,
+                    familyHint,
+                    rewriter: false,
+                    brief: false,
+                });
+                return { ...plan, brief: briefResult.brief };
+            }
+        }
+    }
+    if (rewriter) {
+        const preCheck = await selectStarter({ prompt, partner });
+        if (preCheck.confidence !== 'high' || preCheck.fallbackUsed) {
+            const registry = await loadRegistry();
+            const knownFamilies = [...registry.families.keys()];
+            const knownCapabilities = [];
+            for (const [key] of registry.layers) {
+                if (key.startsWith('capability:'))
+                    knownCapabilities.push(key);
+            }
+            const rewrite = await rewritePrompt({ prompt, partner, knownFamilies, knownCapabilities });
+            if (rewrite) {
+                return planPrompt({ prompt: rewrite.canonicalPrompt, partner, forceKind, familyHint, rewriter: false });
+            }
+        }
+    }
     const { result: plan, durationMs } = await traced('planPrompt', async () => {
         const text = prompt.toLowerCase();
         const effectivePartner = partner ?? inferPartner(text);
@@ -801,6 +257,81 @@ export async function planPrompt({ prompt, partner = null, forceKind = null, fam
                 return workspacePlan;
             }
         }
+        // Partner-first routing. When the workspace check did NOT fire and the
+        // buildout trace carries an EXPLICIT partnerGuess (e.g. `tangle-network`,
+        // `polymarket-prediction`, `coinbase-smart-wallet`, `deno`) that aligns
+        // with a registry family via tags / keywords / id tokens, promote the
+        // prompt to a single-project workspace wrapping the partner-aligned
+        // family. This absorbs demand from newly-promoted domain-specific
+        // families (polymarket-portfolio-hedging, kyc-onboarding,
+        // fraud-ops-console, tangle-blueprint, deno-edge, …) that otherwise
+        // disappear into generic workspace composition.
+        //
+        // Narrowing — MUST preserve routing_stability:
+        //   (1) Only fires on an explicit caller-supplied `partner`. The soft
+        //       `inferPartner(text)` heuristic is too eager — it tags `'tangle'`
+        //       on any prompt containing "tangle", which breaks coverage tests
+        //       that expect starter-mode routing for bare protocol prompts.
+        //   (2) Only fires when the workspace planner already declined, so the
+        //       28 currently-routed workspace scenarios are never touched.
+        //   (3) forceKind === 'starter' callers (scaffold-builder with a
+        //       curated family) bypass this branch.
+        const PARTNER_FIRST_SURFACES = new Set([
+            'frontend', 'api', 'agent-service', 'fullstack', 'blueprint',
+        ]);
+        if (forceKind !== 'starter' && partner) {
+            const partnerMatch = shouldPromotePartnerFirst(partner, registry);
+            if (partnerMatch && PARTNER_FIRST_SURFACES.has(partnerMatch.surface)) {
+                const fwLayers = [];
+                for (const [key, layer] of registry.layers) {
+                    if (layer.group === 'framework' && layer.appliesTo?.includes(partnerMatch.familyId)) {
+                        fwLayers.push(key);
+                    }
+                }
+                const slug = buildSlug(prompt, 'workspace');
+                // Surface → project id + path. Mirrors how buildWebProject /
+                // buildApiProject name their outputs so downstream artifact selectors
+                // (primaryArtifact.kind, path) remain consistent.
+                const surfaceConfig = {
+                    frontend: { id: 'web', path: 'apps/web', artifactKind: 'preview', artifactPath: '/' },
+                    fullstack: { id: 'web', path: 'apps/web', artifactKind: 'preview', artifactPath: '/' },
+                    api: { id: 'api', path: 'apps/api', artifactKind: 'service', artifactPath: '/health' },
+                    'agent-service': { id: 'agent', path: 'apps/agent', artifactKind: 'service', artifactPath: '/health' },
+                    blueprint: { id: 'blueprint', path: 'protocols/tangle', artifactKind: 'service', artifactPath: '/health' },
+                };
+                const cfg = surfaceConfig[partnerMatch.surface] ?? surfaceConfig.frontend;
+                const wrapped = {
+                    kind: 'workspace',
+                    confidence: 'medium',
+                    reasons: [`partner-first → ${partnerMatch.familyId} (aligned to ${partner})`],
+                    spec: {
+                        workspaceName: `${slug}-workspace`,
+                        userPrompt: prompt,
+                        launchPlan: {
+                            primaryProjectId: cfg.id,
+                            primaryArtifact: { kind: cfg.artifactKind, path: cfg.artifactPath, targetMs: 2500 },
+                            initialAgentMission: "Build the user's prompt on top of this partner-aligned scaffold. The starter was chosen because the partner has a dedicated family in the registry — lead with the domain-specific surfaces.",
+                        },
+                        projects: [
+                            {
+                                id: cfg.id,
+                                path: cfg.path,
+                                spec: {
+                                    projectName: `${slug}-${cfg.id}`,
+                                    family: partnerMatch.familyId,
+                                    layers: fwLayers,
+                                    partner: resolvePartnerForFamily(partner, partnerMatch.familyId),
+                                    slots: {},
+                                    variables: {},
+                                    primaryArtifactTargetMs: 2500,
+                                },
+                            },
+                        ],
+                    },
+                };
+                return wrapped;
+            }
+        }
         // Use family hint if provided (scaffold-builder knows the family)
         let starterSelection;
         if (familyHint && registry.families.has(familyHint)) {
@@ -826,10 +357,95 @@ export async function planPrompt({ prompt, partner = null, forceKind = null, fam
         }
         else {
             starterSelection = await selectStarter({ prompt, partner: effectivePartner });
+            // Specialty-family override: selectStarter's tiered keyword score sometimes
+            // lets a generic sibling (python-api, expo-react-native-ts, tauri-desktop,
+            // agent-service-ts, fullstack-ts) beat a more specialized family that the
+            // prompt clearly demands. When the prompt carries unambiguous phrases, we
+            // pick the specialty family directly.
+            const specialtyRules = [
+                { family: 'expo-rn-rich', phrases: ['skia', 'reanimated', 'rich animations mobile', 'expo skia', 'expo reanimated', 'react native skia'] },
+                { family: 'tauri-tray', phrases: ['tauri system tray', 'system tray daemon', 'tray icon only', 'tray menu daemon'] },
+                { family: 'tauri-menubar', phrases: ['macos menubar', 'menu bar app', 'raycast-like', 'floating panel app'] },
+                { family: 'electron-native-os', phrases: ['electron native os', 'deep links desktop', 'native os integration', 'auto updater electron'] },
+                { family: 'voice-first-agent', phrases: ['voice-first conversational', 'voice first agent', 'browser mic agent', 'push to talk agent'] },
+                { family: 'vision-first-agent', phrases: ['camera agent', 'vision-first agent', 'visual qa agent'] },
+                { family: 'multimodal-agent', phrases: ['multimodal agent', 'text image audio agent', 'gpt-4o client app'] },
+                { family: 'webgpu-inference', phrases: ['webgpu browser compute', 'webgpu inference', 'wgsl matmul', 'wgsl compute'] },
+                { family: 'webgpu-render', phrases: ['raw webgpu', 'wgsl graphics', 'wgsl vertex', 'webgpu triangle'] },
+                { family: 'bevy-web', phrases: ['bevy web game', 'bevy wasm', 'rust web game'] },
+                { family: 'godot-web', phrases: ['godot 4 web', 'godot html5', 'godot web game'] },
+                { family: 'unity-web-proxy', phrases: ['unity webgl export', 'unity web build'] },
+                { family: 'livekit-sfu', phrases: ['livekit sfu', 'self-hosted livekit', 'selective forwarding unit'] },
+                { family: 'hls-origin', phrases: ['hls origin', 'hls live streaming', 'rtmp ingest'] },
+                { family: 'realtime-audio-ts', phrases: ['realtime audio visualiz', 'webaudio analyser', 'peer audio'] },
+                { family: 'hipaa-compliance-pack', phrases: ['hipaa compliance pack', 'hipaa-compliant compliance pack', 'phi audit trail and baa', 'baa template'] },
+                { family: 'soc2-compliance-pack', phrases: ['soc 2 type ii compliance pack', 'soc 2 compliance pack', 'soc2 compliance pack', 'change management and incident response'] },
+                { family: 'pci-dss-compliance-pack', phrases: ['pci-dss 4.0 compliance pack', 'pci dss compliance pack', 'pan redaction and stripe tokenization', 'pci compliance pack'] },
+                { family: 'gdpr-compliance-pack', phrases: ['gdpr compliance pack', 'gdpr-compliant consent management', 'data subject rights endpoint'] },
+                { family: 'healthcare-hipaa-backend', phrases: ['hipaa-compliant', 'phi audit log', 'healthcare backend'] },
+                { family: 'fintech-ledger-backend', phrases: ['double-entry ledger', 'double entry ledger', 'debits and credits'] },
+                { family: 'legal-case-mgmt', phrases: ['legal case management', 'matter management', 'attorney timekeeping'] },
+                { family: 'k12-edtech', phrases: ['k-12 edtech', 'k12 edtech', 'ferpa'] },
+                { family: 'crm-backend', phrases: ['sales crm', 'deals pipeline', 'sales pipeline'] },
+                { family: 'ecommerce-headless', phrases: ['headless commerce', 'ecommerce backend', 'cart checkout'] },
+                { family: 'aptos-move', phrases: ['aptos move', 'aptos_framework', 'aptos framework'] },
+                { family: 'celestia-da', phrases: ['celestia', 'data availability node', 'celestia blob'] },
+                { family: 'ollama-server', phrases: ['ollama local', 'ollama server', 'gguf'] },
+                { family: 'sglang-server', phrases: ['sglang', 'radix attention'] },
+                { family: 'tgi-server', phrases: ['text generation inference', 'huggingface tgi'] },
+                { family: 'triton-server', phrases: ['nvidia triton', 'triton inference'] },
+                { family: 'skypilot-serving', phrases: ['skypilot', 'sky serve'] },
+                { family: 'lora-training', phrases: ['lora fine-tun', 'qlora', 'lora training'] },
+                { family: 'streamlit-advanced', phrases: ['multipage streamlit', 'streamlit multipage', 'production streamlit'] },
+                { family: 'jupyter-book', phrases: ['jupyter book', 'jupyterbook', 'executable book'] },
+                { family: 'observable-notebook', phrases: ['observable framework', 'observablehq', 'observable notebook'] },
+                { family: 'eleventy-static', phrases: ['eleventy', '11ty'] },
+                { family: 'hugo-static', phrases: ['hugo static', 'hugo site', 'hugo blog'] },
+                { family: 'zola-static', phrases: ['zola static', 'zola site', 'tera template'] },
+                { family: 'astro-static', phrases: ['astro static', 'astro islands'] },
+                { family: 'threejs-game', phrases: ['three.js', 'threejs', 'webgl 3d scene'] },
+                { family: 'phaser-game', phrases: ['phaser 3', '2d arcade game'] },
+                { family: 'pixijs-game', phrases: ['pixi.js v8', 'pixijs', '2d webgpu'] },
+                { family: 'flutter-app', phrases: ['flutter app', 'flutter dart', 'material design flutter', 'cupertino flutter'] },
+                { family: 'kotlin-multiplatform', phrases: ['kotlin multiplatform', 'compose multiplatform', 'kmp kotlin', 'expect-actual'] },
+                { family: 'esp32-rust', phrases: ['esp32 rust', 'esp-idf-svc', 'xtensa rust', 'espressif rust'] },
+                { family: 'stm32-rust', phrases: ['stm32 rust', 'embassy stm32', 'stm32 embassy', 'stm32 bare metal'] },
+                { family: 'ros2-node-py', phrases: ['ros2 rclpy', 'ros2 python node', 'rclpy publisher', 'ros2 node python'] },
+            ];
+            const lower = prompt.toLowerCase();
+            for (const rule of specialtyRules) {
+                if (starterSelection.spec.family === rule.family)
+                    break;
+                if (!registry.families.has(rule.family))
+                    continue;
+                if (rule.phrases.some((p) => lower.includes(p))) {
+                    const fwLayers = [];
+                    for (const [key, layer] of registry.layers) {
+                        if (layer.group === 'framework' && layer.appliesTo?.includes(rule.family))
+                            fwLayers.push(key);
+                    }
+                    starterSelection = {
+                        confidence: 'high',
+                        spec: {
+                            ...starterSelection.spec,
+                            family: rule.family,
+                            layers: fwLayers,
+                        },
+                        fallbackUsed: false,
+                        reasons: [`specialty override → ${rule.family}`],
+                    };
+                    break;
+                }
+            }
         }
         const family = registry.families.get(starterSelection.spec.family);
         const spec = {
             ...starterSelection.spec,
+            // Scrub partner if it's incompatible with the selected family — otherwise
+            // composeStarter throws at compose time, after the caller has already
+            // allocated a workspace and shown the user a "preparing" UI (blueprint-
+            // agent bug report #3).
+            partner: resolvePartnerForFamily(starterSelection.spec.partner ?? effectivePartner, starterSelection.spec.family),
             projectName: buildSlug(prompt, starterSelection.spec.projectName),
             primaryArtifactTargetMs: 2500,
             userPrompt: prompt,
@@ -861,10 +477,7 @@ export async function planPrompt({ prompt, partner = null, forceKind = null, fam
         // Frontend families default to tailwind + shadcn so the layout layers and
         // any UI components composed downstream actually render with styles.
         // Without these, components ship Tailwind class names against an unconfigured
-        // Tailwind install — the visual result is unstyled HTML. Force-attaching here
-        // means callers don't need to know which families are React-flavored or what
-        // their UI deps are.
-        const REACT_FAMILIES = new Set(['react-vite-ts', 'nextjs-ts', 'fullstack-ts', 'remix-ts']);
+        // Tailwind install — the visual result is unstyled HTML.
         if (REACT_FAMILIES.has(spec.family)) {
             const layerSet = new Set(spec.layers ?? []);
             if (!layerSet.has('capability:tailwind')) {
@@ -874,6 +487,15 @@ export async function planPrompt({ prompt, partner = null, forceKind = null, fam
                 spec.layers = [...(spec.layers ?? []), 'capability:shadcn'];
             }
         }
+        // Archetype-based implicit capability inference. Runs last so it can see
+        // everything already attached and avoid double-adding. For web-producing
+        // families this attaches the SaaS UI trio (layout-dashboard + chart +
+        // ai-chat-ui) or the chat archetype (layout-chat + ai-chat-ui) based on
+        // the product shape in the prompt.
+        const implicitCaps = inferImplicitCapabilities(text, spec.family, new Set(spec.layers ?? []));
+        if (implicitCaps.length > 0) {
+            spec.layers = [...new Set([...(spec.layers ?? []), ...implicitCaps])];
+        }
         return {
             kind: 'starter',
             confidence: starterSelection.confidence,