@babelize/cli 1.1.0 → 1.2.0

package/dist/commands/run.d.ts

@@ -1,3 +1,51 @@
 import { Command } from 'commander';
+import { AxiosInstance } from 'axios';
+/**
+ * Pipeline phases as the worker reports them: each `babel_logs.step` the
+ * engine emits through onProgress (packages/engine/src/orchestrator.ts),
+ * grouped in run order. The lockfile step runs around the locale step, and
+ * format-injection reports under injection.
+ */
+export declare const RUN_PHASES: {
+    id: string;
+    title: string;
+    steps: string[];
+}[];
+export type PhaseState = 'pending' | 'running' | 'done' | 'error';
+export interface PhaseProgress {
+    states: PhaseState[];
+    /** Index of the phase in progress, or -1 before the first log. */
+    current: number;
+    /** Latest message logged for the current phase. */
+    message?: string;
+}
+/**
+ * Where a run is, from its logs. A phase is done once it logs `success` or a
+ * later phase has started; the final `complete` step (or a `completed` run)
+ * marks every phase done. A phase that logged `error` is the failed one.
+ */
+export declare function computePhaseProgress(logs: Record<string, unknown>[], runStatus?: string): PhaseProgress;
 export declare function registerRunCommands(program: Command): void;
+/**
+ * Poll a run until it ends, showing each phase as it finishes.
+ *
+ * Returns the final status payload of a completed run. A run that ends any
+ * other way exits the process:
+ *   - failed    → ExitCode.API_ERROR (6), with the run's error
+ *   - cancelled → ExitCode.CANCEL (128), the code the CLI already uses for
+ *                 anything the user cancelled, so it never looks like success
+ * With --json, the final payload is printed before exiting on failed or
+ * cancelled; a completed run's payload is left to the caller.
+ */
+export declare function pollRunStatus(client: AxiosInstance, babelId: string, options?: {
+    intervalMs?: number;
+}): Promise<Record<string, unknown>>;
+export interface AutoPrOutcome {
+    status: 'created' | 'exists' | 'failed';
+    url?: string;
+    message?: string;
+}
+export declare function renderRunStatus(data: Record<string, unknown>, options?: {
+    source?: string;
+}): void;
 //# sourceMappingURL=run.d.ts.map

package/dist/commands/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0BpC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA0J1D"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAc,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAa7C;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,EAStE,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AAElE,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAKD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CAkCvG;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+K1D;AASD;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GACpC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA8ElC;AAqBD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAuDD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,IAAI,CAgFtG"}

package/dist/commands/run.js

@@ -1,25 +1,81 @@
-import * as clack from '@clack/prompts';
+import * as clack from '../tui/clack.js';
 import chalk from 'chalk';
-import { success as successColor, error as errorColor, statusBadge } from '../tui/theme.js';
+import axios from 'axios';
+import { success as successColor, error as errorColor, warning as warningColor, statusBadge, sym } from '../tui/theme.js';
 import { table, keyValue } from '../tui/table.js';
-import { section, dim, divider, success, warning } from '../tui/display.js';
-import { createPipeline, delay, renderRunTitle } from '../tui/task-list.js';
+import { section, dim, success, warning } from '../tui/display.js';
+import { delay, renderRunTitle } from '../tui/task-list.js';
 import { config } from '../config.js';
 import { getClient, handleApiError } from '../client.js';
 import { isJsonMode, printJson } from '../formatters.js';
 import { isNonInteractive } from '../global-options.js';
 import { renderCommandHelp } from '../tui/help.js';
 import { ExitCode } from '../exit-codes.js';
-const PHASES = [
-    'Phase 0: Workspace Validation',
-    'Phase 1: String Extraction',
-    'Phase 2: Key Generation',
-    'Phase 3: Base Locale Handling',
-    'Phase 4: Translation',
-    'Phase 5: AST Injection',
-    'Phase 6: Summary',
-    'Phase 7: Finalization',
+import { requireUuid } from '../utils/validate.js';
+/**
+ * Pipeline phases as the worker reports them: each `babel_logs.step` the
+ * engine emits through onProgress (packages/engine/src/orchestrator.ts),
+ * grouped in run order. The lockfile step runs around the locale step, and
+ * format-injection reports under injection.
+ */
+export const RUN_PHASES = [
+    { id: 'validation', title: 'Workspace validation', steps: ['validation'] },
+    { id: 'extraction', title: 'String extraction', steps: ['extraction'] },
+    { id: 'keygen', title: 'Key generation', steps: ['keygen'] },
+    { id: 'locale', title: 'Base locale and lockfile', steps: ['locale', 'lockfile'] },
+    { id: 'translation', title: 'Translation', steps: ['translation'] },
+    { id: 'injection', title: 'Code injection', steps: ['injection', 'format-injection'] },
+    { id: 'finalization', title: 'Finalization', steps: ['finalization'] },
+    { id: 'summary', title: 'Summary', steps: ['summary'] },
 ];
+/** Run statuses after which a run never changes again. */
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled']);
+/**
+ * Where a run is, from its logs. A phase is done once it logs `success` or a
+ * later phase has started; the final `complete` step (or a `completed` run)
+ * marks every phase done. A phase that logged `error` is the failed one.
+ */
+export function computePhaseProgress(logs, runStatus) {
+    const states = RUN_PHASES.map(() => 'pending');
+    const succeeded = new Set();
+    let reached = -1;
+    let errorAt = -1;
+    let message;
+    let complete = runStatus === 'completed';
+    for (const log of logs) {
+        const step = String(log.step ?? '').toLowerCase();
+        const status = String(log.status ?? '').toLowerCase();
+        if (step === 'complete') {
+            if (status === 'success')
+                complete = true;
+            continue;
+        }
+        const idx = RUN_PHASES.findIndex((p) => p.steps.includes(step));
+        if (idx === -1)
+            continue;
+        if (idx >= reached) {
+            reached = idx;
+            if (typeof log.message === 'string')
+                message = log.message;
+        }
+        if (status === 'success')
+            succeeded.add(idx);
+        if (status === 'error')
+            errorAt = idx;
+    }
+    if (complete) {
+        return { states: states.map(() => 'done'), current: RUN_PHASES.length - 1, message };
+    }
+    for (let i = 0; i < states.length; i++) {
+        if (i === errorAt)
+            states[i] = 'error';
+        else if (i < reached || succeeded.has(i))
+            states[i] = 'done';
+        else if (i === reached)
+            states[i] = 'running';
+    }
+    return { states, current: reached, message };
+}
 export function registerRunCommands(program) {
     const run = program
         .command('run')
@@ -27,13 +83,13 @@ export function registerRunCommands(program) {
     run.helpInformation = () => renderCommandHelp('run', 'Engine commands — start, preview, and monitor babel runs', [
         {
             name: 'start',
-            desc: 'Start a full Babelize engine run (triggers i18n pipeline)',
+            desc: `Start a full Babelize engine run (exits 0 completed, ${ExitCode.API_ERROR} failed, ${ExitCode.CANCEL} cancelled)`,
             options: [
                 { name: '-p, --project <id>', desc: 'Project ID (defaults to .babelize/config.json)' },
                 { name: '-l, --languages <codes>', desc: 'Comma-separated target language codes (e.g. es,fr,de,ja)' },
                 { name: '--branch <branch>', desc: 'Git branch to run on' },
                 { name: '--no-poll', desc: "Return immediately (don't wait for completion)" },
-                { name: '--no-pr', desc: 'Skip auto-creating a GitHub PR after completion' },
+                { name: '--no-pr', desc: 'Skip auto-creating a GitHub PR after completion (never attempted for ZIP projects)' },
             ],
         },
         {
@@ -64,7 +120,7 @@ export function registerRunCommands(program) {
                 console.error('Error: --project is required in non-interactive mode.');
                 process.exit(ExitCode.USAGE);
             }
-            const result = await clack.text({ message: 'Project ID:' });
+            const result = await clack.text({ message: 'Project ID:', flag: '--project' });
             if (clack.isCancel(result))
                 process.exit(ExitCode.CANCEL);
             projectId = result;
@@ -74,49 +130,69 @@ export function registerRunCommands(program) {
                 console.error('Error: --languages is required in non-interactive mode.');
                 process.exit(ExitCode.USAGE);
             }
-            const result = await clack.text({ message: 'Target languages (comma-sep, e.g. es,fr,de):' });
+            const result = await clack.text({ message: 'Target languages (comma-sep, e.g. es,fr,de):', flag: '--languages' });
             if (clack.isCancel(result))
                 process.exit(ExitCode.CANCEL);
             languages = result;
         }
         const langs = languages.split(',').map((l) => l.trim()).filter(Boolean);
+        const client = getClient();
         const s = clack.spinner();
         s.start('Starting engine run…');
+        let babelId;
+        let startData;
         try {
-            const client = getClient();
             const res = await client.post('/engine/babel', {
                 project_id: projectId,
                 target_locales: langs,
                 ...(opts.branch ? { branch: opts.branch } : {}),
             }); // codeql[js/file-access-to-http] — intentional CLI request to own API
-            const babelId = res.data?.babel_id ?? res.data?.run_id ?? res.data?.id;
+            startData = res.data;
+            babelId = res.data?.babel_id ?? res.data?.run_id ?? res.data?.id;
             s.stop(successColor(`Engine run started — Job ID: ${chalk.bold(babelId)}`));
-            if (!opts.poll) {
-                dim('Use `babelize run status ' + babelId + '` to check progress.');
-                if (isJsonMode())
-                    printJson(res.data);
-                return;
-            }
-            const lastData = await pollRunStatus(client, babelId);
-            printCompletionBanner(lastData);
-            if (lastData?.status === 'completed' && opts.pr !== false) {
-                await autoRaisePR(client, projectId, langs, lastData);
-            }
         }
         catch (err) {
             s.stop('Failed to start engine run.');
             handleApiError(err);
         }
+        if (!opts.poll) {
+            if (isJsonMode())
+                printJson(startData);
+            else
+                dim('Use `babelize run status ' + babelId + '` to check progress.');
+            return;
+        }
+        const lastData = await pollRunStatus(client, babelId);
+        // ZIP projects have no repository to open a PR against; their results
+        // are downloaded instead. The local config already knows the source of
+        // its own project, otherwise ask the API.
+        const source = localProject?.projectId === projectId && localProject?.source
+            ? localProject.source
+            : await fetchProjectSource(client, projectId);
+        let autoPr;
+        if (isJsonMode()) {
+            if (opts.pr !== false && source !== 'zip') {
+                autoPr = await autoRaisePR(client, projectId, langs, lastData, true);
+            }
+            printJson(autoPr ? { ...lastData, auto_pr: autoPr } : lastData);
+            return;
+        }
+        renderRunStatus(lastData, { source });
+        printCompletionBanner(lastData);
+        if (opts.pr !== false && source !== 'zip') {
+            await autoRaisePR(client, projectId, langs, lastData, false);
+        }
     });
     run
         .command('status <babelId>')
         .description('Get status of a running or completed babel job')
         .option('--watch', 'Keep polling until job completes')
         .action(async (babelId, opts) => {
+        requireUuid(babelId, 'babel ID');
         const client = getClient();
+        let data;
         if (opts.watch) {
-            const lastData = await pollRunStatus(client, babelId);
-            printCompletionBanner(lastData);
+            data = await pollRunStatus(client, babelId);
         }
         else {
             const s = clack.spinner();
@@ -124,18 +200,21 @@ export function registerRunCommands(program) {
             try {
                 const res = await client.get(`/engine/status/${babelId}`);
                 s.stop();
-                const data = res.data;
-                if (isJsonMode()) {
-                    printJson(data);
-                    return;
-                }
-                renderRunStatus(data);
+                data = res.data;
             }
             catch (err) {
                 s.stop('Failed to fetch status.');
                 handleApiError(err);
             }
         }
+        if (isJsonMode()) {
+            printJson(data);
+            return;
+        }
+        const source = await fetchProjectSource(client, runOf(data).project_id);
+        renderRunStatus(data, { source });
+        if (opts.watch)
+            printCompletionBanner(data);
     });
     run
         .command('analyze')
@@ -148,7 +227,7 @@ export function registerRunCommands(program) {
                 console.error('Error: --project is required in non-interactive mode.');
                 process.exit(ExitCode.USAGE);
             }
-            const result = await clack.text({ message: 'Project ID:' });
+            const result = await clack.text({ message: 'Project ID:', flag: '--project' });
             if (clack.isCancel(result))
                 process.exit(ExitCode.CANCEL);
             projectId = result;
@@ -171,88 +250,126 @@ export function registerRunCommands(program) {
         }
     });
 }
-async function pollRunStatus(client, babelId) {
-    let lastData = null;
-    const MAX_RETRIES = 60;
-    let retryCount = 0;
-    const pipeline = createPipeline(PHASES.map((phaseTitle) => ({
-        title: phaseTitle,
-        task: async (_ctx, task) => {
-            const phaseShort = phaseTitle.split(':')[1]?.trim()?.toLowerCase() ?? '';
-            while (true) {
-                try {
-                    const res = await client.get(`/engine/status/${babelId}`);
-                    lastData = res.data;
-                    const data = res.data;
-                    const status = (data?.status ?? data?.run?.status);
-                    const logs = ((data?.logs ?? data?.run?.logs) ?? []);
-                    if (status === 'completed')
-                        return;
-                    const phaseLog = logs.find((l) => l.step?.toLowerCase().includes(phaseShort));
-                    if (phaseLog?.status === 'completed')
-                        return;
-                    if (phaseLog?.status === 'failed') {
-                        throw new Error(phaseLog.message || `Phase failed: ${phaseTitle}`);
-                    }
-                    if (status === 'failed') {
-                        throw new Error(data?.error ?? data?.run?.error ?? 'Pipeline failed');
-                    }
-                    if (phaseLog?.message) {
-                        task.output = phaseLog.message;
-                    }
-                    retryCount = 0;
-                }
-                catch (err) {
-                    const pollErr = err;
-                    if (pollErr.message?.includes('failed') || pollErr.message?.includes('Pipeline')) {
-                        throw err;
-                    }
-                    retryCount++;
-                    if (retryCount >= MAX_RETRIES) {
-                        throw new Error(`Timed out waiting for pipeline to complete after ${MAX_RETRIES} retries`, { cause: err });
-                    }
-                    task.output = `Transient error, retrying (${retryCount}/${MAX_RETRIES})…`;
-                }
-                await delay(2500);
-            }
-        },
-    })));
-    try {
+const POLL_INTERVAL_MS = 2500;
+const MAX_CONSECUTIVE_FAILURES = 60;
+function runOf(data) {
+    return (data?.run ?? data ?? {});
+}
+/**
+ * Poll a run until it ends, showing each phase as it finishes.
+ *
+ * Returns the final status payload of a completed run. A run that ends any
+ * other way exits the process:
+ *   - failed    → ExitCode.API_ERROR (6), with the run's error
+ *   - cancelled → ExitCode.CANCEL (128), the code the CLI already uses for
+ *                 anything the user cancelled, so it never looks like success
+ * With --json, the final payload is printed before exiting on failed or
+ * cancelled; a completed run's payload is left to the caller.
+ */
+export async function pollRunStatus(client, babelId, options = {}) {
+    const intervalMs = options.intervalMs ?? POLL_INTERVAL_MS;
+    const json = isJsonMode();
+    const s = clack.spinner();
+    let announced = 0;
+    let failures = 0;
+    let spinning = false;
+    const startSpinner = (msg) => { s.start(msg); spinning = true; };
+    const stopSpinner = (msg) => { if (spinning)
+        s.stop(msg); spinning = false; };
+    if (!json)
         console.log(`\n  ${renderRunTitle(babelId)}\n`);
-        await pipeline.run();
-        divider();
-        if (lastData) {
-            if (isJsonMode()) {
-                printJson(lastData);
-            }
-            else {
-                renderRunStatus(lastData);
+    startSpinner('Waiting for the run to start…');
+    while (true) {
+        let data;
+        try {
+            const res = await client.get(`/engine/status/${babelId}`);
+            data = (res.data ?? {});
+            failures = 0;
+        }
+        catch (err) {
+            const status = axios.isAxiosError(err) ? err.response?.status : undefined;
+            failures++;
+            // A 4xx (other than rate limiting) will not fix itself: report it now.
+            if ((status && status >= 400 && status < 500 && status !== 429) || failures >= MAX_CONSECUTIVE_FAILURES) {
+                stopSpinner();
+                handleApiError(err);
             }
+            s.message(`Connection problem, retrying (${failures}/${MAX_CONSECUTIVE_FAILURES})…`);
+            await delay(intervalMs);
+            continue;
         }
-        return lastData;
-    }
-    catch (err) {
-        if (isJsonMode()) {
-            printJson({ error: err.message, babel_id: babelId, status: 'failed' });
+        const run = runOf(data);
+        const status = String(run.status ?? '');
+        const logs = (Array.isArray(run.logs) ? run.logs : []);
+        const progress = computePhaseProgress(logs, status);
+        // Announce each phase once, in order, as it finishes.
+        while (announced < RUN_PHASES.length && progress.states[announced] === 'done') {
+            if (!spinning)
+                startSpinner(RUN_PHASES[announced].title);
+            stopSpinner(successColor(`${sym.check} ${RUN_PHASES[announced].title}`));
+            announced++;
+        }
+        if (status === 'completed') {
+            stopSpinner();
+            return data;
+        }
+        if (status === 'failed') {
+            const failedLog = [...logs].reverse().find((l) => String(l.status) === 'error');
+            const reason = run.error ?? failedLog?.message ?? 'unknown error';
+            if (!spinning)
+                startSpinner(RUN_PHASES[announced]?.title ?? 'Run');
+            stopSpinner(errorColor(`${sym.cross} Run failed: ${reason}`));
+            if (json)
+                printJson(data);
+            process.exit(ExitCode.API_ERROR);
+        }
+        if (status === 'cancelled') {
+            if (!spinning)
+                startSpinner(RUN_PHASES[announced]?.title ?? 'Run');
+            stopSpinner(warningColor(`${sym.warn} Run cancelled. Nothing from this run was applied.`));
+            if (json)
+                printJson(data);
+            process.exit(ExitCode.CANCEL);
+        }
+        if (TERMINAL_STATUSES.has(status))
+            return data;
+        if (!spinning)
+            startSpinner(RUN_PHASES[announced]?.title ?? 'Working…');
+        if (progress.current >= 0) {
+            const title = RUN_PHASES[progress.current].title;
+            s.message(progress.message ? `${title}: ${progress.message}` : title);
         }
         else {
-            console.log(errorColor(`Babel run failed: ${err.message}`));
+            s.message(status === 'queued' ? 'Queued, waiting for a worker…' : 'Waiting for the run to start…');
         }
-        process.exit(ExitCode.API_ERROR);
+        await delay(intervalMs);
     }
 }
 function printCompletionBanner(lastData) {
-    const status = lastData?.status ?? 'unknown';
-    if (status === 'completed') {
+    if (runOf(lastData).status === 'completed') {
         console.log('');
         success('All done! Translation run completed successfully.');
     }
 }
-async function autoRaisePR(client, projectId, targetLocales, lastData) {
-    const run = (lastData?.run ?? lastData);
-    if (run?.pr_url) {
-        success(`PR already created: ${chalk.cyan.underline(run.pr_url)}`);
-        return;
+/** The project's source (`github` | `zip`), or undefined when it cannot be read. */
+async function fetchProjectSource(client, projectId) {
+    if (!projectId)
+        return undefined;
+    try {
+        const res = await client.get(`/projects/${projectId}`);
+        const project = (res?.data?.project ?? res?.data);
+        return typeof project?.source === 'string' ? project.source : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function autoRaisePR(client, projectId, targetLocales, lastData, quiet) {
+    const run = runOf(lastData);
+    if (run.pr_url) {
+        if (!quiet)
+            success(`PR already created: ${chalk.cyan.underline(run.pr_url)}`);
+        return { status: 'exists', url: run.pr_url };
     }
     const s = clack.spinner();
     s.start('Auto-creating GitHub PR with translations…');
@@ -262,30 +379,45 @@ async function autoRaisePR(client, projectId, targetLocales, lastData) {
         });
         s.stop();
         const prUrl = res.data?.pr_url ?? res.data?.url;
-        if (prUrl) {
-            success(`PR created: ${chalk.cyan.underline(prUrl)}`);
-        }
-        else {
-            success('PR created successfully. Check your GitHub repository.');
+        if (!quiet) {
+            if (prUrl)
+                success(`PR created: ${chalk.cyan.underline(prUrl)}`);
+            else
+                success('PR created successfully. Check your GitHub repository.');
         }
+        return { status: 'created', url: prUrl };
     }
     catch (err) {
         s.stop();
         const apiErr = err;
-        if (apiErr?.response?.status === 409) {
-            dim('PR already exists for this project.');
+        if (apiErr?.response?.status === 409 && apiErr.response.data?.error_code === 'pr_open') {
+            const message = `PR #${apiErr.response.data.pr_number ?? '?'} is still open. Run \`babelize pr update ${projectId}\` to add this run to it (or \`babelize pr raise ${projectId} --new\` for a new PR).`;
+            if (!quiet)
+                dim(message);
+            return { status: 'exists', message };
         }
-        else if (apiErr?.response?.data?.requires_app_install) {
-            warning('GitHub App not installed. Install it from the project page to enable auto-PR.');
-            dim('Run `babelize pr raise ' + projectId + '` after installing.');
+        if (apiErr?.response?.status === 409) {
+            const message = apiErr.response.data?.error ?? 'PR already exists for this project.';
+            if (!quiet)
+                dim(message);
+            return { status: 'exists', message };
         }
-        else {
-            dim('Could not auto-create PR. Run `babelize pr raise ' + projectId + '` to try manually.');
+        if (apiErr?.response?.data?.requires_app_install) {
+            const message = 'GitHub App not installed. Install it from the project page to enable auto-PR.';
+            if (!quiet) {
+                warning(message);
+                dim('Run `babelize pr raise ' + projectId + '` after installing.');
+            }
+            return { status: 'failed', message };
         }
+        const message = 'Could not auto-create PR. Run `babelize pr raise ' + projectId + '` to try manually.';
+        if (!quiet)
+            dim(message);
+        return { status: 'failed', message };
     }
 }
-function renderRunStatus(data) {
-    const run = (data.run ?? data);
+export function renderRunStatus(data, options = {}) {
+    const run = runOf(data);
     keyValue({
         id: run.id,
         status: statusBadge(run.status),
@@ -320,13 +452,8 @@ function renderRunStatus(data) {
             processing_time: stats.processing_time_ms ? `${stats.processing_time_ms}ms` : null,
         }, 'Stats');
     }
-    // Local artifacts
     const projectId = run.project_id;
-    if (projectId) {
-        section('Local Artifacts');
-        dim(`Staging: .babelize/${projectId}/staging/`);
-    }
-    // Warnings (capped)
+    // Pipeline log
     const logs = run.logs;
     if (logs?.length) {
         section('Pipeline Log');
@@ -336,7 +463,7 @@ function renderRunStatus(data) {
             { key: 'message', header: 'Message', width: 60 },
         ]);
     }
-    // Warnings from activity payload
+    // Warnings from activity payload (capped)
     const warnings = data.warnings;
     if (warnings?.length) {
         const DUPE_CAP = 10;
@@ -347,16 +474,21 @@ function renderRunStatus(data) {
         if (shown.length > 0) {
             section('Warnings');
             for (const w of shown) {
-                console.log(`  ${warning('⚠')} ${w.message ?? ''}`);
+                console.log(`  ${warningColor(sym.warn)} ${w.message ?? ''}`);
             }
             if (remaining > 0) {
                 dim(`  … and ${remaining} more duplicate-key warnings. Use --json for full list.`);
             }
         }
     }
-    // PR hint
+    // Next step: ZIP projects download their results; GitHub projects open a PR.
     if (run.status === 'completed' && !run.pr_url && projectId) {
-        dim('Run `babelize pr raise ' + projectId + '` to open a GitHub PR with the translations.');
+        if (options.source === 'zip') {
+            dim('Run `babelize projects download ' + projectId + '` to download the translated files.');
+        }
+        else {
+            dim('Run `babelize pr raise ' + projectId + '` to open a GitHub PR with the translations.');
+        }
     }
 }
 //# sourceMappingURL=run.js.map