@tangle-network/starter-foundry 0.5.3 → 0.5.4

package/dist/lib/prompt-planner.js

@@ -1,623 +1,14 @@
-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 { 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);
@@ -789,7 +180,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);
@@ -861,10 +292,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 +302,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,