luxlabs 1.0.17 → 1.0.19

package/commands/{workflows.js → flows.js}

@@ -6,6 +6,7 @@ const {
   getAuthHeaders,
   isAuthenticated,
   getOrgId,
+  getProjectId,
   getFlowsDir,
   loadLocalFlow,
   saveLocalFlow,
@@ -73,7 +74,7 @@ async function saveWorkflowDraft(workflowId, config) {
   );
 }
 
-async function handleWorkflows(args) {
+async function handleFlows(args) {
   // Check authentication
   if (!isAuthenticated()) {
     console.log(
@@ -88,18 +89,18 @@ async function handleWorkflows(args) {
 
   if (!command) {
     console.log(`
-${chalk.bold('Usage:')} lux workflows <command> [args]
+${chalk.bold('Usage:')} lux flows <command> [args]
 
 ${chalk.bold('Commands:')}
-  list                        List all workflows (from local storage)
-  get <id>                    Get workflow details with config
-  status <id>                 Show sync status for a workflow
-  create <name> [desc] [--publish]  Create workflow (use --publish to publish immediately)
-  init <name> [desc] [--publish]    Initialize workflow (alias for create)
+  list                        List all flows (from local storage)
+  get <id>                    Get flow details with config
+  status <id>                 Show sync status for a flow
+  create <name> [desc] [--publish]  Create flow (use --publish to publish immediately)
+  init <name> [desc] [--publish]    Initialize flow (alias for create)
   save <id> <config-file>     Save draft config from file (local)
-  sync                        Sync published workflows from cloud
-  publish <id>                Publish workflow to cloud
-  delete <id>                 Delete a local workflow
+  sync                        Sync published flows from cloud
+  publish <id>                Publish flow to cloud
+  delete <id>                 Delete a local flow
   diff <id>                   Show local vs published differences
 
 ${chalk.bold('Execution History:')}
@@ -120,29 +121,40 @@ ${chalk.bold('Webhook Commands:')}
   webhook-accept <id>         Accept webhook format and save variables
   webhook-decline <id>        Decline webhook and reset session
 
+${chalk.bold('Execution Commands:')}
+  executions <id>             List recent executions for a flow
+  execution <id> <exec-id>    Get details of a specific execution
+  test <id> [--data]          Test a flow with sample data
+  last <id>                   Show the last execution result
+
 ${chalk.bold('Examples:')}
-  lux workflows list
-  lux workflows get flow_123
-  lux workflows status flow_123
-  lux workflows create "My Workflow" "Description"
-  lux workflows create "My Workflow" --publish    # Create and publish immediately
-  lux flow init "My Workflow" --publish
-  lux workflows save flow_123 ./config.json
-  lux workflows sync
-  lux workflows publish flow_123
-  lux workflows diff flow_123
+  lux flows list
+  lux flows get flow_123
+  lux flows status flow_123
+  lux flows create "My Flow" "Description"
+  lux flows create "My Flow" --publish    # Create and publish immediately
+  lux flows init "My Flow" --publish
+  lux flows save flow_123 ./config.json
+  lux flows sync
+  lux flows publish flow_123
+  lux flows diff flow_123
 
   ${chalk.bold('Execution history:')}
-  lux flow executions my-flow-id
-  lux flow executions my-flow-id --limit 50
-  lux flow execution my-flow-id exec_abc123
-  lux flow node my-flow-id exec_abc123 node-1
-
-  ${chalk.bold('Webhook workflow:')}
-  lux flow webhook-url flow_123
-  lux flow webhook-listen flow_123
-  lux flow webhook-poll flow_123
-  lux flow webhook-accept flow_123
+  lux flows executions my-flow-id
+  lux flows executions my-flow-id --limit 50
+  lux flows execution my-flow-id exec_abc123
+  lux flows node my-flow-id exec_abc123 node-1
+
+  ${chalk.bold('Webhook:')}
+  lux flows webhook-url flow_123
+  lux flows webhook-listen flow_123
+  lux flows webhook-poll flow_123
+  lux flows webhook-accept flow_123
+
+  ${chalk.bold('Execution debugging:')}
+  lux flows executions my-flow       # List recent executions
+  lux flows last my-flow             # Show last execution result
+  lux flows test my-flow --data '{"name":"test"}'  # Test with data
 `);
     process.exit(0);
   }
@@ -153,14 +165,14 @@ ${chalk.bold('Examples:')}
   try {
     switch (command) {
       case 'list': {
-        info('Loading workflows from local storage...');
+        info('Loading flows from local storage...');
         const localFlows = listLocalFlows();
 
         if (localFlows.length === 0) {
-          console.log('\n(No local workflows found)');
-          console.log(chalk.gray('Run "lux workflows sync" to sync from cloud, or "lux workflows create" to create one.\n'));
+          console.log('\n(No local flows found)');
+          console.log(chalk.gray('Run "lux flows sync" to sync from cloud, or "lux flows create" to create one.\n'));
         } else {
-          console.log(`\nFound ${localFlows.length} workflow(s):\n`);
+          console.log(`\nFound ${localFlows.length} flow(s):\n`);
 
           // Color-code sync status
           const statusColors = {
@@ -191,12 +203,12 @@ ${chalk.bold('Examples:')}
       }
 
       case 'status': {
-        requireArgs(args.slice(1), 1, 'lux workflows status <id>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 1, 'lux flows status <id>');
+        const flowId = args[1];
 
-        const flow = loadLocalFlow(workflowId);
+        const flow = loadLocalFlow(flowId);
         if (!flow) {
-          error(`Workflow not found locally: ${workflowId}`);
+          error(`Flow not found locally: ${flowId}`);
           break;
         }
 
@@ -219,8 +231,8 @@ ${chalk.bold('Examples:')}
           conflict: chalk.red,
         };
 
-        console.log(`\n📝 Workflow: ${flow.name}`);
-        console.log(`   ID: ${workflowId}`);
+        console.log(`\n📝 Flow: ${flow.name}`);
+        console.log(`   ID: ${flowId}`);
         console.log(`   Sync Status: ${statusColors[syncStatus](syncStatus)}`);
         console.log(`   Local Version: ${flow.localVersion || 1}`);
         console.log(`   Published Version: ${flow.publishedVersion || '(never published)'}`);
@@ -231,17 +243,17 @@ ${chalk.bold('Examples:')}
         console.log(`   Edges: ${flow.edges?.length || 0}`);
 
         if (syncStatus === 'conflict') {
-          console.log(chalk.red('\n⚠️  This workflow has conflicts with the cloud version.'));
+          console.log(chalk.red('\n⚠️  This flow has conflicts with the cloud version.'));
           console.log(chalk.gray('   Use the Lux Studio app to resolve conflicts.\n'));
         } else if (syncStatus === 'dirty') {
-          console.log(chalk.yellow('\n📤 This workflow has unpublished local changes.'));
-          console.log(chalk.gray('   Run "lux workflows publish ' + workflowId + '" to publish.\n'));
+          console.log(chalk.yellow('\n📤 This flow has unpublished local changes.'));
+          console.log(chalk.gray('   Run "lux flows publish ' + flowId + '" to publish.\n'));
         }
         break;
       }
 
       case 'sync': {
-        info('Syncing workflows from cloud...');
+        info('Syncing flows from cloud...');
 
         const { data } = await axios.get(`${apiUrl}/api/workflows?include_config=true`, {
           headers: getAuthHeaders(),
@@ -345,18 +357,18 @@ ${chalk.bold('Examples:')}
         console.log(`   New from cloud: ${newFromCloud}`);
         if (conflicts > 0) {
           console.log(chalk.red(`   Conflicts: ${conflicts}`));
-          console.log(chalk.gray('\n   Use "lux workflows list" to see workflows with conflicts.'));
+          console.log(chalk.gray('\n   Use "lux flows list" to see flows with conflicts.'));
         }
         break;
       }
 
       case 'delete': {
-        requireArgs(args.slice(1), 1, 'lux workflows delete <id>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 1, 'lux flows delete <id>');
+        const flowId = args[1];
 
-        const flow = loadLocalFlow(workflowId);
+        const flow = loadLocalFlow(flowId);
         if (!flow) {
-          error(`Workflow not found locally: ${workflowId}`);
+          error(`Flow not found locally: ${flowId}`);
           break;
         }
 
@@ -365,23 +377,23 @@ ${chalk.bold('Examples:')}
           console.log(chalk.gray('   This only deletes the local copy. The published version remains in the cloud.\n'));
         }
 
-        deleteLocalFlow(workflowId);
-        success(`Deleted local workflow: ${flow.name}`);
+        deleteLocalFlow(flowId);
+        success(`Deleted local flow: ${flow.name}`);
         break;
       }
 
       case 'get': {
-        requireArgs(args.slice(1), 1, 'lux workflows get <id>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 1, 'lux flows get <id>');
+        const flowId = args[1];
 
-        info(`Loading workflow: ${workflowId}`);
+        info(`Loading flow: ${flowId}`);
         const { data } = await axios.get(
-          `${apiUrl}/api/workflows/${workflowId}`,
+          `${apiUrl}/api/workflows/${flowId}`,
           { headers: getAuthHeaders() }
         );
 
         if (!data.workflow) {
-          error(`Workflow not found: ${workflowId}`);
+          error(`Flow not found: ${flowId}`);
         }
 
         const workflow = data.workflow;
@@ -409,7 +421,7 @@ ${chalk.bold('Examples:')}
           args.splice(publishFlagIndex, 1); // Remove flag from args
         }
 
-        requireArgs(args.slice(1), 1, 'lux workflows create <name> [description] [--publish]');
+        requireArgs(args.slice(1), 1, 'lux flows create <name> [description] [--publish]');
         const name = args[1];
         const description = args[2] || '';
 
@@ -442,15 +454,15 @@ ${chalk.bold('Examples:')}
           updatedAt: now,
         };
 
-        info(`Creating local workflow: ${name}`);
+        info(`Creating local flow: ${name}`);
 
         if (saveLocalFlow(flowId, newFlow)) {
-          success(`Workflow created locally!`);
+          success(`Flow created locally!`);
           console.log(`   ID: ${flowId}`);
 
           // If --publish flag was provided, publish immediately
           if (shouldPublish) {
-            info(`Publishing workflow to cloud...`);
+            info(`Publishing flow to cloud...`);
 
             try {
               const publishConfig = {
@@ -473,7 +485,7 @@ ${chalk.bold('Examples:')}
 
               const cloudId = createResponse.data.workflow?.id || createResponse.data.workflow?.workflow_id;
               if (!cloudId) {
-                throw new Error('No workflow ID returned from cloud');
+                throw new Error('No flow ID returned from cloud');
               }
 
               info(`Created in cloud with ID: ${cloudId}`);
@@ -506,41 +518,41 @@ ${chalk.bold('Examples:')}
               };
               saveLocalFlow(flowId, updatedFlow);
 
-              success('Workflow published!');
+              success('Flow published!');
               console.log(`   Cloud ID: ${cloudId}`);
               console.log(`   Status: ${chalk.green('published')}`);
               console.log(`   Version: ${newVersion}`);
             } catch (publishError) {
               error(`Failed to publish: ${publishError.response?.data?.error || publishError.message}`);
               console.log(`   Status: ${chalk.gray('draft')}`);
-              console.log(chalk.gray(`\nRun "lux workflows publish ${flowId}" to try again.`));
+              console.log(chalk.gray(`\nRun "lux flows publish ${flowId}" to try again.`));
             }
           } else {
             console.log(`   Status: ${chalk.gray('draft')}`);
-            console.log(chalk.gray(`\n   This workflow is local only. Run "lux workflows publish ${flowId}" to publish to cloud.`));
+            console.log(chalk.gray(`\n   This flow is local only. Run "lux flows publish ${flowId}" to publish to cloud.`));
           }
         } else {
-          error('Failed to create workflow. Make sure you are authenticated.');
+          error('Failed to create flow. Make sure you are authenticated.');
         }
         break;
       }
 
       case 'save': {
-        requireArgs(args.slice(1), 2, 'lux workflows save <id> <config-file>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 2, 'lux flows save <id> <config-file>');
+        const flowId = args[1];
         const configFile = args[2];
 
         // Load existing local flow
-        const existingFlow = loadLocalFlow(workflowId);
+        const existingFlow = loadLocalFlow(flowId);
         if (!existingFlow) {
-          error(`Workflow not found locally: ${workflowId}`);
-          console.log(chalk.gray('Run "lux workflows sync" to sync from cloud first.'));
+          error(`Flow not found locally: ${flowId}`);
+          console.log(chalk.gray('Run "lux flows sync" to sync from cloud first.'));
           break;
         }
 
         info(`Reading config from: ${configFile}`);
         const configJson = readFile(configFile);
-        const config = parseJson(configJson, 'workflow config');
+        const config = parseJson(configJson, 'flow config');
 
         // Update local flow with new config
         const updatedFlow = {
@@ -551,9 +563,9 @@ ${chalk.bold('Examples:')}
           updatedAt: new Date().toISOString(),
         };
 
-        info(`Saving to local storage: ${workflowId}`);
-        if (saveLocalFlow(workflowId, updatedFlow)) {
-          success('Workflow saved locally!');
+        info(`Saving to local storage: ${flowId}`);
+        if (saveLocalFlow(flowId, updatedFlow)) {
+          success('Flow saved locally!');
           console.log(`   Local Version: ${updatedFlow.localVersion}`);
 
           // Show sync status
@@ -564,22 +576,22 @@ ${chalk.bold('Examples:')}
             console.log(`   Status: ${chalk.yellow('dirty')} (has unpublished changes)`);
           }
 
-          console.log(chalk.gray(`\nRun "lux workflows publish ${workflowId}" to publish to cloud.`));
+          console.log(chalk.gray(`\nRun "lux flows publish ${flowId}" to publish to cloud.`));
         } else {
-          error('Failed to save workflow locally.');
+          error('Failed to save flow locally.');
         }
         break;
       }
 
       case 'publish': {
-        requireArgs(args.slice(1), 1, 'lux workflows publish <id>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 1, 'lux flows publish <id>');
+        const flowId = args[1];
 
         // Load local flow
-        const localFlow = loadLocalFlow(workflowId);
+        const localFlow = loadLocalFlow(flowId);
         if (!localFlow) {
-          error(`Workflow not found locally: ${workflowId}`);
-          console.log(chalk.gray('Run "lux workflows sync" to sync from cloud first.'));
+          error(`Flow not found locally: ${flowId}`);
+          console.log(chalk.gray('Run "lux flows sync" to sync from cloud first.'));
           break;
         }
 
@@ -587,12 +599,12 @@ ${chalk.bold('Examples:')}
         if (localFlow.cloudVersion && localFlow.publishedVersion &&
             localFlow.cloudVersion > localFlow.publishedVersion &&
             localFlow.localVersion > localFlow.publishedVersion) {
-          error('Cannot publish: workflow has conflicts with cloud version.');
+          error('Cannot publish: flow has conflicts with cloud version.');
           console.log(chalk.gray('Resolve conflicts in Lux Studio first.'));
           break;
         }
 
-        info(`Publishing workflow: ${workflowId}`);
+        info(`Publishing flow: ${flowId}`);
 
         // Publish directly to cloud with config in request body
         const publishConfig = {
@@ -603,7 +615,7 @@ ${chalk.bold('Examples:')}
         };
 
         const { data } = await axios.post(
-          `${apiUrl}/api/workflows/${workflowId}/publish`,
+          `${apiUrl}/api/workflows/${flowId}/publish`,
           {
             name: localFlow.name,
             description: localFlow.description,
@@ -631,9 +643,9 @@ ${chalk.bold('Examples:')}
           cloudPublishedAt: now,
           cloudStatus: 'published',
         };
-        saveLocalFlow(workflowId, updatedFlow);
+        saveLocalFlow(flowId, updatedFlow);
 
-        success('Workflow published!');
+        success('Flow published!');
         console.log(`   Name: ${localFlow.name}`);
         console.log(`   Version: ${newVersion}`);
         console.log(`   Status: ${chalk.green('synced')}`);
@@ -641,17 +653,17 @@ ${chalk.bold('Examples:')}
       }
 
       case 'diff': {
-        requireArgs(args.slice(1), 1, 'lux workflows diff <id>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 1, 'lux flows diff <id>');
+        const flowId = args[1];
 
         // Load local flow
-        const localFlow = loadLocalFlow(workflowId);
+        const localFlow = loadLocalFlow(flowId);
         if (!localFlow) {
-          error(`Workflow not found locally: ${workflowId}`);
+          error(`Flow not found locally: ${flowId}`);
           break;
         }
 
-        info(`Comparing local vs published for: ${workflowId}`);
+        info(`Comparing local vs published for: ${flowId}`);
 
         const localConfig = {
           nodes: localFlow.nodes || [],
@@ -660,12 +672,12 @@ ${chalk.bold('Examples:')}
 
         // Check if never published
         if (!localFlow.publishedVersion) {
-          console.log('\n📝 NEW WORKFLOW (not yet published)\n');
+          console.log('\n📝 NEW FLOW (not yet published)\n');
           console.log(`   Name: ${localFlow.name}`);
           console.log(`   Local Version: ${localFlow.localVersion || 1}`);
           console.log(`   Nodes: ${localConfig.nodes.length}`);
           console.log(`   Edges: ${localConfig.edges.length}`);
-          console.log(chalk.gray(`\nRun "lux workflows publish ${workflowId}" to publish.\n`));
+          console.log(chalk.gray(`\nRun "lux flows publish ${flowId}" to publish.\n`));
           break;
         }
 
@@ -697,17 +709,17 @@ ${chalk.bold('Examples:')}
           console.log(`   Published Version: ${localFlow.publishedVersion}`);
           console.log(`   Nodes: ${localConfig.nodes.length}`);
           console.log(`   Edges: ${localConfig.edges.length}`);
-          console.log(chalk.gray(`\nRun "lux workflows publish ${workflowId}" to publish changes.\n`));
+          console.log(chalk.gray(`\nRun "lux flows publish ${flowId}" to publish changes.\n`));
         }
         break;
       }
 
       case 'webhook-url': {
-        requireArgs(args.slice(1), 1, 'lux flow webhook-url <flow-id>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 1, 'lux flows webhook-url <flow-id>');
+        const flowId = args[1];
 
-        info(`Getting webhook URL for: ${workflowId}`);
-        const tokenData = await getWebhookToken(workflowId);
+        info(`Getting webhook URL for: ${flowId}`);
+        const tokenData = await getWebhookToken(flowId);
 
         console.log(`\n📍 Webhook URL:\n${tokenData.webhookUrl}\n`);
         console.log(`📊 Status:`);
@@ -715,17 +727,17 @@ ${chalk.bold('Examples:')}
         console.log(`   Webhook Trigger Enabled: ${tokenData.webhookTrigger ? '✅ Yes' : '❌ No'}\n`);
 
         if (!tokenData.formatConfirmed) {
-          console.log(chalk.yellow('ℹ️  Run "lux flow webhook-listen" to capture a sample webhook'));
+          console.log(chalk.yellow('ℹ️  Run "lux flows webhook-listen" to capture a sample webhook'));
         }
         break;
       }
 
       case 'webhook-listen': {
-        requireArgs(args.slice(1), 1, 'lux flow webhook-listen <flow-id>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 1, 'lux flows webhook-listen <flow-id>');
+        const flowId = args[1];
 
-        info(`Starting webhook listening session for: ${workflowId}`);
-        const tokenData = await getWebhookToken(workflowId);
+        info(`Starting webhook listening session for: ${flowId}`);
+        const tokenData = await getWebhookToken(flowId);
 
         // Start listening session
         await axios.post(`${WEBHOOK_WORKER_URL}/listening/start/${tokenData.token}`);
@@ -734,15 +746,15 @@ ${chalk.bold('Examples:')}
         console.log(`\n📡 Now listening for webhooks at:\n${tokenData.webhookUrl}\n`);
         console.log('Session expires in 5 minutes.');
         console.log(`\nSend a webhook request to the URL above, then run:`);
-        console.log(chalk.white(`   lux flow webhook-poll ${workflowId}\n`));
+        console.log(chalk.white(`   lux flows webhook-poll ${flowId}\n`));
         break;
       }
 
       case 'webhook-poll': {
-        requireArgs(args.slice(1), 1, 'lux flow webhook-poll <flow-id>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 1, 'lux flows webhook-poll <flow-id>');
+        const flowId = args[1];
 
-        const tokenData = await getWebhookToken(workflowId);
+        const tokenData = await getWebhookToken(flowId);
         const pollData = await getCapturedPayload(tokenData.token);
 
         // Return raw JSON response
@@ -751,20 +763,20 @@ ${chalk.bold('Examples:')}
       }
 
       case 'webhook-accept': {
-        requireArgs(args.slice(1), 1, 'lux flow webhook-accept <flow-id>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 1, 'lux flows webhook-accept <flow-id>');
+        const flowId = args[1];
 
-        info(`Accepting webhook format for: ${workflowId}`);
+        info(`Accepting webhook format for: ${flowId}`);
 
         // Step 1: Get webhook token
-        const tokenData = await getWebhookToken(workflowId);
+        const tokenData = await getWebhookToken(flowId);
 
         // Step 2: Poll for captured payload
         const pollData = await getCapturedPayload(tokenData.token);
 
         // Check if payload was captured
         if (pollData.waiting || !pollData.payload) {
-          error('No webhook captured. Run "lux flow webhook-listen" first and send a test webhook.');
+          error('No webhook captured. Run "lux flows webhook-listen" first and send a test webhook.');
           break;
         }
 
@@ -839,11 +851,11 @@ ${chalk.bold('Examples:')}
       }
 
       case 'webhook-decline': {
-        requireArgs(args.slice(1), 1, 'lux flow webhook-decline <flow-id>');
-        const workflowId = args[1];
+        requireArgs(args.slice(1), 1, 'lux flows webhook-decline <flow-id>');
+        const flowId = args[1];
 
-        info(`Declining webhook format for: ${workflowId}`);
-        const tokenData = await getWebhookToken(workflowId);
+        info(`Declining webhook format for: ${flowId}`);
+        const tokenData = await getWebhookToken(flowId);
 
         // Clear webhook schema from database
         info('Clearing webhook schema...');
@@ -858,33 +870,57 @@ ${chalk.bold('Examples:')}
         success('Webhook format declined!');
         console.log('\n✅ Schema cleared from database');
         console.log('✅ Listening session has been reset');
-        console.log(`\nRun "lux flow webhook-listen ${workflowId}" to try again.\n`);
+        console.log(`\nRun "lux flows webhook-listen ${flowId}" to try again.\n`);
         break;
       }
 
       // ============ EXECUTION HISTORY COMMANDS ============
 
       case 'executions': {
-        requireArgs(args.slice(1), 1, 'lux flow executions <flow-id> [--limit N]');
+        requireArgs(args.slice(1), 1, 'lux flows executions <flow-id> [--limit N]');
         const flowId = args[1];
 
         // Parse --limit flag
         const limitIndex = args.indexOf('--limit');
         const limit = limitIndex !== -1 && args[limitIndex + 1] ? parseInt(args[limitIndex + 1], 10) : 20;
+        const jsonOutput = args.includes('--json');
 
-        info(`Fetching execution history for: ${flowId}`);
+        const projectId = getProjectId();
+        if (!projectId || projectId === 'default') {
+          error('No project selected. Open a project in Lux Studio first.');
+          break;
+        }
 
-        const { data } = await axios.get(
-          `${apiUrl}/api/flows/${flowId}/executions?limit=${limit}`,
-          { headers: getAuthHeaders() }
-        );
+        info(`Loading executions for: ${flowId}`);
+
+        const workflowsUrl = 'https://lux-workflows.jason-a5d.workers.dev';
+        const url = `${workflowsUrl}/api/flows/${flowId}/executions?limit=${limit}&offset=0`;
+
+        const { data } = await axios.get(url, {
+          headers: {
+            ...getAuthHeaders(),
+            'X-Project-Id': projectId,
+          },
+        });
+
+        const executions = data.executions || [];
+
+        if (jsonOutput) {
+          console.log(formatJson(executions));
+          break;
+        }
 
-        if (!data.executions || data.executions.length === 0) {
-          console.log(chalk.dim('\nNo executions found for this flow.\n'));
+        if (executions.length === 0) {
+          console.log('\n(No executions found for this flow)');
+          console.log(chalk.gray('Run the flow from the interface or use "lux flows test" to create an execution.\n'));
           break;
         }
 
-        console.log(`\n📊 Execution History for: ${flowId}\n`);
+        // Load flow name
+        const flow = loadLocalFlow(flowId);
+        const flowName = flow?.name || flowId;
+
+        console.log(`\n📊 Execution History for "${flowName}" (${executions.length})\n`);
 
         // Status colors
         const statusColors = {
@@ -894,9 +930,9 @@ ${chalk.bold('Examples:')}
           cancelled: chalk.yellow,
         };
 
-        const formatted = data.executions.map((exec) => {
+        const formatted = executions.map((exec) => {
           const statusColor = statusColors[exec.status] || chalk.white;
-          const duration = exec.durationMs ? `${exec.durationMs}ms` : '-';
+          const duration = exec.duration ? `${(exec.duration / 1000).toFixed(1)}s` : (exec.durationMs ? `${exec.durationMs}ms` : '-');
           const startedAt = exec.startedAt ? new Date(exec.startedAt).toLocaleString() : '-';
           const nodeCount = exec.nodeExecutions?.length || 0;
 
@@ -914,32 +950,53 @@ ${chalk.bold('Examples:')}
         formatTable(formatted);
 
         if (data.pagination?.hasMore) {
-          console.log(chalk.dim(`\nShowing ${data.executions.length} of ${data.pagination.total} executions.`));
+          console.log(chalk.dim(`\nShowing ${executions.length} of ${data.pagination.total} executions.`));
           console.log(chalk.dim(`Use --limit N to see more.\n`));
         }
 
-        console.log(chalk.gray(`\nTo see full details: lux flow execution ${flowId} <execution-id>\n`));
+        console.log(chalk.gray(`\nTo see full details: lux flows execution ${flowId} <execution-id>\n`));
         break;
       }
 
       case 'execution': {
-        requireArgs(args.slice(1), 2, 'lux flow execution <flow-id> <execution-id>');
+        requireArgs(args.slice(1), 2, 'lux flows execution <flow-id> <execution-id>');
         const flowId = args[1];
         const executionId = args[2];
+        const jsonOutput = args.includes('--json');
 
-        info(`Fetching execution: ${executionId}`);
+        const projectId = getProjectId();
+        if (!projectId || projectId === 'default') {
+          error('No project selected. Open a project in Lux Studio first.');
+          break;
+        }
 
-        const { data } = await axios.get(
-          `${apiUrl}/api/flows/${flowId}/executions/${executionId}`,
-          { headers: getAuthHeaders() }
-        );
+        info(`Loading execution: ${executionId}`);
 
-        if (!data.execution) {
+        const workflowsUrl = 'https://lux-workflows.jason-a5d.workers.dev';
+        const url = `${workflowsUrl}/api/flows/${flowId}/executions/${executionId}`;
+
+        const { data } = await axios.get(url, {
+          headers: {
+            ...getAuthHeaders(),
+            'X-Project-Id': projectId,
+          },
+        });
+
+        const exec = data.execution;
+        if (!exec) {
           error(`Execution not found: ${executionId}`);
           break;
         }
 
-        const exec = data.execution;
+        if (jsonOutput) {
+          console.log(formatJson(exec));
+          break;
+        }
+
+        // Load flow name
+        const flow = loadLocalFlow(flowId);
+        const flowName = flow?.name || flowId;
+
         const statusColors = {
           completed: chalk.green,
           running: chalk.cyan,
@@ -950,10 +1007,10 @@ ${chalk.bold('Examples:')}
 
         console.log(`\n📋 Execution Details\n`);
         console.log(`   ID: ${exec.id}`);
-        console.log(`   Flow: ${exec.flowId}`);
+        console.log(`   Flow: ${flowName}`);
         console.log(`   Status: ${statusColor(exec.status)}`);
         console.log(`   Trigger: ${exec.triggerType || '-'}`);
-        console.log(`   Duration: ${exec.durationMs ? exec.durationMs + 'ms' : '-'}`);
+        console.log(`   Duration: ${exec.duration ? `${(exec.duration / 1000).toFixed(1)}s` : (exec.durationMs ? `${exec.durationMs}ms` : '-')}`);
         console.log(`   Started: ${exec.startedAt ? new Date(exec.startedAt).toLocaleString() : '-'}`);
         console.log(`   Completed: ${exec.completedAt ? new Date(exec.completedAt).toLocaleString() : '-'}`);
         console.log(`   Version: ${exec.flowVersion || '-'}`);
@@ -974,6 +1031,9 @@ ${chalk.bold('Examples:')}
         if (exec.outputData && Object.keys(exec.outputData).length > 0) {
           console.log(`\n${chalk.cyan('📤 Output Data:')}`);
           console.log(formatJson(exec.outputData));
+        } else if (exec.output) {
+          console.log(`\n${chalk.cyan('📤 Output:')}`);
+          console.log(formatJson(exec.output));
         }
 
         // Show node executions summary
@@ -983,7 +1043,7 @@ ${chalk.bold('Examples:')}
           const nodeFormatted = exec.nodeExecutions.map((node) => {
             const nodeStatus = node.status || 'unknown';
             const nodeStatusColor = statusColors[nodeStatus] || chalk.white;
-            const nodeDuration = node.durationMs ? `${node.durationMs}ms` : '-';
+            const nodeDuration = node.duration ? `${node.duration}ms` : (node.durationMs ? `${node.durationMs}ms` : '-');
 
             return {
               node_id: node.nodeId || node.id,
@@ -996,24 +1056,36 @@ ${chalk.bold('Examples:')}
 
           formatTable(nodeFormatted);
 
-          console.log(chalk.gray(`\nTo see node details: lux flow node ${flowId} ${executionId} <node-id>\n`));
+          console.log(chalk.gray(`\nTo see node details: lux flows node ${flowId} ${executionId} <node-id>\n`));
         }
 
         break;
       }
 
       case 'node': {
-        requireArgs(args.slice(1), 3, 'lux flow node <flow-id> <execution-id> <node-id>');
+        requireArgs(args.slice(1), 3, 'lux flows node <flow-id> <execution-id> <node-id>');
         const flowId = args[1];
         const executionId = args[2];
         const nodeId = args[3];
+        const jsonOutput = args.includes('--json');
+
+        const projectId = getProjectId();
+        if (!projectId || projectId === 'default') {
+          error('No project selected. Open a project in Lux Studio first.');
+          break;
+        }
 
         info(`Fetching node execution: ${nodeId}`);
 
-        const { data } = await axios.get(
-          `${apiUrl}/api/flows/${flowId}/executions/${executionId}`,
-          { headers: getAuthHeaders() }
-        );
+        const workflowsUrl = 'https://lux-workflows.jason-a5d.workers.dev';
+        const url = `${workflowsUrl}/api/flows/${flowId}/executions/${executionId}`;
+
+        const { data } = await axios.get(url, {
+          headers: {
+            ...getAuthHeaders(),
+            'X-Project-Id': projectId,
+          },
+        });
 
         if (!data.execution) {
           error(`Execution not found: ${executionId}`);
@@ -1034,6 +1106,11 @@ ${chalk.bold('Examples:')}
           break;
         }
 
+        if (jsonOutput) {
+          console.log(formatJson(nodeExec));
+          break;
+        }
+
         const statusColors = {
           completed: chalk.green,
           running: chalk.cyan,
@@ -1048,7 +1125,7 @@ ${chalk.bold('Examples:')}
         console.log(`   Type: ${nodeExec.nodeType || '-'}`);
         console.log(`   Label: ${nodeExec.label || '-'}`);
         console.log(`   Status: ${statusColor(nodeExec.status || 'unknown')}`);
-        console.log(`   Duration: ${nodeExec.durationMs ? nodeExec.durationMs + 'ms' : '-'}`);
+        console.log(`   Duration: ${nodeExec.duration ? `${nodeExec.duration}ms` : (nodeExec.durationMs ? `${nodeExec.durationMs}ms` : '-')}`);
         console.log(`   Started: ${nodeExec.startedAt ? new Date(nodeExec.startedAt).toLocaleString() : '-'}`);
         console.log(`   Completed: ${nodeExec.completedAt ? new Date(nodeExec.completedAt).toLocaleString() : '-'}`);
 
@@ -1085,9 +1162,208 @@ ${chalk.bold('Examples:')}
         break;
       }
 
+      case 'last': {
+        requireArgs(args.slice(1), 1, 'lux flows last <flow-id>');
+        const flowId = args[1];
+        const jsonOutput = args.includes('--json');
+
+        const projectId = getProjectId();
+        if (!projectId || projectId === 'default') {
+          error('No project selected. Open a project in Lux Studio first.');
+          break;
+        }
+
+        info(`Loading last execution for: ${flowId}`);
+
+        const workflowsUrl = 'https://lux-workflows.jason-a5d.workers.dev';
+        const listUrl = `${workflowsUrl}/api/flows/${flowId}/executions?limit=1&offset=0`;
+
+        const { data: listData } = await axios.get(listUrl, {
+          headers: {
+            ...getAuthHeaders(),
+            'X-Project-Id': projectId,
+          },
+        });
+
+        const executions = listData.executions || [];
+        if (executions.length === 0) {
+          console.log('\n(No executions found for this flow)');
+          console.log(chalk.gray('Run the flow from the interface or use "lux flows test" to create an execution.\n'));
+          break;
+        }
+
+        const lastExecId = executions[0].id;
+        const execUrl = `${workflowsUrl}/api/flows/${flowId}/executions/${lastExecId}`;
+
+        const { data: execData } = await axios.get(execUrl, {
+          headers: {
+            ...getAuthHeaders(),
+            'X-Project-Id': projectId,
+          },
+        });
+
+        const exec = execData.execution;
+
+        if (jsonOutput) {
+          console.log(formatJson(exec));
+          break;
+        }
+
+        // Load flow name
+        const flow = loadLocalFlow(flowId);
+        const flowName = flow?.name || flowId;
+
+        const status = exec.status === 'completed' ? chalk.green('✓ Success') :
+                       exec.status === 'failed' ? chalk.red('✗ Failed') :
+                       chalk.yellow('⏳ ' + exec.status);
+        const timestamp = new Date(exec.startedAt).toLocaleString();
+        const duration = exec.duration ? `${(exec.duration / 1000).toFixed(1)}s` : '-';
+
+        console.log(`\nLast Execution for "${flowName}"\n`);
+        console.log(`  Status: ${status}`);
+        console.log(`  Started: ${timestamp}`);
+        console.log(`  Duration: ${duration}`);
+        console.log(`  ID: ${exec.id}`);
+
+        if (exec.nodeExecutions && exec.nodeExecutions.length > 0) {
+          console.log(`\n  Node Results:`);
+          exec.nodeExecutions.forEach((node, i) => {
+            const nodeStatus = node.status === 'completed' ? chalk.green('✓') :
+                               node.status === 'failed' ? chalk.red('✗') :
+                               chalk.yellow('⏳');
+            const nodeDuration = node.duration ? `${node.duration}ms` : '-';
+            let outputPreview = '';
+            if (node.output) {
+              const outputStr = JSON.stringify(node.output);
+              outputPreview = outputStr.length > 60 ? outputStr.substring(0, 60) + '...' : outputStr;
+              outputPreview = chalk.gray(` → ${outputPreview}`);
+            }
+            if (node.error) {
+              outputPreview = chalk.red(` → Error: ${node.error}`);
+            }
+            console.log(`    ${i + 1}. ${node.nodeId}  ${nodeStatus}  ${nodeDuration}${outputPreview}`);
+          });
+        }
+
+        if (exec.output) {
+          console.log(`\n  Final Output:`);
+          console.log(formatJson(exec.output).split('\n').map(l => '    ' + l).join('\n'));
+        }
+
+        if (exec.error) {
+          console.log(chalk.red(`\n  Error: ${exec.error}`));
+        }
+
+        console.log('');
+        break;
+      }
+
+      case 'test': {
+        requireArgs(args.slice(1), 1, 'lux flows test <flow-id> [--data <json>] [--data-file <path>]');
+        const flowId = args[1];
+        const jsonOutput = args.includes('--json');
+
+        // Parse --data or --data-file arguments
+        let testData = {};
+        const dataIndex = args.indexOf('--data');
+        const dataFileIndex = args.indexOf('--data-file');
+
+        if (dataIndex !== -1 && args[dataIndex + 1]) {
+          testData = parseJson(args[dataIndex + 1], 'test data');
+        } else if (dataFileIndex !== -1 && args[dataFileIndex + 1]) {
+          const fileContent = readFile(args[dataFileIndex + 1]);
+          testData = parseJson(fileContent, 'test data file');
+        }
+
+        const projectId = getProjectId();
+        if (!projectId || projectId === 'default') {
+          error('No project selected. Open a project in Lux Studio first.');
+          break;
+        }
+
+        // Load flow from local storage
+        const flowData = loadLocalFlow(flowId);
+        if (!flowData) {
+          error(`Flow not found locally: ${flowId}`);
+          console.log(chalk.gray('Run "lux flows sync" to sync from cloud first.'));
+          break;
+        }
+
+        info(`Testing flow: ${flowData.name}`);
+
+        const executeUrl = `${apiUrl}/api/flows/execute`;
+
+        const startTime = Date.now();
+        const { data: result } = await axios.post(executeUrl, {
+          flowId,
+          nodes: flowData.nodes || [],
+          edges: flowData.edges || [],
+          context: testData,
+          projectId,
+        }, {
+          headers: {
+            ...getAuthHeaders(),
+            'Content-Type': 'application/json',
+            'X-Project-Id': projectId,
+          },
+        });
+
+        const executionTime = Date.now() - startTime;
+
+        if (jsonOutput) {
+          console.log(formatJson({
+            success: result.success,
+            data: result.data,
+            statusCode: result.statusCode,
+            nodeExecutions: result.nodeExecutions,
+            executionTime,
+          }));
+          break;
+        }
+
+        console.log(`\nTesting flow: ${flowData.name}\n`);
+
+        if (result.nodeExecutions && result.nodeExecutions.length > 0) {
+          result.nodeExecutions.forEach((node) => {
+            const nodeStatus = node.status === 'completed' ? chalk.green('✓') :
+                               node.status === 'failed' ? chalk.red('✗') :
+                               chalk.yellow('⏳');
+            const nodeDuration = node.duration ? `${node.duration}ms` : '-';
+            let outputPreview = '';
+            if (node.output) {
+              const outputStr = JSON.stringify(node.output);
+              if (outputStr.length > 40) {
+                outputPreview = chalk.gray(` → ${outputStr.substring(0, 40)}...`);
+              } else {
+                outputPreview = chalk.gray(` → ${outputStr}`);
+              }
+            }
+            if (node.error) {
+              outputPreview = chalk.red(` → ${node.error}`);
+            }
+            console.log(`  ${nodeStatus} ${node.nodeId}    ${nodeDuration}${outputPreview}`);
+          });
+        }
+
+        const resultStatus = result.success ? chalk.green('Success') : chalk.red('Failed');
+        console.log(`\n  Result: ${resultStatus} (${(executionTime / 1000).toFixed(1)}s)`);
+
+        if (result.data !== undefined) {
+          console.log(`\n  Output:`);
+          console.log(formatJson(result.data).split('\n').map(l => '    ' + l).join('\n'));
+        }
+
+        if (!result.success && result.error) {
+          console.log(chalk.red(`\n  Error: ${result.error}`));
+        }
+
+        console.log('');
+        break;
+      }
+
       default:
         error(
-          `Unknown command: ${command}\n\nRun 'lux workflows' to see available commands`
+          `Unknown command: ${command}\n\nRun 'lux flows' to see available commands`
         );
     }
   } catch (err) {
@@ -1097,4 +1373,4 @@ ${chalk.bold('Examples:')}
   }
 }
 
-module.exports = { handleWorkflows };
+module.exports = { handleFlows };

package/commands/servers.js

@@ -238,6 +238,56 @@ function formatTime(isoString) {
   return date.toLocaleString();
 }
 
+/**
+ * Restart a specific server by sending a signal file
+ * The Lux Studio Electron app watches for these signal files
+ */
+async function restartServer(appNameOrId) {
+  if (!appNameOrId) {
+    console.log(chalk.red('\nPlease specify an app name or ID to restart.'));
+    console.log(chalk.dim('Usage: lux servers restart <app-name-or-id>\n'));
+    return;
+  }
+
+  // Verify ports to clean up stale entries
+  const registry = await loadRegistry(true);
+
+  if (!registry.servers || registry.servers.length === 0) {
+    console.log(chalk.yellow('\nNo dev servers are currently running.'));
+    console.log(chalk.dim('Start a server in Lux Studio to restart it.\n'));
+    return;
+  }
+
+  // Find the server by name or ID (case-insensitive partial match)
+  const searchTerm = appNameOrId.toLowerCase();
+  const server = registry.servers.find(s =>
+    s.appId.toLowerCase().includes(searchTerm) ||
+    (s.appName && s.appName.toLowerCase().includes(searchTerm))
+  );
+
+  if (!server) {
+    console.log(chalk.red(`\nNo running server found matching "${appNameOrId}".`));
+    console.log(chalk.dim('\nAvailable servers:'));
+    registry.servers.forEach(s => {
+      console.log(chalk.dim(`  - ${s.appName || s.appId}`));
+    });
+    console.log('');
+    return;
+  }
+
+  // Write signal file to trigger restart
+  const signalDir = path.join(LUX_STUDIO_DIR, 'restart-signals');
+  if (!fs.existsSync(signalDir)) {
+    fs.mkdirSync(signalDir, { recursive: true });
+  }
+
+  const signalFile = path.join(signalDir, `${server.appId}.signal`);
+  fs.writeFileSync(signalFile, Date.now().toString());
+
+  console.log(chalk.green(`\n✓ Restart signal sent for ${server.appName || server.appId}`));
+  console.log(chalk.dim(`  The server will restart momentarily.\n`));
+}
+
 /**
  * Handle the servers command
  */
@@ -249,10 +299,16 @@ async function handleServers(args = []) {
     return;
   }
 
+  if (subcommand === 'restart') {
+    await restartServer(args[1]);
+    return;
+  }
+
   // Show help
   console.log(chalk.cyan('\nUsage:'));
   console.log('  lux servers              List all running dev servers');
   console.log('  lux servers list         List all running dev servers');
+  console.log('  lux servers restart <app>  Restart a specific dev server');
   console.log('');
 }
 
@@ -408,4 +464,5 @@ module.exports = {
   listServers,
   getLogs,
   getBrowserConsoleLogs,
+  restartServer,
 };

package/commands/spec.js

@@ -0,0 +1,137 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const {
+  error,
+  success,
+  info,
+} = require('../lib/helpers');
+
+// Paths to the pro-docs files (relative to project root)
+const PRO_DOCS_DIR = 'knowledge/pro-docs';
+const SPEC_FILE = 'project-spec.md';
+
+function getProjectRoot() {
+  // Walk up from cwd to find .lux folder (project root)
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, '.lux'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+function getSpecPath() {
+  return path.join(getProjectRoot(), PRO_DOCS_DIR, SPEC_FILE);
+}
+
+function ensureProDocsDir() {
+  const dir = path.join(getProjectRoot(), PRO_DOCS_DIR);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+function readFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  return fs.readFileSync(filePath, 'utf-8');
+}
+
+function writeFile(filePath, content) {
+  ensureProDocsDir();
+  fs.writeFileSync(filePath, content, 'utf-8');
+}
+
+async function handleSpec(args) {
+  const command = args[0];
+
+  if (!command || command === 'show') {
+    // Show project spec
+    const content = readFile(getSpecPath());
+    if (!content) {
+      console.log(chalk.yellow('\nNo project-spec.md found.'));
+      console.log(`Run ${chalk.cyan('lux spec init')} to create one.\n`);
+      return;
+    }
+    console.log('\n' + content);
+    return;
+  }
+
+  if (command === 'init') {
+    const specPath = getSpecPath();
+    if (fs.existsSync(specPath)) {
+      console.log(chalk.yellow('\nproject-spec.md already exists.'));
+      console.log(`Run ${chalk.cyan('lux spec edit')} to modify it.\n`);
+      return;
+    }
+
+    const template = `# Project Spec
+
+## Overview
+<!-- What is this project? Why does it exist? -->
+
+## Core Features
+
+### Planned
+- [ ] Feature 1
+- [ ] Feature 2
+- [ ] Feature 3
+
+## Technical Stack
+<!-- Key technologies, frameworks, architecture decisions -->
+
+## Key Decisions
+<!-- Important decisions made and why -->
+
+## Out of Scope
+<!-- What we're NOT building (helps keep focus) -->
+`;
+    writeFile(specPath, template);
+    success('Created project-spec.md');
+    console.log(`  Path: ${specPath}\n`);
+    return;
+  }
+
+  if (command === 'edit') {
+    const specPath = getSpecPath();
+    if (!fs.existsSync(specPath)) {
+      error('No project-spec.md found. Run "lux spec init" first.');
+      return;
+    }
+
+    // Open in default editor
+    const editor = process.env.EDITOR || 'code';
+    const { spawn } = require('child_process');
+    spawn(editor, [specPath], { stdio: 'inherit', detached: true });
+    info(`Opening ${specPath} in ${editor}`);
+    return;
+  }
+
+  if (command === 'path') {
+    console.log(getSpecPath());
+    return;
+  }
+
+  // Show help
+  console.log(`
+${chalk.bold('Usage:')} lux spec <command>
+
+${chalk.bold('Commands:')}
+  show          Show project spec (default)
+  init          Create a new project-spec.md
+  edit          Open project-spec.md in editor
+  path          Print path to project-spec.md
+
+${chalk.bold('Examples:')}
+  lux spec
+  lux spec init
+  lux spec edit
+`);
+}
+
+module.exports = { handleSpec };

package/lib/config.js

@@ -201,6 +201,7 @@ function loadLocalFlow(flowId) {
 
 /**
  * Save a flow to local storage
+ * Matches Electron storage service pattern: main file + separate .deployed.json
  */
 function saveLocalFlow(flowId, flowData) {
   const flowsDir = getFlowsDir();
@@ -211,8 +212,22 @@ function saveLocalFlow(flowId, flowData) {
     fs.mkdirSync(flowsDir, { recursive: true });
   }
 
+  // Extract deployed data (same pattern as Electron storage service)
+  const { deployedNodes, deployedEdges, ...flowWithoutDeployed } = flowData;
+
+  // Write main flow file (without deployed data)
   const flowPath = path.join(flowsDir, `${flowId}.json`);
-  fs.writeFileSync(flowPath, JSON.stringify(flowData, null, 2));
+  fs.writeFileSync(flowPath, JSON.stringify(flowWithoutDeployed, null, 2));
+
+  // Write deployed data to separate file (if present)
+  if (deployedNodes || deployedEdges) {
+    const deployedPath = path.join(flowsDir, `${flowId}.deployed.json`);
+    fs.writeFileSync(deployedPath, JSON.stringify({
+      deployedNodes: deployedNodes || [],
+      deployedEdges: deployedEdges || [],
+    }, null, 2));
+  }
+
   return true;
 }
 

package/lux.js

@@ -11,7 +11,7 @@ const { dev } = require('./commands/dev');
 const { handleInterface } = require('./commands/interface');
 const { handleData } = require('./commands/data');
 const { handleStorage } = require('./commands/storage');
-const { handleWorkflows } = require('./commands/workflows');
+const { handleFlows } = require('./commands/flows');
 const { handleSecrets } = require('./commands/secrets');
 const { handleAgents } = require('./commands/agents');
 const { handleKnowledge } = require('./commands/knowledge');
@@ -23,6 +23,7 @@ const { handleServers, handleLogs } = require('./commands/servers');
 const { handleTest } = require('./commands/webview');
 const { handleABTests } = require('./commands/ab-tests');
 const { handleTools } = require('./commands/tools');
+const { handleSpec } = require('./commands/spec');
 
 program
   .name('lux')
@@ -95,14 +96,14 @@ program
     handleStorage(subcommand ? [subcommand, ...(args || [])] : []);
   });
 
-// Workflows commands (with short aliases 'flow' and 'f')
+// Flows commands (with short alias 'f')
 program
-  .command('workflows [subcommand] [args...]')
-  .aliases(['flow', 'f'])
-  .description('Workflow management (list, get, create/init, save, publish, diff)')
+  .command('flows [subcommand] [args...]')
+  .alias('f')
+  .description('Flow management (list, get, create/init, save, publish, diff)')
   .allowUnknownOption()
   .action((subcommand, args) => {
-    handleWorkflows(subcommand ? [subcommand, ...(args || [])] : []);
+    handleFlows(subcommand ? [subcommand, ...(args || [])] : []);
   });
 
 // Secrets commands
@@ -192,12 +193,13 @@ program
     handleProject(subcommand ? [subcommand, ...(args || [])] : []);
   });
 
-// Servers command - list running dev servers
+// Servers command - list/restart running dev servers
 program
-  .command('servers [subcommand]')
-  .description('List running dev servers started from Lux Studio')
-  .action((subcommand) => {
-    handleServers(subcommand ? [subcommand] : []);
+  .command('servers [subcommand] [args...]')
+  .description('Manage dev servers (list, restart)')
+  .allowUnknownOption()
+  .action((subcommand, args) => {
+    handleServers(subcommand ? [subcommand, ...(args || [])] : []);
   });
 
 // Logs command - view dev server logs
@@ -275,4 +277,13 @@ program
     await startPreview(interfaceId);
   });
 
+// Project spec command
+program
+  .command('spec [subcommand] [args...]')
+  .description('Project spec management (show, init, edit)')
+  .allowUnknownOption()
+  .action((subcommand, args) => {
+    handleSpec(subcommand ? [subcommand, ...(args || [])] : []);
+  });
+
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luxlabs",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "CLI tool for Lux - Upload and deploy interfaces from your terminal",
   "author": "Jason Henkel <jason@uselux.ai>",
   "license": "SEE LICENSE IN LICENSE",
@@ -24,7 +24,7 @@
     "deploy",
     "interfaces",
     "ai",
-    "workflows",
+    "flows",
     "agents"
   ],
   "repository": {