@synergenius/flow-weaver 0.17.0 → 0.17.2

package/dist/cli/commands/dev.js

@@ -3,14 +3,13 @@
  */
 import * as path from 'path';
 import * as fs from 'fs';
-import * as os from 'os';
 import { glob } from 'glob';
-import { spawn } from 'child_process';
-import { compileCommand, compileInngestTarget } from './compile.js';
+import { compileCommand } from './compile.js';
 import { executeWorkflowFromFile } from '../../mcp/workflow-executor.js';
 import { logger } from '../utils/logger.js';
 import { getErrorMessage } from '../../utils/error-utils.js';
 import { getFriendlyError } from '../../friendly-errors.js';
+import { devModeRegistry } from '../../generator/dev-mode-registry.js';
 function timestamp() {
     const now = new Date();
     const h = String(now.getHours()).padStart(2, '0');
@@ -124,204 +123,6 @@ async function compileAndRun(filePath, params, options) {
     }
 }
 // ---------------------------------------------------------------------------
-// Inngest Dev Mode
-// ---------------------------------------------------------------------------
-/**
- * Check that required packages are installed.
- */
-function checkDependency(pkg, cwd) {
-    try {
-        require.resolve(pkg, { paths: [cwd] });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Generate the dev server entry file for Inngest.
- */
-function generateDevServerEntry(inngestOutputPath, framework, port) {
-    const relImport = `./${path.basename(inngestOutputPath).replace(/\.ts$/, '.js')}`;
-    if (framework === 'express') {
-        return `import express from 'express';
-import { handler } from '${relImport}';
-
-const app = express();
-app.use(express.json());
-app.use('/api/inngest', handler);
-app.listen(${port}, () => {
-  console.log('Inngest dev server running on http://localhost:${port}');
-  console.log('Inngest endpoint: http://localhost:${port}/api/inngest');
-  console.log('');
-  console.log('Connect Inngest Dev Server:');
-  console.log('  npx inngest-cli@latest dev -u http://localhost:${port}/api/inngest');
-});
-`;
-    }
-    if (framework === 'hono') {
-        return `import { Hono } from 'hono';
-import { serve } from '@hono/node-server';
-import { handler } from '${relImport}';
-
-const app = new Hono();
-app.route('/api/inngest', handler);
-
-serve({ fetch: app.fetch, port: ${port} }, () => {
-  console.log('Inngest dev server running on http://localhost:${port}');
-  console.log('Inngest endpoint: http://localhost:${port}/api/inngest');
-  console.log('');
-  console.log('Connect Inngest Dev Server:');
-  console.log('  npx inngest-cli@latest dev -u http://localhost:${port}/api/inngest');
-});
-`;
-    }
-    // Default: express (most common for dev)
-    return generateDevServerEntry(inngestOutputPath, 'express', port);
-}
-/**
- * Compile workflow to Inngest and start a local dev server.
- */
-async function runInngestDevMode(filePath, options) {
-    const framework = options.framework ?? 'express';
-    const port = options.port ?? 3000;
-    const cwd = path.dirname(filePath);
-    // Check dependencies
-    const missingDeps = [];
-    if (!checkDependency('inngest', cwd))
-        missingDeps.push('inngest');
-    if (framework === 'express' && !checkDependency('express', cwd))
-        missingDeps.push('express');
-    if (framework === 'hono') {
-        if (!checkDependency('hono', cwd))
-            missingDeps.push('hono');
-        if (!checkDependency('@hono/node-server', cwd))
-            missingDeps.push('@hono/node-server');
-    }
-    if (missingDeps.length > 0) {
-        throw new Error(`Missing dependencies: ${missingDeps.join(', ')}. Install them with: npm install ${missingDeps.join(' ')}`);
-    }
-    // Set up temp directory for generated files
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fw-inngest-dev-'));
-    const inngestOutputPath = path.join(tmpDir, path.basename(filePath).replace(/\.ts$/, '.inngest.ts'));
-    let serverProcess = null;
-    const compileInngest = async () => {
-        try {
-            await compileInngestTarget(filePath, {
-                production: false,
-                workflowName: options.workflow,
-                serve: true,
-                framework: framework,
-                typedEvents: true,
-            });
-            // compileInngestTarget writes to filePath.replace(.ts, .inngest.ts)
-            // Copy it to our temp dir, then remove the source-adjacent file
-            const sourceOutput = filePath.replace(/\.ts$/, '.inngest.ts');
-            if (fs.existsSync(sourceOutput)) {
-                fs.copyFileSync(sourceOutput, inngestOutputPath);
-                try {
-                    fs.unlinkSync(sourceOutput);
-                }
-                catch { /* ignore */ }
-            }
-            return true;
-        }
-        catch (error) {
-            logger.error(`Inngest compilation failed: ${getErrorMessage(error)}`);
-            return false;
-        }
-    };
-    const startServer = () => {
-        // Generate dev server entry
-        const entryPath = path.join(tmpDir, 'dev-server.ts');
-        const entryCode = generateDevServerEntry(inngestOutputPath, framework, port);
-        fs.writeFileSync(entryPath, entryCode, 'utf8');
-        // Spawn tsx to run the server
-        serverProcess = spawn('npx', ['tsx', entryPath], {
-            cwd: path.dirname(filePath),
-            stdio: 'inherit',
-            shell: true,
-        });
-        serverProcess.on('error', (err) => {
-            logger.error(`Server process error: ${err.message}`);
-        });
-        serverProcess.on('exit', (code) => {
-            if (code !== null && code !== 0) {
-                logger.error(`Server exited with code ${code}`);
-            }
-            serverProcess = null;
-        });
-    };
-    const stopServer = () => {
-        if (serverProcess && !serverProcess.killed) {
-            serverProcess.kill();
-            serverProcess = null;
-        }
-    };
-    const restartServer = async () => {
-        stopServer();
-        const ok = await compileInngest();
-        if (ok) {
-            startServer();
-        }
-    };
-    // Header
-    logger.section('Inngest Dev Mode');
-    logger.info(`File: ${path.basename(filePath)}`);
-    logger.info(`Framework: ${framework}`);
-    logger.info(`Port: ${port}`);
-    logger.newline();
-    // Initial compile + start
-    const ok = await compileInngest();
-    if (!ok) {
-        if (options.once)
-            return;
-        logger.info('Fix the errors above, then save the file to retry.');
-    }
-    else {
-        if (options.once)
-            return;
-        startServer();
-    }
-    // Watch for changes
-    logger.newline();
-    logger.success('Watching for file changes... (Ctrl+C to stop)');
-    const files = await glob(path.resolve(filePath), { absolute: true });
-    const chokidar = await import('chokidar');
-    const watcher = chokidar.watch(files, {
-        persistent: true,
-        ignoreInitial: true,
-    });
-    watcher.on('change', async (file) => {
-        cycleSeparator(file);
-        logger.info('Recompiling and restarting server...');
-        await restartServer();
-    });
-    // Cleanup
-    const sourceOutput = filePath.replace(/\.ts$/, '.inngest.ts');
-    const cleanup = () => {
-        logger.newline();
-        logger.info('Stopping Inngest dev mode...');
-        stopServer();
-        watcher.close();
-        // Clean up temp files and source-adjacent .inngest.ts
-        try {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
-        try {
-            fs.unlinkSync(sourceOutput);
-        }
-        catch { /* ignore */ }
-        process.exit(0);
-    };
-    process.on('SIGINT', cleanup);
-    if (process.platform !== 'win32')
-        process.on('SIGTERM', cleanup);
-    // Keep process alive
-    await new Promise(() => { });
-}
-// ---------------------------------------------------------------------------
 // Main Command
 // ---------------------------------------------------------------------------
 /**
@@ -332,9 +133,14 @@ export async function devCommand(input, options = {}) {
     if (!fs.existsSync(filePath)) {
         throw new Error(`File not found: ${filePath}`);
     }
-    // Route to Inngest dev mode if target is inngest
-    if (options.target === 'inngest') {
-        return runInngestDevMode(filePath, options);
+    // Delegate to a registered dev mode provider if one exists for the target
+    if (options.target) {
+        const provider = devModeRegistry.get(options.target);
+        if (provider) {
+            return provider.run(filePath, options);
+        }
+        const available = devModeRegistry.getNames();
+        throw new Error(`Unknown dev target "${options.target}". ${available.length ? `Available: ${available.join(', ')}` : 'No dev mode providers registered. Install a pack that provides one.'}`);
     }
     const params = parseParams(options);
     if (!options.json) {

package/dist/cli/commands/doctor.js

@@ -455,7 +455,8 @@ export function checkTsxAvailable(cwd) {
 }
 // ── Config health checks ─────────────────────────────────────────────────────
 const VALID_FILE_TYPES = ['ts', 'tsx', 'js', 'jsx'];
-const VALID_TARGETS = ['lambda', 'vercel', 'cloudflare'];
+// Target validation is skipped — valid targets are discovered dynamically
+// from installed packs at export time.
 function readYaml(filePath) {
     try {
         const content = fs.readFileSync(filePath, 'utf8');
@@ -606,8 +607,10 @@ export function checkDeploymentProfiles(cwd) {
             continue;
         }
         const config = data;
-        if (config.target && !VALID_TARGETS.includes(config.target)) {
-            invalid.push(`${profile} (invalid target "${config.target}" — must be: ${VALID_TARGETS.join(', ')})`);
+        // Target names are validated at export time via the target registry.
+        // We only check that the value is a non-empty string here.
+        if (config.target && typeof config.target !== 'string') {
+            invalid.push(`${profile} (target must be a string)`);
         }
     }
     if (invalid.length > 0) {

package/dist/cli/commands/export.d.ts

@@ -2,7 +2,7 @@
  * Export command - generate serverless function handlers for deployment
  */
 export interface ExportOptions {
-    /** Target platform (lambda, vercel, cloudflare, inngest) */
+    /** Target platform (provided by installed packs) */
     target: string;
     /** Output directory */
     output: string;
@@ -20,7 +20,7 @@ export interface ExportOptions {
     workflows?: string;
     /** Include API documentation routes (/docs and /openapi.json) */
     docs?: boolean;
-    /** Use deep generator with per-node Inngest steps for durability (inngest target only) */
+    /** Use deep generator with per-node durable steps */
     durableSteps?: boolean;
 }
 /**
@@ -31,26 +31,17 @@ export interface ExportOptions {
  *
  * @example
  * ```bash
- * # Export for Vercel
- * flow-weaver export workflow.ts --target vercel --output api/
- *
- * # Export for AWS Lambda
- * flow-weaver export workflow.ts --target lambda --output dist/lambda/
- *
- * # Export for Cloudflare Workers
- * flow-weaver export workflow.ts --target cloudflare --output workers/
+ * # Export for a target (install the corresponding pack first)
+ * flow-weaver export workflow.ts --target <target> --output dist/
  *
  * # Export specific workflow from multi-workflow file
- * flow-weaver export multi-workflow.ts --target vercel --output api/ --workflow calculate
- *
- * # Export all workflows as a single service (multi-workflow mode)
- * flow-weaver export workflows.ts --target lambda --output dist/ --multi
+ * flow-weaver export multi-workflow.ts --target <target> --output api/ --workflow calculate
  *
- * # Export specific workflows from a file as a service
- * flow-weaver export workflows.ts --target lambda --output dist/ --multi --workflows "workflowA,workflowB"
+ * # Export all workflows as a single service
+ * flow-weaver export workflows.ts --target <target> --output dist/ --multi
  *
  * # Export with API documentation routes
- * flow-weaver export workflow.ts --target lambda --output dist/ --docs
+ * flow-weaver export workflow.ts --target <target> --output dist/ --docs
  * ```
  */
 export declare function exportCommand(input: string, options: ExportOptions): Promise<void>;

package/dist/cli/commands/export.js

@@ -11,32 +11,23 @@ import { logger } from '../utils/logger.js';
  *
  * @example
  * ```bash
- * # Export for Vercel
- * flow-weaver export workflow.ts --target vercel --output api/
- *
- * # Export for AWS Lambda
- * flow-weaver export workflow.ts --target lambda --output dist/lambda/
- *
- * # Export for Cloudflare Workers
- * flow-weaver export workflow.ts --target cloudflare --output workers/
+ * # Export for a target (install the corresponding pack first)
+ * flow-weaver export workflow.ts --target <target> --output dist/
  *
  * # Export specific workflow from multi-workflow file
- * flow-weaver export multi-workflow.ts --target vercel --output api/ --workflow calculate
- *
- * # Export all workflows as a single service (multi-workflow mode)
- * flow-weaver export workflows.ts --target lambda --output dist/ --multi
+ * flow-weaver export multi-workflow.ts --target <target> --output api/ --workflow calculate
  *
- * # Export specific workflows from a file as a service
- * flow-weaver export workflows.ts --target lambda --output dist/ --multi --workflows "workflowA,workflowB"
+ * # Export all workflows as a single service
+ * flow-weaver export workflows.ts --target <target> --output dist/ --multi
  *
  * # Export with API documentation routes
- * flow-weaver export workflow.ts --target lambda --output dist/ --docs
+ * flow-weaver export workflow.ts --target <target> --output dist/ --docs
  * ```
  */
 export async function exportCommand(input, options) {
     // Validate target is provided
     if (!options.target) {
-        throw new Error('--target is required. Install a target pack (e.g. npm install flowweaver-pack-lambda)');
+        throw new Error('--target is required. Install a target pack first.');
     }
     const isDryRun = options.dryRun ?? false;
     const t = logger.timer();
@@ -64,7 +55,7 @@ export async function exportCommand(input, options) {
         logger.info('Include docs: Yes (/docs and /openapi.json routes)');
     }
     if (options.durableSteps) {
-        logger.info('Durable steps: Yes (per-node step.run for Inngest)');
+        logger.info('Durable steps: Yes');
     }
     if (isDryRun) {
         logger.info('Mode: DRY RUN (no files will be written)');

package/dist/cli/commands/init-personas.d.ts

@@ -3,7 +3,7 @@
  * Types, use-case mappings, template selection, and post-scaffold output.
  */
 export type PersonaId = 'nocode' | 'vibecoder' | 'lowcode' | 'expert';
-export type UseCaseId = 'data' | 'ai' | 'api' | 'automation' | 'cicd' | 'minimal';
+export type UseCaseId = 'data' | 'ai' | 'api' | 'automation' | 'minimal';
 export declare const PERSONA_CHOICES: {
     value: PersonaId;
     name: string;
@@ -20,13 +20,22 @@ export interface UseCaseMapping {
     default: string;
     all: string[];
 }
-export declare const USE_CASE_TEMPLATES: Record<UseCaseId, UseCaseMapping>;
+export declare const USE_CASE_TEMPLATES: Record<string, UseCaseMapping>;
+/**
+ * Register a use case contributed by a pack.
+ * Adds the use case choice and template mapping so it appears in fw init.
+ */
+export declare function registerPackUseCase(useCase: {
+    id: string;
+    name: string;
+    description: string;
+}, templates: string[]): void;
 /**
  * Select the template for a given persona and use-case.
  * For lowcode, returns the full list when the category has multiple templates.
  * For nocode/vibecoder, always returns the single default.
  */
-export declare function selectTemplateForPersona(persona: PersonaId, useCase: UseCaseId): {
+export declare function selectTemplateForPersona(persona: PersonaId, useCase: UseCaseId | string): {
     template: string;
     choices?: string[];
 };
@@ -58,6 +67,8 @@ export interface PrintNextStepsOptions {
     mcpConfigured?: string[];
     /** When true, skip persona-specific guidance (the agent handles it) */
     agentLaunched?: boolean;
+    /** When true, the workflow was auto-compiled and npm start works immediately */
+    compiled?: boolean;
 }
 export declare function printNextSteps(opts: PrintNextStepsOptions): void;
 /** Maps each persona to the fw_context preset used for agent knowledge bootstrap. */
@@ -66,17 +77,17 @@ export declare const AGENT_CONTEXT_PRESETS: Record<PersonaId, string>;
  * Generate the initial prompt for a CLI agent (Claude Code, Codex).
  * Interpolates project name and template into the persona-specific template.
  */
-export declare function generateAgentPrompt(projectName: string, persona: PersonaId, template: string): string;
+export declare function generateAgentPrompt(projectName: string, persona: PersonaId, template: string, useCaseDescription?: string): string;
 /**
  * Generate a shorter prompt suitable for pasting into a GUI editor.
  * Persona-aware but more concise than the full agent prompt.
  */
-export declare function generateEditorPrompt(projectName: string, persona: PersonaId, template: string): string;
+export declare function generateEditorPrompt(projectName: string, persona: PersonaId, template: string, useCaseDescription?: string): string;
 /**
  * Generate the full content for a PROJECT_SETUP.md file.
  * Includes the agent prompt plus project context.
  */
-export declare function generateSetupPromptFile(projectName: string, persona: PersonaId, template: string, filesCreated: string[]): string;
+export declare function generateSetupPromptFile(projectName: string, persona: PersonaId, template: string, filesCreated: string[], useCaseDescription?: string): string;
 /**
  * Print a copyable prompt in a bordered box.
  * Long lines are word-wrapped to fit within the box.

package/dist/cli/commands/init-personas.js

@@ -2,8 +2,9 @@
  * Persona-specific logic for the init command.
  * Types, use-case mappings, template selection, and post-scaffold output.
  */
+import { execSync } from 'child_process';
 import { logger } from '../utils/logger.js';
-import { workflowTemplates } from '../templates/index.js';
+import { getAllWorkflowTemplates } from '../templates/index.js';
 import { buildContext } from '../../context/index.js';
 // ── Prompt choices ───────────────────────────────────────────────────────────
 export const PERSONA_CHOICES = [
@@ -24,7 +25,6 @@ export const USE_CASE_CHOICES = [
     { value: 'ai', name: 'AI agent', description: 'LLM with tools, reasoning, or retrieval' },
     { value: 'api', name: 'API / webhook', description: 'HTTP endpoints and integrations' },
     { value: 'automation', name: 'Automation', description: 'Conditional logic, error handling, routing' },
-    { value: 'cicd', name: 'CI/CD pipeline', description: 'Test, build, and deploy workflows' },
     { value: 'minimal', name: 'Something else', description: 'Start with a minimal template' },
 ];
 export const USE_CASE_TEMPLATES = {
@@ -32,9 +32,33 @@ export const USE_CASE_TEMPLATES = {
     ai: { default: 'ai-agent', all: ['ai-agent', 'ai-react', 'ai-rag', 'ai-chat'] },
     api: { default: 'webhook', all: ['webhook'] },
     automation: { default: 'conditional', all: ['conditional', 'error-handler'] },
-    cicd: { default: 'cicd-test-deploy', all: ['cicd-test-deploy', 'cicd-docker', 'cicd-multi-env', 'cicd-matrix'] },
     minimal: { default: 'sequential', all: ['sequential'] },
 };
+/**
+ * Register a use case contributed by a pack.
+ * Adds the use case choice and template mapping so it appears in fw init.
+ */
+export function registerPackUseCase(useCase, templates) {
+    // Add to choices if not already present
+    if (!USE_CASE_CHOICES.some((c) => c.value === useCase.id)) {
+        // Insert before "minimal" (last entry)
+        const minimalIdx = USE_CASE_CHOICES.findIndex((c) => c.value === 'minimal');
+        const entry = { value: useCase.id, name: useCase.name, description: useCase.description };
+        if (minimalIdx >= 0) {
+            USE_CASE_CHOICES.splice(minimalIdx, 0, entry);
+        }
+        else {
+            USE_CASE_CHOICES.push(entry);
+        }
+    }
+    // Add template mapping
+    if (!USE_CASE_TEMPLATES[useCase.id] && templates.length > 0) {
+        USE_CASE_TEMPLATES[useCase.id] = {
+            default: templates[0],
+            all: templates,
+        };
+    }
+}
 /**
  * Select the template for a given persona and use-case.
  * For lowcode, returns the full list when the category has multiple templates.
@@ -56,7 +80,7 @@ export function selectTemplateForPersona(persona, useCase) {
  */
 export function getTemplateSubChoices(templateIds) {
     return templateIds.map((id) => {
-        const tmpl = workflowTemplates.find((t) => t.id === id);
+        const tmpl = getAllWorkflowTemplates().find((t) => t.id === id);
         return {
             value: id,
             name: id,
@@ -215,7 +239,7 @@ export function ${fnName}(
 `;
 }
 export function printNextSteps(opts) {
-    const { projectName, persona, displayDir, installSkipped, workflowCode, workflowFile, agentLaunched } = opts;
+    const { projectName, persona, displayDir, installSkipped, workflowCode, workflowFile, agentLaunched, compiled } = opts;
     // Workflow preview
     if (workflowCode) {
         const preview = extractWorkflowPreview(workflowCode);
@@ -247,7 +271,13 @@ export function printNextSteps(opts) {
     if (installSkipped) {
         logger.log('    npm install');
     }
-    logger.log('    npm run dev');
+    if (compiled) {
+        logger.log(`    npm start${' '.repeat(14)}${logger.dim('Run your compiled workflow')}`);
+        logger.log(`    npm run dev${' '.repeat(12)}${logger.dim('Recompile + run (after editing)')}`);
+    }
+    else {
+        logger.log('    npm run dev');
+    }
     // Persona-specific guidance (skip if agent was launched, it handles this)
     if (!agentLaunched) {
         if (persona === 'nocode') {
@@ -282,27 +312,26 @@ function printNocodeGuidance(_projectName) {
 }
 function printVibecoderGuidance() {
     logger.newline();
-    logger.log('  With your AI editor connected, try:');
+    logger.log(`  ${logger.bold('Describe what you want, AI handles the code.')}`);
     logger.newline();
     logger.log(`    ${logger.dim('"Add a retry loop when the model call fails"')}`);
-    logger.log(`    ${logger.dim('"Add a tool that searches a knowledge base"')}`);
+    logger.log(`    ${logger.dim('"Connect this to a Postgres database"')}`);
+    logger.log(`    ${logger.dim('"Show me a diagram of the current workflow"')}`);
     logger.newline();
-    logger.log(`  ${logger.bold('Commands you\'ll use')}`);
+    logger.log(`  ${logger.bold('When you want to see the structure')}`);
     logger.newline();
-    logger.log(`    flow-weaver diagram src/*.ts     ${logger.dim('See a visual diagram')}`);
-    logger.log(`    flow-weaver validate src/*.ts    ${logger.dim('Check for errors')}`);
-    logger.log(`    flow-weaver templates            ${logger.dim('Browse all templates')}`);
+    logger.log(`    npm run diagram                  ${logger.dim('Visual diagram of your workflow')}`);
 }
 function printLowcodeGuidance() {
     logger.newline();
-    logger.log(`  ${logger.bold('Explore and learn')}`);
+    logger.log(`  ${logger.bold('Explore and customize')}`);
     logger.newline();
     logger.log(`    flow-weaver templates            ${logger.dim('List all 16 workflow templates')}`);
-    logger.log(`    flow-weaver create workflow ...   ${logger.dim('Add another workflow')}`);
-    logger.log(`    flow-weaver describe src/*.ts     ${logger.dim('See workflow structure')}`);
-    logger.log(`    flow-weaver docs annotations     ${logger.dim('Read the annotation reference')}`);
+    logger.log(`    flow-weaver describe src/*.ts     ${logger.dim('See the workflow structure')}`);
+    logger.log(`    flow-weaver docs annotations     ${logger.dim('Annotation reference')}`);
     logger.newline();
     logger.log(`  Your project includes an example in ${logger.highlight('examples/')} to study.`);
+    logger.log(`  With MCP connected, AI can help modify nodes and connections.`);
 }
 function printExpertGuidance() {
     logger.newline();
@@ -370,26 +399,32 @@ Then ask what I'd like to build.`,
  * Generate the initial prompt for a CLI agent (Claude Code, Codex).
  * Interpolates project name and template into the persona-specific template.
  */
-export function generateAgentPrompt(projectName, persona, template) {
-    return AGENT_PROMPTS[persona]
+export function generateAgentPrompt(projectName, persona, template, useCaseDescription) {
+    let prompt = AGENT_PROMPTS[persona]
         .replace(/\{name\}/g, projectName)
         .replace(/\{template\}/g, template);
+    if (useCaseDescription) {
+        // Insert the user's description after the template mention line
+        prompt = prompt.replace(/(using the .+ template\.?\n)/, `$1The user wants to build: ${useCaseDescription}\n`);
+    }
+    return prompt;
 }
 /**
  * Generate a shorter prompt suitable for pasting into a GUI editor.
  * Persona-aware but more concise than the full agent prompt.
  */
-export function generateEditorPrompt(projectName, persona, template) {
+export function generateEditorPrompt(projectName, persona, template, useCaseDescription) {
     const preset = AGENT_CONTEXT_PRESETS[persona];
     const bootstrap = `Start by calling fw_context(preset="${preset}", profile="assistant") to learn Flow Weaver.`;
+    const desc = useCaseDescription ? ` I want to build: ${useCaseDescription}.` : '';
     if (persona === 'nocode') {
-        return `${bootstrap}\nThis is a Flow Weaver project called "${projectName}" using the ${template} template. Show me the workflow diagram, walk me through what each step does in plain language, then ask me what I want to build. Keep it simple, no code.`;
+        return `${bootstrap}\nThis is a Flow Weaver project called "${projectName}" using the ${template} template.${desc} Show me the workflow diagram, walk me through what each step does in plain language, then ask me what I want to build. Keep it simple, no code.`;
     }
     if (persona === 'vibecoder') {
-        return `${bootstrap}\nThis is a Flow Weaver project called "${projectName}" using the ${template} template. Show me the workflow diagram, then let's iterate on it together. I'll describe what I want and you handle the implementation.`;
+        return `${bootstrap}\nThis is a Flow Weaver project called "${projectName}" using the ${template} template.${desc} Show me the workflow diagram, then let's iterate on it together. I'll describe what I want and you handle the implementation.`;
     }
     if (persona === 'lowcode') {
-        return `${bootstrap}\nThis is a Flow Weaver project called "${projectName}" using the ${template} template. Show me the workflow diagram and explain the template, then help me customize it for my use case.`;
+        return `${bootstrap}\nThis is a Flow Weaver project called "${projectName}" using the ${template} template.${desc} Show me the workflow diagram and explain the template, then help me customize it for my use case.`;
     }
     return `${bootstrap}\nFlow Weaver project "${projectName}" (template: ${template}). Show the workflow diagram and implementation status.`;
 }
@@ -397,8 +432,8 @@ export function generateEditorPrompt(projectName, persona, template) {
  * Generate the full content for a PROJECT_SETUP.md file.
  * Includes the agent prompt plus project context.
  */
-export function generateSetupPromptFile(projectName, persona, template, filesCreated) {
-    const prompt = generateAgentPrompt(projectName, persona, template);
+export function generateSetupPromptFile(projectName, persona, template, filesCreated, useCaseDescription) {
+    const prompt = generateAgentPrompt(projectName, persona, template, useCaseDescription);
     // Embed Flow Weaver knowledge directly so the file is self-contained.
     // GUI editors may not have MCP tools configured when first reading this file.
     const contextResult = buildContext({ preset: 'core', profile: 'assistant' });
@@ -481,6 +516,20 @@ export function printCopyablePrompt(prompt) {
         logger.log(`  │ ${padded} │`);
     }
     logger.log(`  ${'└' + '─'.repeat(width) + '┘'}`);
+    // Auto-copy to clipboard (best-effort)
+    try {
+        const clipCmd = process.platform === 'darwin' ? 'pbcopy'
+            : process.platform === 'linux' ? 'xclip -selection clipboard'
+                : null;
+        if (clipCmd) {
+            execSync(clipCmd, { input: prompt, stdio: ['pipe', 'pipe', 'pipe'], timeout: 3000 });
+            logger.newline();
+            logger.success('Copied to clipboard');
+        }
+    }
+    catch {
+        // Clipboard not available, box is still there
+    }
 }
 /** Default for the "Launch agent?" confirm prompt per persona */
 export const AGENT_LAUNCH_DEFAULTS = {

package/dist/cli/commands/init.d.ts

@@ -4,7 +4,7 @@
  */
 import type { ToolId } from './mcp-setup.js';
 import type { TModuleFormat } from '../../ast/types.js';
-import type { PersonaId, UseCaseId } from './init-personas.js';
+import type { PersonaId } from './init-personas.js';
 export interface InitOptions {
     name?: string;
     template?: string;
@@ -28,7 +28,9 @@ export interface InitConfig {
     git: boolean;
     force: boolean;
     persona: PersonaId;
-    useCase?: UseCaseId;
+    useCase?: string;
+    /** Free-text description when user picked "Something else" */
+    useCaseDescription?: string;
     mcp: boolean;
 }
 export interface InitReport {
@@ -76,6 +78,7 @@ interface AgentHandoffOptions {
     cliTools: ToolId[];
     guiTools: ToolId[];
     filesCreated: string[];
+    useCaseDescription?: string;
 }
 /**
  * After init + MCP setup, offer to launch a CLI agent or generate a prompt for GUI editors.