lua-cli 3.12.1 → 3.13.0

package/dist/commands/push.js

@@ -4,10 +4,11 @@
  */
 import { compileCommand } from './compile.js';
 import { readYamlConfig, } from '../utils/files.js';
-import { withErrorHandling, writeProgress, writeSuccess, writeInfo, clearPromptLines } from '../utils/cli.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';
@@ -15,7 +16,30 @@ 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)
 // ============================================================================
@@ -128,8 +152,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
  */
@@ -206,16 +228,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 };
         }
+        return { productionDeploySucceeded: false };
+        // Staging vs deployed hints run in pushCommand — avoid duplicates here (H8).
     }
     catch (error) {
         throw error;
@@ -237,21 +272,33 @@ async function genericDeployAfterPush(handler, apiKey, agentId, entityId, entity
                 }]);
             if (!confirmAnswer || !confirmAnswer.confirm) {
                 console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
-                return;
+                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;
     }
 }
 /**
@@ -274,7 +321,15 @@ export async function pushCommand(type, cmdObj) {
             entityName: cmdObj?.name || 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 +347,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 {
@@ -344,34 +379,39 @@ export async function pushCommand(type, cmdObj) {
         }
         // 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,
@@ -381,6 +421,74 @@ export async function pushCommand(type, cmdObj) {
             type_selected_by_arg: !!type,
             version_specified: !!options.version,
         });
+        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");
 }
 /**
@@ -433,7 +541,7 @@ async function pushAgentVersion(options = {}) {
         ]);
         if (!confirmAnswer || !confirmAnswer.confirm) {
             console.log("\n❌ Push cancelled.\n");
-            return;
+            return { cancelled: true };
         }
     }
     // Authenticate
@@ -441,15 +549,23 @@ async function pushAgentVersion(options = {}) {
     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");
         }
     }
+    const personaAutoDeployFailed = Boolean(options.autoDeploy && personaDeployEligible && personaDeployWasAttempted && !productionDeployedWithAutoDeploy);
+    return { cancelled: false, productionDeployedWithAutoDeploy, personaAutoDeployFailed };
 }
 /**
  * Deploy a persona version immediately after pushing
@@ -471,7 +587,7 @@ async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum, skipCo
             ]);
             if (!confirmAnswer || !confirmAnswer.confirm) {
                 console.log("\n❌ Deployment cancelled. Persona version created but not deployed.\n");
-                return;
+                return false;
             }
         }
         writeProgress("🔄 Deploying persona version...");
@@ -479,14 +595,18 @@ async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum, skipCo
         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.");
+        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;
     }
 }
 /**
@@ -520,19 +640,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`);
+        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
@@ -572,6 +698,11 @@ 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;
     // Icons per kind for display
@@ -624,12 +755,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 +788,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 +805,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 +817,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) {
@@ -691,6 +857,7 @@ async function pushAllCommand(options) {
             }
             else {
                 console.warn(`  ⚠️  ${item.name} deployment failed`);
+                deployFailedCount++;
             }
         }
     }
@@ -707,6 +874,7 @@ async function pushAllCommand(options) {
         }
         else {
             console.warn(`  ⚠️  Persona deployment failed`);
+            deployFailedCount++;
         }
     }
     // Step 7.5: Push source backup (independent storage concern)
@@ -758,11 +926,58 @@ 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,
     });
-    console.log('');
+    // 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,
+    });
+    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