luxlabs 1.0.18 → 1.0.20

package/commands/dev.js

@@ -124,12 +124,21 @@ async function dev(options = {}) {
   }
 }
 
+/**
+ * Get the correct next binary path for the current platform
+ * Points directly to Next.js CLI JS file to bypass .bin shell script wrappers (cross-platform)
+ */
+function getNextBinPath() {
+  return './node_modules/next/dist/bin/next';
+}
+
 /**
  * Check and install npm dependencies if needed
  */
 async function checkDependencies() {
   const nodeModulesExists = fs.existsSync('node_modules');
-  const nextBinExists = fs.existsSync('./node_modules/.bin/next');
+  const nextBinPath = getNextBinPath();
+  const nextBinExists = fs.existsSync(nextBinPath);
 
   if (!nodeModulesExists || !nextBinExists) {
     console.log(chalk.yellow('📦 Installing dependencies...'));
@@ -157,7 +166,7 @@ async function startDevServer(port) {
   return new Promise((resolve, reject) => {
     console.log(chalk.dim(`Starting Next.js on port ${port}...`));
 
-    const nextBin = './node_modules/.bin/next';
+    const nextBin = getNextBinPath();
     const nodePath = getNodePath();
     const nodeEnv = getNodeEnv();
 

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

@@ -56,7 +56,7 @@ async function getCapturedPayload(token) {
 async function getWorkflowDraft(workflowId) {
   const apiUrl = getApiUrl();
   const { data } = await axios.get(
-    `${apiUrl}/api/workflows/${workflowId}/draft`,
+    `${apiUrl}/api/flows/${workflowId}/draft`,
     { headers: getAuthHeaders() }
   );
   return data;
@@ -68,13 +68,13 @@ async function getWorkflowDraft(workflowId) {
 async function saveWorkflowDraft(workflowId, config) {
   const apiUrl = getApiUrl();
   await axios.put(
-    `${apiUrl}/api/workflows/${workflowId}/draft`,
+    `${apiUrl}/api/flows/${workflowId}/draft`,
     { config },
     { headers: getAuthHeaders() }
   );
 }
 
-async function handleWorkflows(args) {
+async function handleFlows(args) {
   // Check authentication
   if (!isAuthenticated()) {
     console.log(
@@ -89,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:')}
@@ -128,33 +128,33 @@ ${chalk.bold('Execution Commands:')}
   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
+  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 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
+  ${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 workflows executions my-flow       # List recent executions
-  lux workflows last my-flow             # Show last execution result
-  lux workflows test my-flow --data '{"name":"test"}'  # Test with data
+  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);
   }
@@ -165,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 = {
@@ -203,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;
         }
 
@@ -231,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)'}`);
@@ -243,19 +243,19 @@ ${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`, {
+        const { data } = await axios.get(`${apiUrl}/api/flows?include_config=true`, {
           headers: getAuthHeaders(),
         });
 
@@ -357,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;
         }
 
@@ -377,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/flows/${flowId}`,
           { headers: getAuthHeaders() }
         );
 
         if (!data.workflow) {
-          error(`Workflow not found: ${workflowId}`);
+          error(`Flow not found: ${flowId}`);
         }
 
         const workflow = data.workflow;
@@ -421,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] || '';
 
@@ -454,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 = {
@@ -472,9 +472,9 @@ ${chalk.bold('Examples:')}
                 metadata: newFlow.metadata || {},
               };
 
-              // Step 1: Create workflow in cloud database (this generates a cloud UUID)
+              // Step 1: Create flow in cloud database (this generates a cloud UUID)
               const createResponse = await axios.post(
-                `${apiUrl}/api/workflows`,
+                `${apiUrl}/api/flows`,
                 {
                   name: newFlow.name,
                   description: newFlow.description,
@@ -485,14 +485,14 @@ ${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}`);
 
-              // Step 2: Publish the workflow (copies draft config to published)
+              // Step 2: Publish the flow (copies draft config to published)
               const publishResponse = await axios.post(
-                `${apiUrl}/api/workflows/${cloudId}/publish`,
+                `${apiUrl}/api/flows/${cloudId}/publish`,
                 {},
                 { headers: getAuthHeaders() }
               );
@@ -515,44 +515,46 @@ ${chalk.bold('Examples:')}
                 // Cloud sync tracking - matches markFlowPublished()
                 cloudPublishedAt: now,
                 cloudStatus: 'published',
+                // Track who deployed (for teammate detection)
+                lastDeployedBy: publishResponse.data.triggeredBy || null,
               };
               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 = {
@@ -563,9 +565,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
@@ -576,22 +578,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;
         }
 
@@ -599,12 +601,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 = {
@@ -615,7 +617,7 @@ ${chalk.bold('Examples:')}
         };
 
         const { data } = await axios.post(
-          `${apiUrl}/api/workflows/${workflowId}/publish`,
+          `${apiUrl}/api/flows/${flowId}/publish`,
           {
             name: localFlow.name,
             description: localFlow.description,
@@ -642,10 +644,12 @@ ${chalk.bold('Examples:')}
           // Cloud sync tracking - matches markFlowPublished()
           cloudPublishedAt: now,
           cloudStatus: 'published',
+          // Track who deployed (for teammate detection)
+          lastDeployedBy: data.triggeredBy || null,
         };
-        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')}`);
@@ -653,17 +657,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 || [],
@@ -672,12 +676,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;
         }
 
@@ -709,17 +713,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:`);
@@ -727,17 +731,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}`);
@@ -746,15 +750,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
@@ -763,20 +767,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;
         }
 
@@ -851,11 +855,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...');
@@ -870,14 +874,14 @@ ${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 workflows executions <flow-id> [--limit N]');
+        requireArgs(args.slice(1), 1, 'lux flows executions <flow-id> [--limit N]');
         const flowId = args[1];
 
         // Parse --limit flag
@@ -912,7 +916,7 @@ ${chalk.bold('Examples:')}
 
         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 workflows test" to create an execution.\n'));
+          console.log(chalk.gray('Run the flow from the interface or use "lux flows test" to create an execution.\n'));
           break;
         }
 
@@ -954,12 +958,12 @@ ${chalk.bold('Examples:')}
           console.log(chalk.dim(`Use --limit N to see more.\n`));
         }
 
-        console.log(chalk.gray(`\nTo see full details: lux workflows 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 workflows 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');
@@ -1056,14 +1060,14 @@ ${chalk.bold('Examples:')}
 
           formatTable(nodeFormatted);
 
-          console.log(chalk.gray(`\nTo see node details: lux workflows 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 workflows 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];
@@ -1163,7 +1167,7 @@ ${chalk.bold('Examples:')}
       }
 
       case 'last': {
-        requireArgs(args.slice(1), 1, 'lux workflows last <flow-id>');
+        requireArgs(args.slice(1), 1, 'lux flows last <flow-id>');
         const flowId = args[1];
         const jsonOutput = args.includes('--json');
 
@@ -1188,7 +1192,7 @@ ${chalk.bold('Examples:')}
         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 workflows test" to create an execution.\n'));
+          console.log(chalk.gray('Run the flow from the interface or use "lux flows test" to create an execution.\n'));
           break;
         }
 
@@ -1259,7 +1263,7 @@ ${chalk.bold('Examples:')}
       }
 
       case 'test': {
-        requireArgs(args.slice(1), 1, 'lux workflows test <flow-id> [--data <json>] [--data-file <path>]');
+        requireArgs(args.slice(1), 1, 'lux flows test <flow-id> [--data <json>] [--data-file <path>]');
         const flowId = args[1];
         const jsonOutput = args.includes('--json');
 
@@ -1285,7 +1289,7 @@ ${chalk.bold('Examples:')}
         const flowData = loadLocalFlow(flowId);
         if (!flowData) {
           error(`Flow not found locally: ${flowId}`);
-          console.log(chalk.gray('Run "lux workflows sync" to sync from cloud first.'));
+          console.log(chalk.gray('Run "lux flows sync" to sync from cloud first.'));
           break;
         }
 
@@ -1363,7 +1367,7 @@ ${chalk.bold('Examples:')}
 
       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) {
@@ -1373,4 +1377,4 @@ ${chalk.bold('Examples:')}
   }
 }
 
-module.exports = { handleWorkflows };
+module.exports = { handleFlows };

package/commands/knowledge.js

@@ -5,9 +5,15 @@ const path = require('path');
 const FormData = require('form-data');
 const {
   getApiUrl,
+  getStudioApiUrl,
   getAuthHeaders,
   isAuthenticated,
+  getProjectId,
+  getOrgId,
 } = require('../lib/config');
+
+// Public R2 URL for the lux-knowledge bucket
+const R2_PUBLIC_URL = 'https://pub-12ee5415430243b7bfc167df804f52e2.r2.dev';
 const {
   error,
   success,
@@ -36,138 +42,163 @@ ${chalk.bold('Usage:')} lux knowledge <command> [args]
 
 ${chalk.bold('Document Commands:')}
   list                              List all documents and folders
-  get <document-id>                 Get document details and content
-  url <document-id>                 Get public URL for a document
-  upload <file-path> [folder-id]    Upload a file to knowledge base
-  delete <document-id>              Delete a document
+  get <file-path>                   Get document details and content
+  url <file-path>                   Get public URL for a document
+  upload <local-file> [folder]      Upload a file to knowledge base
+  delete <file-path>                Delete a document
 
 ${chalk.bold('Folder Commands:')}
   folders list                      List all folders
-  folders create <name> [parent-id] Create a new folder
-  folders delete <folder-id>        Delete a folder
+  folders create <folder-path>      Create a new folder
+  folders delete <folder-path>      Delete a folder and all contents
 
 ${chalk.bold('Examples:')}
   lux knowledge list
-  lux knowledge get doc_123abc
+  lux knowledge get custom-designs/blanks/blank-white-front.png
+  lux knowledge url custom-designs/blanks/blank-white-front.png
   lux knowledge upload ./data.json
-  lux knowledge upload ./image.png folder_xyz
-  lux knowledge folders create "Product Docs"
+  lux knowledge upload ./image.png custom-designs/blanks
+  lux knowledge folders create product-docs
+  lux knowledge folders delete product-docs
 `);
     process.exit(0);
   }
 
   const apiUrl = getApiUrl();
+  const studioApiUrl = getStudioApiUrl();
+  const projectId = getProjectId();
 
   try {
     // ============ DOCUMENT COMMANDS ============
     if (command === 'list') {
       info('Loading knowledge base...');
 
-      const [foldersRes, docsRes] = await Promise.all([
-        axios.get(`${apiUrl}/api/knowledge/folders`, {
-          headers: getAuthHeaders(),
-        }),
-        axios.get(`${apiUrl}/api/knowledge/documents`, {
-          headers: getAuthHeaders(),
-        }),
-      ]);
+      const { data } = await axios.get(
+        `${studioApiUrl}/api/projects/${projectId}/knowledge`,
+        { headers: getAuthHeaders() }
+      );
+
+      if (!data.success) {
+        error(data.error || 'Failed to list knowledge');
+        return;
+      }
 
-      const folders = foldersRes.data.folders || [];
-      const documents = docsRes.data.documents || [];
+      const tree = data.tree || [];
+      const totalFiles = data.totalFiles || 0;
 
-      if (folders.length === 0 && documents.length === 0) {
+      if (tree.length === 0) {
         console.log('\n(No knowledge items found)\n');
         return;
       }
 
-      if (folders.length > 0) {
-        console.log(`\n${chalk.bold('Folders')} (${folders.length}):\n`);
-        formatTable(folders.map(f => ({
-          id: f.id,
-          name: f.name,
-          path: f.path,
-        })));
+      console.log(`\n${chalk.bold('Knowledge Base')} (${totalFiles} files):\n`);
+
+      // Print tree structure
+      function printTree(nodes, indent = '') {
+        for (const node of nodes) {
+          if (node.type === 'folder') {
+            console.log(`${indent}${chalk.blue('📁')} ${chalk.bold(node.name)}/`);
+            if (node.children && node.children.length > 0) {
+              printTree(node.children, indent + '  ');
+            }
+          } else {
+            const size = node.size ? ` (${formatFileSize(node.size)})` : '';
+            console.log(`${indent}${chalk.gray('📄')} ${node.name}${chalk.gray(size)}`);
+          }
+        }
       }
 
-      if (documents.length > 0) {
-        console.log(`\n${chalk.bold('Documents')} (${documents.length}):\n`);
-        formatTable(documents.map(d => ({
-          id: d.id,
-          name: d.name,
-          type: d.document_type || d.file_type || 'unknown',
-          size: formatFileSize(d.file_size),
-          folder: d.folder_id || '(root)',
-        })));
-      }
+      printTree(tree);
       console.log('');
     }
 
     else if (command === 'get') {
-      requireArgs(args.slice(1), 1, 'lux knowledge get <document-id>');
-      const docId = args[1];
+      requireArgs(args.slice(1), 1, 'lux knowledge get <file-path>');
+      const filePath = args[1];
+      const orgId = getOrgId();
 
-      info(`Loading document: ${docId}`);
+      info(`Loading document: ${filePath}`);
       const { data } = await axios.get(
-        `${apiUrl}/api/knowledge/documents/${docId}`,
+        `${studioApiUrl}/api/projects/${projectId}/knowledge/${filePath}`,
         { headers: getAuthHeaders() }
       );
 
-      const doc = data.document;
-      console.log(`\n${chalk.bold('Document Details:')}`);
-      console.log(`  ID: ${doc.id}`);
-      console.log(`  Name: ${doc.name}`);
-      console.log(`  Type: ${doc.document_type || doc.file_type || 'unknown'}`);
-      console.log(`  Size: ${formatFileSize(doc.file_size)}`);
-      console.log(`  Folder: ${doc.folder_id || '(root)'}`);
-
-      if (doc.public_url) {
-        console.log(`  URL: ${doc.public_url}`);
+      if (!data.success) {
+        error(data.error || 'Failed to get file');
+        return;
       }
 
-      if (doc.image_width && doc.image_height) {
-        console.log(`  Dimensions: ${doc.image_width}x${doc.image_height}`);
-        console.log(`  Est. Tokens: ${doc.estimated_tokens || 'N/A'}`);
+      // Extract filename from path
+      const fileName = filePath.split('/').pop() || filePath;
+      const ext = fileName.split('.').pop()?.toLowerCase() || '';
+
+      console.log(`\n${chalk.bold('Document Details:')}`);
+      console.log(`  Path: ${filePath}`);
+      console.log(`  Name: ${fileName}`);
+      console.log(`  Size: ${formatFileSize(data.size)}`);
+      console.log(`  Encoding: ${data.encoding}`);
+      console.log(`  Modified: ${data.modifiedAt || 'N/A'}`);
+
+      // Show public URL for binary files
+      if (data.encoding === 'base64') {
+        const publicUrl = `${R2_PUBLIC_URL}/${orgId}/${projectId}/knowledge/${filePath}`;
+        console.log(`  URL: ${publicUrl}`);
       }
 
-      if (doc.content) {
+      // Show content preview for text files
+      if (data.encoding === 'utf-8' && data.content) {
         console.log(`\n${chalk.bold('Content:')}`);
-        console.log(doc.content.substring(0, 2000));
-        if (doc.content.length > 2000) {
-          console.log(chalk.gray(`\n... (${doc.content.length - 2000} more characters)`));
+        const preview = data.content.substring(0, 2000);
+        console.log(preview);
+        if (data.content.length > 2000) {
+          console.log(chalk.gray(`\n... (${data.content.length - 2000} more characters)`));
         }
       }
       console.log('');
     }
 
     else if (command === 'url') {
-      requireArgs(args.slice(1), 1, 'lux knowledge url <document-id>');
-      const docId = args[1];
+      requireArgs(args.slice(1), 1, 'lux knowledge url <file-path>');
+      const filePath = args[1];
+      const orgId = getOrgId();
 
-      info(`Getting URL for document: ${docId}`);
+      info(`Getting URL for document: ${filePath}`);
+
+      // Verify the file exists by fetching from the project-based knowledge API
       const { data } = await axios.get(
-        `${apiUrl}/api/knowledge/documents/${docId}/presigned-url`,
+        `${studioApiUrl}/api/projects/${projectId}/knowledge/${filePath}`,
         { headers: getAuthHeaders() }
       );
 
+      if (!data.success) {
+        error(data.error || 'Failed to get file');
+        return;
+      }
+
+      // Construct the public R2 URL
+      // Format: https://pub-{bucket-id}.r2.dev/{orgId}/{projectId}/knowledge/{filePath}
+      const publicUrl = `${R2_PUBLIC_URL}/${orgId}/${projectId}/knowledge/${filePath}`;
+
       console.log(`\n${chalk.bold('Public URL:')}`);
-      console.log(data.presignedUrl);
-      console.log(`\nDocument: ${data.document.name} (${formatFileSize(data.document.file_size)})`);
+      console.log(publicUrl);
+      console.log(`\nFile: ${filePath} (${formatFileSize(data.size)})`);
       console.log('');
     }
 
     else if (command === 'upload') {
-      requireArgs(args.slice(1), 1, 'lux knowledge upload <file-path> [folder-id]');
-      const filePath = args[1];
-      const folderId = args[2] || null;
+      requireArgs(args.slice(1), 1, 'lux knowledge upload <local-file> [folder]');
+      const localFilePath = args[1];
+      const folder = args[2] || '';
+      const orgId = getOrgId();
 
       // Check file exists
-      if (!fs.existsSync(filePath)) {
-        error(`File not found: ${filePath}`);
+      if (!fs.existsSync(localFilePath)) {
+        error(`File not found: ${localFilePath}`);
         return;
       }
 
-      const fileName = path.basename(filePath);
-      const fileBuffer = fs.readFileSync(filePath);
+      const fileName = path.basename(localFilePath);
+      const fileBuffer = fs.readFileSync(localFilePath);
       const fileSize = fileBuffer.length;
 
       // Detect MIME type
@@ -187,60 +218,70 @@ ${chalk.bold('Examples:')}
         '.webp': 'image/webp',
         '.svg': 'image/svg+xml',
       };
-      const fileType = mimeTypes[ext] || 'application/octet-stream';
+      const contentType = mimeTypes[ext] || 'application/octet-stream';
 
       info(`Uploading: ${fileName} (${formatFileSize(fileSize)})`);
 
-      // Step 1: Get presigned upload URL
+      // Step 1: Get presigned upload URL from the project-based API
       const { data: uploadData } = await axios.post(
-        `${apiUrl}/api/knowledge/upload`,
-        { fileName, fileType },
+        `${studioApiUrl}/api/projects/${projectId}/knowledge/upload-url`,
+        { path: fileName, contentType, folder },
         { headers: getAuthHeaders() }
       );
 
-      // Step 2: Upload to R2
+      if (!uploadData.success) {
+        error(uploadData.error || 'Failed to get upload URL');
+        return;
+      }
+
+      // Step 2: Upload directly to R2 using presigned URL
       info('Uploading to storage...');
       await axios.put(uploadData.uploadUrl, fileBuffer, {
         headers: {
-          'Content-Type': fileType,
+          'Content-Type': contentType,
         },
         maxBodyLength: Infinity,
         maxContentLength: Infinity,
       });
 
-      // Step 3: Complete upload (save to database)
-      info('Saving document metadata...');
-      const { data: completeData } = await axios.put(
-        `${apiUrl}/api/knowledge/upload`,
-        {
-          filePath: uploadData.filePath,
-          fileName,
-          fileType,
-          folderId,
-          fileSize,
-        },
+      // Step 3: Confirm upload completed
+      info('Confirming upload...');
+      const { data: confirmData } = await axios.post(
+        `${studioApiUrl}/api/projects/${projectId}/knowledge/confirm-upload`,
+        { path: uploadData.path, size: fileSize },
         { headers: getAuthHeaders() }
       );
 
-      success('Document uploaded!');
-      console.log(`  ID: ${completeData.document.id}`);
-      console.log(`  Name: ${completeData.document.name}`);
-      if (completeData.document.public_url) {
-        console.log(`  URL: ${completeData.document.public_url}`);
+      if (!confirmData.success) {
+        error(confirmData.error || 'Failed to confirm upload');
+        return;
       }
+
+      // Construct public URL
+      const publicUrl = `${R2_PUBLIC_URL}/${orgId}/${projectId}/knowledge/${uploadData.path}`;
+
+      success('Document uploaded!');
+      console.log(`  Path: ${uploadData.path}`);
+      console.log(`  Size: ${formatFileSize(fileSize)}`);
+      console.log(`  URL: ${publicUrl}`);
       console.log('');
     }
 
     else if (command === 'delete') {
-      requireArgs(args.slice(1), 1, 'lux knowledge delete <document-id>');
-      const docId = args[1];
+      requireArgs(args.slice(1), 1, 'lux knowledge delete <file-path>');
+      const filePath = args[1];
 
-      info(`Deleting document: ${docId}`);
-      await axios.delete(
-        `${apiUrl}/api/knowledge/documents/${docId}`,
+      info(`Deleting: ${filePath}`);
+      const { data } = await axios.delete(
+        `${studioApiUrl}/api/projects/${projectId}/knowledge/${filePath}`,
         { headers: getAuthHeaders() }
       );
 
+      if (!data.success) {
+        error(data.error || 'Failed to delete file');
+        return;
+      }
+
       success('Document deleted!');
     }
 
@@ -250,67 +291,82 @@ ${chalk.bold('Examples:')}
 
       if (!subCommand || subCommand === 'list') {
         info('Loading folders...');
-        const { data } = await axios.get(`${apiUrl}/api/knowledge/folders`, {
-          headers: getAuthHeaders(),
-        });
+        const { data } = await axios.get(
+          `${studioApiUrl}/api/projects/${projectId}/knowledge`,
+          { headers: getAuthHeaders() }
+        );
 
-        if (!data.folders || data.folders.length === 0) {
+        if (!data.success) {
+          error(data.error || 'Failed to list knowledge');
+          return;
+        }
+
+        // Extract folders from tree
+        const folders = [];
+        function collectFolders(nodes, parentPath = '') {
+          for (const node of nodes) {
+            if (node.type === 'folder') {
+              folders.push({
+                name: node.name,
+                path: node.path,
+              });
+              if (node.children && node.children.length > 0) {
+                collectFolders(node.children, node.path);
+              }
+            }
+          }
+        }
+        collectFolders(data.tree || []);
+
+        if (folders.length === 0) {
           console.log('\n(No folders found)\n');
         } else {
-          console.log(`\nFound ${data.folders.length} folder(s):\n`);
-          formatTable(data.folders.map(f => ({
-            id: f.id,
-            name: f.name,
-            path: f.path,
-            parent: f.parent_id || '(root)',
-          })));
+          console.log(`\nFound ${folders.length} folder(s):\n`);
+          formatTable(folders);
           console.log('');
         }
       }
 
       else if (subCommand === 'create') {
-        requireArgs(args.slice(2), 1, 'lux knowledge folders create <name> [parent-id]');
-        const name = args[2];
-        const parentId = args[3] || null;
-
-        // Calculate path
-        let folderPath = `/${name}`;
-        if (parentId) {
-          // Fetch parent to get its path
-          const { data: foldersData } = await axios.get(`${apiUrl}/api/knowledge/folders`, {
-            headers: getAuthHeaders(),
-          });
-          const parent = (foldersData.folders || []).find(f => f.id === parentId);
-          if (parent) {
-            folderPath = `${parent.path}/${name}`;
-          }
-        }
+        requireArgs(args.slice(2), 1, 'lux knowledge folders create <folder-path>');
+        const folderPath = args[2];
+
+        info(`Creating folder: ${folderPath}`);
 
-        info(`Creating folder: ${name}`);
+        // In R2, folders are virtual - they're created by the folder endpoint
         const { data } = await axios.post(
-          `${apiUrl}/api/knowledge/folders`,
-          { name, parent_id: parentId, path: folderPath },
+          `${studioApiUrl}/api/projects/${projectId}/knowledge/folder/${folderPath}`,
+          {},
           { headers: getAuthHeaders() }
         );
 
+        if (!data.success) {
+          error(data.error || 'Failed to create folder');
+          return;
+        }
+
         success('Folder created!');
-        console.log(`  ID: ${data.folder.id}`);
-        console.log(`  Name: ${data.folder.name}`);
-        console.log(`  Path: ${data.folder.path}`);
+        console.log(`  Path: ${data.path}`);
         console.log('');
       }
 
       else if (subCommand === 'delete') {
-        requireArgs(args.slice(2), 1, 'lux knowledge folders delete <folder-id>');
-        const folderId = args[2];
+        requireArgs(args.slice(2), 1, 'lux knowledge folders delete <folder-path>');
+        const folderPath = args[2];
 
-        info(`Deleting folder: ${folderId}`);
-        await axios.delete(
-          `${apiUrl}/api/knowledge/folders?id=${folderId}`,
+        info(`Deleting folder: ${folderPath}`);
+        const { data } = await axios.delete(
+          `${studioApiUrl}/api/projects/${projectId}/knowledge/${folderPath}`,
           { headers: getAuthHeaders() }
         );
 
-        success('Folder deleted!');
+        if (!data.success) {
+          error(data.error || 'Failed to delete folder');
+          return;
+        }
+
+        const deletedCount = data.deletedCount || 1;
+        success(`Folder deleted! (${deletedCount} item${deletedCount > 1 ? 's' : ''} removed)`);
       }
 
       else {

package/commands/login.js

@@ -177,7 +177,7 @@ async function manualLogin(providedKey) {
     const apiUrl = getApiUrl();
 
     // Validate the API key by making a test request
-    const response = await axios.get(`${apiUrl}/api/workflows`, {
+    const response = await axios.get(`${apiUrl}/api/flows`, {
       headers: {
         Authorization: `Bearer ${apiKey}`,
         'X-Org-Id': extractOrgIdFromKey(apiKey),

package/commands/project.js

@@ -231,7 +231,8 @@ async function deployProject(projectId) {
     createGitignore(projectDir);
 
     // Always configure git user (required for commits)
-    execSync('git config user.email "deploy@uselux.ai"', { cwd: projectDir, stdio: 'pipe' });
+    // Use jason@uselux.ai so Vercel recognizes the commit author as a team member
+    execSync('git config user.email "jason@uselux.ai"', { cwd: projectDir, stdio: 'pipe' });
     execSync('git config user.name "Lux Deploy"', { cwd: projectDir, stdio: 'pipe' });
 
     gitSpinner.succeed('Git repository ready');
@@ -496,7 +497,7 @@ async function deployProject(projectId) {
           // Deploy to cloud API using /publish endpoint
           // The publish endpoint supports CLI auth and will create the flow if it doesn't exist
           const { data: deployData } = await axios.post(
-            `${apiUrl}/api/workflows/${flowId}/publish`,
+            `${apiUrl}/api/flows/${flowId}/publish`,
             {
               // Wrap flow data in config object as expected by /publish
               config: {

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');
@@ -96,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luxlabs",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "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": {