lua-cli 3.12.2 → 3.14.0

package/dist/commands/push.js

@@ -3,19 +3,44 @@
  * Orchestrates pushing skill versions to the server
  */
 import { compileCommand } from './compile.js';
-import { readYamlConfig, } from '../utils/files.js';
-import { withErrorHandling, writeProgress, writeSuccess, writeInfo, clearPromptLines } from '../utils/cli.js';
+import { readYamlConfig } from '../utils/files.js';
+import { withErrorHandling, writeProgress, writeSuccess, writeInfo, clearPromptLines, writeNextStep, writeHintBlock, writeTip, } from '../utils/cli.js';
 import { requireAuthOrExit } from '../utils/command-utils.js';
 import { safePrompt } from '../utils/prompt-handler.js';
 import { incrementPatchVersion, maxSemver } from '../utils/semver.js';
+import { AuthenticationError } from '../errors/auth.error.js';
 import { BASE_URLS } from '../config/constants.js';
 import PersonaApi from '../api/persona.api.service.js';
 import { loadManifest, getPrimitivesByKind } from '../utils/artifact-loader.js';
+import { ensureBundlesUploaded } from '../utils/bundle-upload.js';
 import { PrimitiveKind } from '../compiler/types.js';
 import { agentHandler } from '../primitives/agent.handler.js';
 import { skillHandler as skillH, webhookHandler as webhookH, jobHandler as jobH, preprocessorHandler as preprocessorH, postprocessorHandler as postprocessorH, deviceHandler as deviceH, deviceTriggerHandler as deviceTriggerH, } from '../primitives/index.js';
 import { pushBackupCommand } from './pushBackup.js';
+import { buildLogsCommand } from './log-tip.js';
 import { trackEvent } from '../services/analytics.js';
+import { validateOrSuggest } from '../utils/aliases.js';
+export { pickPushAllNextStepVariant, formatPushFailureSummary } from './push-helpers.js';
+import { pickPushAllNextStepVariant, formatPushFailureSummary } from './push-helpers.js';
+/**
+ * Maps push target type to a valid `lua deploy …` follow-up (or null when
+ * there is no deploy CLI surface for that type — e.g. mcp, device, backup).
+ */
+function getDeployHint(type) {
+    const deployableMap = {
+        skill: 'lua deploy skill',
+        webhook: 'lua deploy webhook',
+        job: 'lua deploy job',
+        preprocessor: 'lua deploy preprocessor',
+        postprocessor: 'lua deploy postprocessor',
+        agent: 'lua deploy persona',
+        persona: 'lua deploy persona',
+    };
+    const cmd = deployableMap[type];
+    if (!cmd)
+        return null;
+    return { label: 'Deploy:', command: cmd };
+}
 // ============================================================================
 // Core Push Helpers (shared by all push functions)
 // ============================================================================
@@ -29,25 +54,25 @@ async function promptVersionConfirmOrUpdate(currentVersion) {
     console.log(`\nCurrent version: ${currentVersion || '(none - first push)'}`);
     const answer = await safePrompt([
         {
-            type: "input",
-            name: "newVersion",
-            message: "Enter new version to push:",
+            type: 'input',
+            name: 'newVersion',
+            message: 'Enter new version to push:',
             default: incrementPatchVersion(currentVersion),
             validate: (input) => {
-                if (!input || input.trim() === "") {
-                    return "Version cannot be empty";
+                if (!input || input.trim() === '') {
+                    return 'Version cannot be empty';
                 }
                 // Basic semver validation
                 const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
                 if (!semverRegex.test(input.trim())) {
-                    return "Version must follow semver format (e.g., 1.0.0, 1.0.0-alpha.1)";
+                    return 'Version must follow semver format (e.g., 1.0.0, 1.0.0-alpha.1)';
                 }
                 return true;
-            }
-        }
+            },
+        },
     ]);
     if (!answer) {
-        console.log("Push cancelled.");
+        console.log('Push cancelled.');
         process.exit(0);
     }
     clearPromptLines(2);
@@ -73,7 +98,7 @@ async function selectEntityOrFail(items, options, config) {
     }
     // Non-interactive: find by name
     if (options.entityName) {
-        const found = items.find((item) => nameFields.some(field => item[field] === options.entityName));
+        const found = items.find((item) => nameFields.some((field) => item[field] === options.entityName));
         if (!found) {
             throw new Error(`${entityType} "${options.entityName}" not found`);
         }
@@ -93,12 +118,12 @@ async function selectEntityOrFail(items, options, config) {
             message: `Select a ${entityType} to push:`,
             choices: items.map((item) => ({
                 name: formatChoice ? formatChoice(item) : `${item.name} (v${item.version})`,
-                value: item
-            }))
-        }
+                value: item,
+            })),
+        },
     ]);
     if (!answer) {
-        console.log("Push cancelled.");
+        console.log('Push cancelled.');
         process.exit(0);
     }
     writeInfo(`📦 Selected ${entityType}: ${answer.selected.name}`);
@@ -128,8 +153,6 @@ async function resolveVersionOrFail(currentVersion, options, highestKnownVersion
     // Otherwise, prompt interactively
     return await promptVersionConfirmOrUpdate(currentVersion);
 }
-/**
-
 /**
  * Determines if we should deploy after push based on options or prompt
  */
@@ -148,8 +171,8 @@ async function shouldDeployAfterPush(options) {
             type: 'confirm',
             name: 'deployNow',
             message: 'Would you like to deploy this version to production now?',
-            default: false
-        }
+            default: false,
+        },
     ]);
     return answer?.deployNow || false;
 }
@@ -163,12 +186,12 @@ async function shouldDeployAfterPush(options) {
 async function pushVersionedPrimitive(handler, options = {}) {
     try {
         // Step 1: Compile
-        writeProgress("📦 Compiling project...");
+        writeProgress('📦 Compiling project...');
         await compileCommand();
-        writeSuccess("✅ Compilation complete");
+        writeSuccess('✅ Compilation complete');
         // Step 2: Authenticate
         const apiKey = await authenticateOrFail();
-        writeSuccess("✅ Authentication verified");
+        writeSuccess('✅ Authentication verified');
         // Step 3: Read config
         const config = readYamlConfig();
         if (!config?.agent?.agentId) {
@@ -182,22 +205,32 @@ async function pushVersionedPrimitive(handler, options = {}) {
         }
         const selected = await selectEntityOrFail(items, options, {
             entityType: handler.displayName,
-            nameFields: ['id', handler.yamlConfig.idField, 'name']
+            nameFields: ['id', handler.yamlConfig.idField, 'name'],
         });
         const entityId = selected[handler.yamlConfig.idField];
         if (!entityId) {
             throw new Error(`${handler.displayName} "${selected.name}" has no server ID. Run 'lua compile' first.`);
         }
-        // Step 5: Load bundled data
+        // Step 5: Load bundled data — accumulate raw gzip blobs for presigned upload (BAC-196)
         const manifest = loadManifest();
-        const pushData = handler.prepareForPush(manifest, selected.name);
+        const bundleAccumulator = new Map();
+        const pushData = handler.prepareForPush(manifest, selected.name, undefined, bundleAccumulator);
         if (!pushData) {
             throw new Error(`${handler.displayName} "${selected.name}" not found in compiled output.`);
         }
+        // Step 5b: Upload missing blobs to S3 via presigned PUT, skip ones already there.
+        let bundleStats = {
+            total: 0,
+            alreadyExisted: 0,
+            uploaded: 0,
+        };
+        if (bundleAccumulator.size > 0) {
+            writeProgress(`📤 Uploading ${bundleAccumulator.size} bundle(s) to S3...`);
+            bundleStats = await ensureBundlesUploaded(apiKey, agentId, bundleAccumulator);
+            writeSuccess('✅ Bundles uploaded');
+        }
         // Step 6: Resolve version (check server for highest to avoid conflicts)
-        const serverHighest = options.force
-            ? await handler.getHighestServerVersion(apiKey, agentId, entityId)
-            : undefined;
+        const serverHighest = options.force ? await handler.getHighestServerVersion(apiKey, agentId, entityId) : undefined;
         const confirmedVersion = await resolveVersionOrFail(selected.version, options, serverHighest ?? undefined);
         if (confirmedVersion !== selected.version) {
             handler.updateVersionInYaml(selected.name, confirmedVersion);
@@ -206,16 +239,29 @@ async function pushVersionedPrimitive(handler, options = {}) {
         writeProgress(`\n🚀 Pushing ${selected.name} v${confirmedVersion} to server...`);
         const result = await handler.pushToServer(apiKey, agentId, entityId, { ...pushData, version: confirmedVersion });
         if (!result.success) {
+            const isVersionConflict = result.error?.toLowerCase().includes('already exists');
+            if (isVersionConflict) {
+                writeHintBlock({
+                    headline: 'Version conflict — this version already exists on the server.',
+                    lines: [
+                        { label: 'Auto-bump:', command: `lua push ${handler.kind} --force` },
+                        { label: 'Or push all:', command: 'lua push all --force' },
+                    ],
+                    when: 'error',
+                });
+            }
+            // Push rejected — the reason is already on screen in the error above.
+            // No lua logs hint here: the push never ran, so no execution logs exist.
             throw new Error(`Push Error: ${result.error || 'Unknown error'}`);
         }
         writeSuccess(`\n✅ Successfully pushed ${selected.name} v${confirmedVersion}\n`);
         // Step 8: Deploy if requested
         if (await shouldDeployAfterPush(options)) {
-            await genericDeployAfterPush(handler, apiKey, agentId, entityId, selected.name, confirmedVersion, options.autoDeploy || false);
-        }
-        else {
-            writeInfo(`💡 You can deploy later using: lua ${handler.displayNamePlural} production`);
+            const deployedOk = await genericDeployAfterPush(handler, apiKey, agentId, entityId, selected.name, confirmedVersion, options.autoDeploy || false);
+            return { productionDeploySucceeded: deployedOk, bundleStats };
         }
+        return { productionDeploySucceeded: false, bundleStats };
+        // Staging vs deployed hints run in pushCommand — avoid duplicates here (H8).
     }
     catch (error) {
         throw error;
@@ -227,31 +273,45 @@ async function pushVersionedPrimitive(handler, options = {}) {
 async function genericDeployAfterPush(handler, apiKey, agentId, entityId, entityName, version, skipConfirmation = false) {
     try {
         if (!skipConfirmation) {
-            console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
-            console.log("⚠️  This will affect ALL users immediately.\n");
-            const confirmAnswer = await safePrompt([{
+            console.log('\n⚠️  WARNING: You are about to deploy to PRODUCTION!');
+            console.log('⚠️  This will affect ALL users immediately.\n');
+            const confirmAnswer = await safePrompt([
+                {
                     type: 'confirm',
                     name: 'confirm',
                     message: 'Are you absolutely sure you want to deploy?',
-                    default: false
-                }]);
+                    default: false,
+                },
+            ]);
             if (!confirmAnswer || !confirmAnswer.confirm) {
-                console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
-                return;
+                console.log('\n❌ Deployment cancelled. Version pushed but not deployed.\n');
+                return false;
             }
         }
         writeProgress(`🔄 Publishing ${handler.displayName} version...`);
-        const result = await handler.publishVersion(apiKey, agentId, entityId, version);
-        if (!result.success) {
-            console.error(`\n❌ Deploy Error: ${result.error || 'Unknown error'}\n`);
-            return;
+        writeInfo('⏱️  Waiting for server to process the new version (3 seconds)...');
+        await new Promise((resolve) => setTimeout(resolve, 3000));
+        const deployed = await retryDeploy(async () => {
+            const result = await handler.publishVersion(apiKey, agentId, entityId, version);
+            if (!result.success)
+                throw new Error(result.error || 'Deploy failed');
+        }, entityName, version, 3);
+        if (!deployed) {
+            console.error(`\n❌ Deploy Error: failed after retries\n`);
+            // Deploy is a management operation — no execution logs exist for a failed deploy.
+            // Suggest retrying via the deploy command.
+            writeTip(`Deploy later with: lua deploy ${handler.kind}`);
+            return false;
         }
         writeSuccess(`\n✅ ${entityName} v${version} deployed to production\n`);
         writeInfo(`💡 The new ${handler.displayName} version is now active.`);
+        return true;
     }
     catch (error) {
         console.error(`\n❌ Error deploying ${handler.displayName}:`, error);
-        console.log(`💡 You can deploy later using: lua ${handler.displayNamePlural} production\n`);
+        // Deploy is a management operation — no execution logs exist for a failed deploy.
+        writeTip(`Deploy later with: lua deploy ${handler.kind}`);
+        return false;
     }
 }
 /**
@@ -272,9 +332,17 @@ export async function pushCommand(type, cmdObj) {
             force: cmdObj?.force || false,
             autoDeploy: cmdObj?.autoDeploy || false,
             entityName: cmdObj?.name || null,
-            version: cmdObj?.setVersion || null
+            version: cmdObj?.setVersion || null,
         };
+        let agentOutcome;
         let selectedType;
+        /** Present only after a versioned-primitive route; indicates production publish success after optional deploy. */
+        let versionedPushDeployResult;
+        // Normalize alias first (e.g. 'everything' → 'all', 'skills' → 'skill')
+        // so that the early 'all' guard below can catch aliases like 'everything'
+        if (type) {
+            type = validateOrSuggest('push.type', type, { allowAll: true });
+        }
         // Handle 'all' type with force flag
         if (type === 'all') {
             if (!options.force) {
@@ -292,27 +360,7 @@ export async function pushCommand(type, cmdObj) {
             console.log('  lua push webhook --name myWebhook --set-version 2.0.0    Push specific webhook');
             throw new Error('Type must be specified when using the --name option.');
         }
-        // Step 1: Check if type was provided as argument
         if (type) {
-            // Validate the provided type
-            const validTypes = ['skill', 'agent', 'persona', 'webhook', 'job', 'preprocessor', 'postprocessor', 'mcp', 'device', 'device-trigger', 'backup'];
-            if (!validTypes.includes(type)) {
-                console.log('\nUsage:');
-                console.log('  lua push                - Interactive selection');
-                console.log('  lua push skill          - Push a skill directly');
-                console.log('  lua push agent          - Push agent config (persona, model)');
-                console.log('  lua push webhook        - Push a webhook directly');
-                console.log('  lua push job            - Push a job directly');
-                console.log('  lua push preprocessor   - Push a preprocessor directly');
-                console.log('  lua push postprocessor  - Push a postprocessor directly');
-                console.log('  lua push mcp            - Push an MCP server directly');
-                console.log('  lua push backup         - Push project source backup');
-                console.log('  lua push all --force    - Push all components without prompts');
-                throw new Error(`Invalid type: "${type}". Must be one of: ${validTypes.join(', ')}, or "all".`);
-            }
-            // 'persona' is an alias for 'agent' (backward compatibility)
-            if (type === 'persona')
-                type = 'agent';
             selectedType = type;
         }
         else {
@@ -332,46 +380,51 @@ export async function pushCommand(type, cmdObj) {
                         { name: '📡 Device', value: 'device' },
                         { name: '📡 Device Trigger', value: 'device-trigger' },
                         { name: '🤖 Agent (persona, model)', value: 'agent' },
-                        { name: '💾 Backup (source files)', value: 'backup' }
-                    ]
-                }
+                        { name: '💾 Backup (source files)', value: 'backup' },
+                    ],
+                },
             ]);
             if (!typeAnswer) {
-                console.log("Push cancelled.");
+                console.log('Push cancelled.');
                 return;
             }
             selectedType = typeAnswer.type;
         }
         // Step 3: Route to appropriate function
         if (selectedType === 'skill') {
-            await pushVersionedPrimitive(skillH, options);
+            versionedPushDeployResult = await pushVersionedPrimitive(skillH, options);
         }
         else if (selectedType === 'webhook') {
-            await pushVersionedPrimitive(webhookH, options);
+            versionedPushDeployResult = await pushVersionedPrimitive(webhookH, options);
         }
         else if (selectedType === 'job') {
-            await pushVersionedPrimitive(jobH, options);
+            versionedPushDeployResult = await pushVersionedPrimitive(jobH, options);
         }
         else if (selectedType === 'preprocessor') {
-            await pushVersionedPrimitive(preprocessorH, options);
+            versionedPushDeployResult = await pushVersionedPrimitive(preprocessorH, options);
         }
         else if (selectedType === 'postprocessor') {
-            await pushVersionedPrimitive(postprocessorH, options);
+            versionedPushDeployResult = await pushVersionedPrimitive(postprocessorH, options);
         }
         else if (selectedType === 'device') {
-            await pushVersionedPrimitive(deviceH, options);
+            versionedPushDeployResult = await pushVersionedPrimitive(deviceH, options);
         }
         else if (selectedType === 'device-trigger') {
-            await pushVersionedPrimitive(deviceTriggerH, options);
+            versionedPushDeployResult = await pushVersionedPrimitive(deviceTriggerH, options);
         }
         else if (selectedType === 'mcp') {
-            await pushMCPServer(options);
+            const mcpActivated = await pushMCPServer(options);
+            // B10: thread activation status so the final hint knows whether MCP is live.
+            versionedPushDeployResult = { productionDeploySucceeded: mcpActivated };
         }
         else if (selectedType === 'backup') {
             await pushBackupCommand({ force: options.force });
         }
         else if (selectedType === 'agent') {
-            await pushAgentVersion(options);
+            agentOutcome = await pushAgentVersion(options);
+        }
+        if (agentOutcome?.cancelled) {
+            return;
         }
         trackEvent('cli_push_completed', {
             primitive_type: selectedType,
@@ -380,8 +433,79 @@ export async function pushCommand(type, cmdObj) {
             entity_selected_by_name: !!options.entityName,
             type_selected_by_arg: !!type,
             version_specified: !!options.version,
+            // BAC-196 presigned-upload telemetry. `bundles_total` = unique
+            // content-hashes referenced by this push; `bundles_uploaded` = hashes
+            // the server reported missing and we PUT to S3; `bundles_existed`
+            // measures delta-upload hit rate. Zero for non-versioned types
+            // (mcp/agent/backup) — they don't go through the S3 path.
+            bundles_total: versionedPushDeployResult?.bundleStats?.total ?? 0,
+            bundles_uploaded: versionedPushDeployResult?.bundleStats?.uploaded ?? 0,
+            bundles_existed: versionedPushDeployResult?.bundleStats?.alreadyExisted ?? 0,
         });
-    }, "push");
+        const productionDeployedActually = versionedPushDeployResult?.productionDeploySucceeded === true ||
+            (!!agentOutcome && !agentOutcome.cancelled && agentOutcome.productionDeployedWithAutoDeploy);
+        const personaAutoDeployRanAndFailed = selectedType === 'agent' &&
+            options.autoDeploy &&
+            !!agentOutcome &&
+            !agentOutcome.cancelled &&
+            'personaAutoDeployFailed' in agentOutcome &&
+            agentOutcome.personaAutoDeployFailed;
+        if (productionDeployedActually) {
+            writeHintBlock({
+                headline: 'Deployed to production. Generate test traffic first:',
+                lines: [
+                    { label: 'Test:', command: `lua chat -e production -m "your test message"` },
+                    { label: 'Inspect:', command: buildLogsCommand({ primitiveType: selectedType }) },
+                ],
+                when: 'success',
+            });
+        }
+        else {
+            const deployHint = getDeployHint(selectedType);
+            if (personaAutoDeployRanAndFailed) {
+                const lines = [];
+                if (deployHint) {
+                    lines.push(deployHint);
+                }
+                else if (selectedType === 'mcp') {
+                    lines.push({
+                        label: 'Activate:',
+                        command: 'use the Lua dashboard or: lua push mcp --force --auto-deploy  (requires --name when multiple MCP servers)',
+                    });
+                }
+                lines.push({
+                    label: 'Or re-push:',
+                    command: selectedType === 'mcp'
+                        ? 'lua push mcp --force --auto-deploy'
+                        : `lua push ${selectedType} --force --auto-deploy`,
+                });
+                writeHintBlock({
+                    headline: 'Push completed — production persona deploy did not succeed. Try:',
+                    lines,
+                    when: 'partial',
+                });
+            }
+            else if (selectedType === 'backup') {
+                // Backup is not a "live" primitive; skip staged-vs-live framing.
+            }
+            else if (deployHint) {
+                writeHintBlock({
+                    headline: 'Staged but NOT live yet. To make it active:',
+                    lines: [deployHint, { label: 'Or re-push:', command: `lua push ${selectedType} --force --auto-deploy` }],
+                    when: 'success',
+                });
+            }
+            else {
+                writeNextStep({
+                    command: selectedType === 'mcp'
+                        ? 'lua push mcp --force --auto-deploy'
+                        : `lua push ${selectedType} --force --auto-deploy`,
+                    rationale: 'to re-push with auto-activation',
+                    when: 'success',
+                });
+            }
+        }
+    }, 'push');
 }
 /**
  * Push agent configuration (persona, model/modelResolver) to the server.
@@ -408,13 +532,13 @@ async function pushAgentVersion(options = {}) {
     const model = agent?.model;
     const hasModelResolver = agent?.hasModelResolver;
     if (!persona?.trim() && !model && !hasModelResolver) {
-        throw new Error("No agent configuration to push (no persona or model found).");
+        throw new Error('No agent configuration to push (no persona or model found).');
     }
     writeInfo(`📦 Pushing agent config for: ${agentId}`);
     // Show preview
     if (persona) {
         const preview = persona.length > 200 ? persona.substring(0, 200) + '...' : persona;
-        console.log("\nPersona preview:");
+        console.log('\nPersona preview:');
         console.log(preview);
     }
     if (model) {
@@ -428,28 +552,36 @@ async function pushAgentVersion(options = {}) {
                 type: 'confirm',
                 name: 'confirm',
                 message: 'Push agent configuration to server?',
-                default: true
-            }
+                default: true,
+            },
         ]);
         if (!confirmAnswer || !confirmAnswer.confirm) {
-            console.log("\n❌ Push cancelled.\n");
-            return;
+            console.log('\n❌ Push cancelled.\n');
+            return { cancelled: true };
         }
     }
     // Authenticate
     const apiKey = await authenticateOrFail();
-    writeProgress("✅ Authenticated");
+    writeProgress('✅ Authenticated');
     // Push via agentHandler
     const result = await agentHandler.pushAgentConfig(apiKey, agentId, manifest);
-    // Deploy persona if requested and was pushed
-    if (result.persona?.success && result.persona.version) {
-        if (await shouldDeployAfterPush(options)) {
-            await deployPersonaVersionAfterPush(apiKey, agentId, result.persona.version, options.autoDeploy || false);
+    let productionDeployedWithAutoDeploy = false;
+    let personaDeployWasAttempted = false;
+    const personaDeployEligible = !!(result.persona?.success && result.persona.version);
+    // B4: only ask about deploy when a persona was actually pushed — avoid the prompt
+    // when push failed or was a model-only push with no persona version created.
+    if (personaDeployEligible) {
+        const shouldDeploy = await shouldDeployAfterPush(options);
+        if (shouldDeploy) {
+            personaDeployWasAttempted = true;
+            productionDeployedWithAutoDeploy = await deployPersonaVersionAfterPush(apiKey, agentId, result.persona.version, options.autoDeploy || false);
         }
         else {
-            writeInfo("💡 You can deploy the persona version later using: lua deploy");
+            writeInfo('💡 You can deploy the persona version later using: lua deploy');
         }
     }
+    const personaAutoDeployFailed = Boolean(options.autoDeploy && personaDeployEligible && personaDeployWasAttempted && !productionDeployedWithAutoDeploy);
+    return { cancelled: false, productionDeployedWithAutoDeploy, personaAutoDeployFailed };
 }
 /**
  * Deploy a persona version immediately after pushing
@@ -459,34 +591,38 @@ async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum, skipCo
         // Skip confirmation when called from auto-deploy with --force
         if (!skipConfirmation) {
             // Show warning
-            console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
-            console.log("⚠️  This will affect ALL users immediately.\n");
+            console.log('\n⚠️  WARNING: You are about to deploy to PRODUCTION!');
+            console.log('⚠️  This will affect ALL users immediately.\n');
             const confirmAnswer = await safePrompt([
                 {
                     type: 'confirm',
                     name: 'confirm',
                     message: 'Are you absolutely sure you want to deploy this persona version?',
-                    default: false
-                }
+                    default: false,
+                },
             ]);
             if (!confirmAnswer || !confirmAnswer.confirm) {
-                console.log("\n❌ Deployment cancelled. Persona version created but not deployed.\n");
-                return;
+                console.log('\n❌ Deployment cancelled. Persona version created but not deployed.\n');
+                return false;
             }
         }
-        writeProgress("🔄 Deploying persona version...");
+        writeProgress('🔄 Deploying persona version...');
         const personaApi = new PersonaApi(BASE_URLS.API, apiKey, agentId);
         const deployResult = await personaApi.deployVersion(versionNum);
         if (!deployResult.success) {
             console.error(`\n❌ Deploy Error: ${deployResult.error?.message || 'Unknown error'}\n`);
+            // Persona deploy is a management operation — no execution logs exist.
+            writeTip('Retry with: lua push agent');
             throw new Error(deployResult.error?.message || 'Failed to deploy persona version');
         }
         writeSuccess(`\n✅ Persona version ${versionNum} deployed successfully to production\n`);
-        writeInfo("💡 The new persona is now active for all users.");
+        writeInfo('💡 The new persona is now active for all users.');
+        return true;
     }
     catch (error) {
         console.error('\n❌ Error deploying persona version:', error);
-        console.log('💡 You can deploy later using: lua persona\n');
+        writeTip('Retry with: lua push agent');
+        return false;
     }
 }
 /**
@@ -496,11 +632,11 @@ async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum, skipCo
  */
 async function pushMCPServer(options = {}) {
     try {
-        writeProgress("📦 Compiling project...");
+        writeProgress('📦 Compiling project...');
         await compileCommand();
-        writeSuccess("✅ Compilation complete");
+        writeSuccess('✅ Compilation complete');
         const apiKey = await authenticateOrFail();
-        writeSuccess("✅ Authentication verified");
+        writeSuccess('✅ Authentication verified');
         const config = readYamlConfig();
         if (!config?.agent?.agentId) {
             throw new Error("No agent ID found. Run 'lua init' first.");
@@ -509,7 +645,7 @@ async function pushMCPServer(options = {}) {
         const { mcpServerHandler } = await import('../primitives/mcp-server.handler.js');
         const bundledServers = mcpServerHandler.loadBundledItems();
         if (bundledServers.length === 0) {
-            throw new Error("No MCP servers found in compiled output.");
+            throw new Error('No MCP servers found in compiled output.');
         }
         const selectedServer = await selectEntityOrFail(bundledServers, options, {
             entityType: 'MCP server',
@@ -520,19 +656,25 @@ async function pushMCPServer(options = {}) {
         // upsertOnServer persists the returned id into lua.skill.yaml on success.
         const result = await mcpServerHandler.upsertOnServer(apiKey, agentId, selectedServer);
         if (!result.success) {
+            // Push rejected — reason already on screen; no execution logs exist for a failed push.
             throw new Error(`Failed: ${result.error}`);
         }
         writeSuccess(`\n✅ MCP server "${selectedServer.name}" pushed successfully\n`);
-        if (result.id && await shouldDeployAfterPush(options)) {
-            writeProgress("🔄 Activating MCP server...");
+        let activated = false;
+        if (result.id && (await shouldDeployAfterPush(options))) {
+            writeProgress('🔄 Activating MCP server...');
             const activateResult = await mcpServerHandler.activate(apiKey, agentId, result.id);
-            if (activateResult.success)
+            if (activateResult.success) {
                 writeSuccess(`✅ MCP server activated\n`);
+                activated = true;
+            }
         }
+        return activated;
     }
     catch (error) {
         throw error;
     }
+    return false; // unreachable — catch always rethrows
 }
 /**
  * Push all command - Pushes all components (skills, webhooks, jobs, processors) without prompts
@@ -547,12 +689,12 @@ async function pushMCPServer(options = {}) {
  * @param options - Command options (force is required, autoDeploy is optional)
  */
 async function pushAllCommand(options) {
-    writeProgress("🚀 Push All - Pushing all components to server...\n");
+    writeProgress('🚀 Push All - Pushing all components to server...\n');
     if (options.autoDeploy) {
-        writeInfo("🚀 Auto-deploy to production is ENABLED\n");
+        writeInfo('🚀 Auto-deploy to production is ENABLED\n');
     }
     // Step 1: Compile first
-    writeProgress("📦 Compiling project...");
+    writeProgress('📦 Compiling project...');
     await compileCommand();
     // Step 2: Load configuration and API key
     const config = readYamlConfig();
@@ -572,22 +714,44 @@ async function pushAllCommand(options) {
     // Track results and deploy queue per handler
     const allResults = [];
     const toDeploy = [];
+    // Per-item failures collected across all push surfaces (versioned
+    // primitives + MCP). Drives the post-run aggregate `⚠️ N component(s)
+    // failed` block and the final partial/error writeNextStep variant.
+    const failedItems = [];
+    let deployFailedCount = 0;
     let personaPushResult = null;
     let backupSuccess = false;
+    // BAC-196: aggregate bundle-upload stats across all primitives in the run.
+    const bundleStatsAggregate = { total: 0, uploaded: 0, existed: 0 };
     // Icons per kind for display
     const kindIcons = {
-        skill: '📦', webhook: '🪝', job: '⏰', preprocessor: '📥', postprocessor: '📤', device: '📡',
+        skill: '📦',
+        webhook: '🪝',
+        job: '⏰',
+        preprocessor: '📥',
+        postprocessor: '📤',
+        device: '📡',
     };
     // Step 4: Pre-fetch highest versions in parallel (one HTTP call per handler type)
-    const handlers = [skillH, webhookH, jobH, preprocessorH, postprocessorH, deviceH, deviceTriggerH];
+    const handlers = [
+        skillH,
+        webhookH,
+        jobH,
+        preprocessorH,
+        postprocessorH,
+        deviceH,
+        deviceTriggerH,
+    ];
     // Collect entity IDs per handler and batch-fetch versions in parallel
-    const handlerItems = handlers.map(handler => ({
+    const handlerItems = handlers
+        .map((handler) => ({
         handler,
         items: handler.getFromYaml(config).filter((item) => {
             const entityId = item[handler.yamlConfig.idField];
             return entityId && item.version;
         }),
-    })).filter(h => h.items.length > 0);
+    }))
+        .filter((h) => h.items.length > 0);
     const versionMaps = await Promise.all(handlerItems.map(async ({ handler, items }) => {
         const entityIds = items.map((item) => item[handler.yamlConfig.idField]);
         const versions = await handler.batchGetHighestVersions(apiKey, agentId, entityIds);
@@ -607,11 +771,18 @@ async function pushAllCommand(options) {
         const handlerVersions = versionLookup.get(handler);
         for (const item of items) {
             try {
-                const pushData = handler.prepareForPush(manifest, item.name);
+                const bundleAccumulator = new Map();
+                const pushData = handler.prepareForPush(manifest, item.name, undefined, bundleAccumulator);
                 if (!pushData) {
                     console.warn(`⚠️  ${handler.displayName} "${item.name}" not found in compiled output, skipping`);
                     continue;
                 }
+                if (bundleAccumulator.size > 0) {
+                    const stats = await ensureBundlesUploaded(apiKey, agentId, bundleAccumulator);
+                    bundleStatsAggregate.total += stats.total;
+                    bundleStatsAggregate.uploaded += stats.uploaded;
+                    bundleStatsAggregate.existed += stats.alreadyExisted;
+                }
                 const entityId = item[handler.yamlConfig.idField];
                 if (!entityId) {
                     console.warn(`⚠️  ${handler.displayName} "${item.name}" has no server ID, skipping. Run 'lua compile' first.`);
@@ -624,12 +795,29 @@ async function pushAllCommand(options) {
                 // Auto-bump version (use pre-fetched server version to avoid conflicts)
                 const serverHighest = handlerVersions?.get(entityId) ?? null;
                 const baseVersion = serverHighest ? maxSemver(item.version, serverHighest) : item.version;
-                const newVersion = incrementPatchVersion(baseVersion);
+                let newVersion = incrementPatchVersion(baseVersion);
                 writeInfo(`  📝 ${item.name}: ${item.version} → ${newVersion}`);
                 // Push
-                const result = await handler.pushToServer(apiKey, agentId, entityId, { ...pushData, version: newVersion });
+                let result = await handler.pushToServer(apiKey, agentId, entityId, { ...pushData, version: newVersion });
+                // On version collision, re-fetch the server's current highest version
+                // and try once more. The pre-fetch in step 4 is racey against
+                // concurrent pushes by the same/another user; a single re-bump
+                // resolves the dominant collision pattern observed in production.
+                if (!result.success && result.error?.toLowerCase().includes('already exists')) {
+                    console.log(`  ⚠️  Version collision on ${item.name}, refetching server state and retrying...`);
+                    const freshHighest = await handler.getHighestServerVersion(apiKey, agentId, entityId);
+                    if (freshHighest) {
+                        const retryVersion = incrementPatchVersion(freshHighest);
+                        writeInfo(`  📝 ${item.name}: re-bumped ${newVersion} → ${retryVersion} after collision`);
+                        result = await handler.pushToServer(apiKey, agentId, entityId, { ...pushData, version: retryVersion });
+                        if (result.success) {
+                            newVersion = retryVersion;
+                        }
+                    }
+                }
                 if (!result.success) {
                     console.error(`  ❌ Failed to push ${item.name}: ${result.error}`);
+                    failedItems.push({ kind: handler.kind, name: item.name, error: result.error || 'Unknown error' });
                     continue;
                 }
                 handler.updateVersionInYaml(item.name, newVersion, { silent: true });
@@ -640,7 +828,14 @@ async function pushAllCommand(options) {
                 }
             }
             catch (error) {
+                // Auth errors must propagate so withErrorHandling treats them as
+                // fatal, otherwise the loop continues against a known-broken auth
+                // state. Matches the re-throw pattern in batchGetHighestVersions /
+                // getHighestServerVersion.
+                if (AuthenticationError.isAuthenticationError(error))
+                    throw error;
                 console.error(`  ❌ Failed to push ${item.name}: ${error.message}`);
+                failedItems.push({ kind: handler.kind, name: item.name, error: error.message || 'Unknown error' });
             }
         }
     }
@@ -650,9 +845,11 @@ async function pushAllCommand(options) {
     // when --auto-deploy is set. Here we only print the summary.
     const { mcpServerHandler: mcpH } = await import('../primitives/mcp-server.handler.js');
     const bundledMcp = mcpH.loadBundledItems();
+    let mcpPushedCount = 0; // tracks actual successes, not just attempts (B2)
     if (bundledMcp.length > 0) {
         writeProgress(`\n🔌 Pushing ${bundledMcp.length} MCP server(s)...`);
         const mcpResult = await mcpH.pushAll(bundledMcp, apiKey, agentId, { autoDeploy: options.autoDeploy });
+        mcpPushedCount = mcpResult.pushed.length;
         for (const name of mcpResult.pushed) {
             writeSuccess(`  ✅ ${name}`);
             if (mcpResult.activated.includes(name))
@@ -660,8 +857,17 @@ async function pushAllCommand(options) {
         }
         for (const { name, error } of mcpResult.failed) {
             console.error(`  ❌ Failed to push ${name}: ${error}`);
+            failedItems.push({ kind: 'mcp', name, error: error || 'Unknown error' });
         }
     }
+    // Aggregate failure block: emit a single grouped summary with a per-item
+    // `lua logs` diagnose hint so users can jump straight to the failing
+    // component's logs without scrolling back through interleaved push output.
+    // Printed before agent config push so the user sees component failures
+    // alongside the persona/backup status that follows.
+    if (failedItems.length > 0) {
+        console.error(formatPushFailureSummary(failedItems));
+    }
     // Step 6.5: Push agent config (persona, model/modelResolver)
     const agentPushResult = await agentHandler.pushAgentConfig(apiKey, agentId, manifest);
     if (agentPushResult.persona?.success) {
@@ -679,7 +885,7 @@ async function pushAllCommand(options) {
     if (options.autoDeploy && toDeploy.length > 0) {
         writeProgress('\n🚀 Deploying all pushed versions to production...');
         writeInfo('⏱️  Waiting for server to process versions (5 seconds)...\n');
-        await new Promise(resolve => setTimeout(resolve, 5000));
+        await new Promise((resolve) => setTimeout(resolve, 5000));
         for (const item of toDeploy) {
             const deployed = await retryDeploy(async () => {
                 const result = await item.handler.publishVersion(apiKey, agentId, item.entityId, item.version);
@@ -691,6 +897,7 @@ async function pushAllCommand(options) {
             }
             else {
                 console.warn(`  ⚠️  ${item.name} deployment failed`);
+                deployFailedCount++;
             }
         }
     }
@@ -707,6 +914,7 @@ async function pushAllCommand(options) {
         }
         else {
             console.warn(`  ⚠️  Persona deployment failed`);
+            deployFailedCount++;
         }
     }
     // Step 7.5: Push source backup (independent storage concern)
@@ -730,12 +938,16 @@ async function pushAllCommand(options) {
         byKind.get(kind).push(r);
     }
     const summaryIcons = {
-        skills: '🛠️ ', webhooks: '🪝', jobs: '⏰', preprocessors: '📥', postprocessors: '📤',
+        skills: '🛠️ ',
+        webhooks: '🪝',
+        jobs: '⏰',
+        preprocessors: '📥',
+        postprocessors: '📤',
     };
     for (const [kind, items] of byKind) {
         const icon = summaryIcons[kind] || '📦';
         console.log(`${icon} ${kind.charAt(0).toUpperCase() + kind.slice(1)} (${items.length}):`);
-        items.forEach(i => console.log(`   • ${i.name} v${i.version}`));
+        items.forEach((i) => console.log(`   • ${i.name} v${i.version}`));
     }
     if (personaPushResult) {
         console.log(`🌙 Persona:`);
@@ -758,11 +970,63 @@ async function pushAllCommand(options) {
         auto_deploy: options.autoDeploy || false,
         primitives_pushed_count: allResults.length,
         primitives_by_kind: kindCounts,
-        mcp_servers_pushed: bundledMcp.length,
+        mcp_servers_pushed: mcpPushedCount,
         persona_pushed: !!personaPushResult,
         backup_pushed: backupSuccess,
+        // BAC-196 presigned-upload telemetry, summed across every primitive
+        // pushed in this run. `bundles_existed` measures delta-upload hit rate.
+        bundles_total: bundleStatsAggregate.total,
+        bundles_uploaded: bundleStatsAggregate.uploaded,
+        bundles_existed: bundleStatsAggregate.existed,
+    });
+    // B2: use actual successful MCP pushes, not attempt count, to determine pushedSomething.
+    const pushedSomething = allResults.length > 0 || mcpPushedCount > 0 || !!personaPushResult || backupSuccess;
+    // Pick the right hint variant based on the run outcome. We deliberately
+    // ungate the tip from `pushedSomething` for the all-failed case so a
+    // 100%-failed `lua push all --force` still surfaces a `lua logs` nudge
+    // (previously it was silent, leaving users to guess what to do next).
+    const variant = pickPushAllNextStepVariant({
+        pushedSomething,
+        failedCount: failedItems.length + deployFailedCount,
     });
-    console.log('');
+    if (variant === 'success') {
+        console.log('');
+        if (options.autoDeploy) {
+            writeHintBlock({
+                headline: 'All deployed. Generate test traffic first, then inspect:',
+                lines: [
+                    { label: 'Test:', command: 'lua chat -e production -m "your test message"' },
+                    { label: 'Inspect:', command: buildLogsCommand({ limit: 10 }) },
+                ],
+                when: 'success',
+            });
+        }
+        else {
+            writeHintBlock({
+                headline: 'Code staged but NOT live. Make it active:',
+                lines: [
+                    { label: 'Deploy all:', command: 'lua deploy all --force' },
+                    { label: 'Or re-push:', command: 'lua push all --force --auto-deploy' },
+                ],
+                when: 'success',
+            });
+        }
+    }
+    else if (variant === 'partial') {
+        console.log('');
+        // Some components pushed, some failed. Suggest re-pushing the failures.
+        // No lua logs hint: failed pushes produce no execution logs.
+        writeNextStep({
+            command: 'lua push all --force',
+            rationale: 'to re-attempt the failed components',
+            when: 'partial',
+        });
+    }
+    else if (variant === 'error') {
+        console.log('');
+        // Total failure — nothing pushed, no execution logs exist.
+        // No hint: the errors are already shown above.
+    }
 }
 /**
  * Retry deployment with exponential backoff
@@ -774,7 +1038,7 @@ async function retryDeploy(deployFn, _componentName, _version, maxRetries = 3) {
             // Only delay on retry attempts (not first attempt)
             if (attempt > 1) {
                 const delay = attempt * 2000; // 2s on 2nd attempt, 4s on 3rd, etc.
-                await new Promise(resolve => setTimeout(resolve, delay));
+                await new Promise((resolve) => setTimeout(resolve, delay));
             }
             await deployFn();
             // Show success message if succeeded after retrying