@meshy-ai/cli 0.4.6 → 0.6.0

package/dist/internal/task-command.js

@@ -3,14 +3,11 @@
  * subcommands for any registered task resource. Per-resource modules only
  * contribute their unique `create` flag shape and payload validation.
  *
- * Two output schemas share one execution path:
- *   legacy — the 0.2.0 payloads and `-o` status report, with two documented
- *            fixes: `get` of a non-terminal task exits 0, and async create
- *            never polls.
- *   v1     — one `meshy.cli/v1` envelope whose result carries the TaskView,
- *            the submission record and the download manifest.
+ * Every verb prints one `meshy.cli/v1` envelope whose result carries the
+ * TaskView, the submission record and the download manifest. `get` of a task
+ * in any status is a successful query (exit 0); async create never polls.
  *
- * Money rules enforced here, independent of schema:
+ * Money rules enforced here:
  *   - every create is exactly one POST, journaled before it is sent;
  *   - a lost or malformed response is `submission_unknown` (exit 10), never a
  *     retry and never a "please run it again" hint;
@@ -26,34 +23,32 @@ import { Command, Option } from "commander";
 import { MeshyApiError } from "../client/errors.js";
 import { requireTaskResource } from "../client/resource-registry.js";
 import { TransportError } from "../client/transport.js";
-import { isTerminalStatus, summarizeTask } from "../client/types.js";
-import { emitResult, openCommand, rejectOutputFlagForV1, saveRawJson } from "./command-helpers.js";
+import { emitResult, openCommand, rejectOutputFlag, saveRawJson } from "./command-helpers.js";
 import { abortSignal, wasInterrupted } from "./context.js";
-import { downloadArtifacts, looksLikeFile } from "./download.js";
+import { downloadTaskAssets } from "./download.js";
 import { classifyError, CliError, UsageError } from "./errors.js";
 import { normalizeMediaPayload } from "./file-input.js";
+import { allAssetsOption, outputOption } from "./global-options.js";
 import { logger } from "./logger.js";
 import { mergeNestedObjects, mergePayload, parseJsonFlag } from "./payload.js";
-import { painterFor } from "./color.js";
-import { taskCard } from "./views.js";
-import { emitEnvelope, emitStreamEvent, emit } from "./output.js";
+import { emitEnvelope, emitStreamEvent } from "./output.js";
 import { parseTimeoutSeconds, pollUntilTerminal } from "./poll.js";
 import { createProgress, withSpinner } from "./progress.js";
-import { printReport } from "./report.js";
 import { errorEnvelope, okEnvelope, warning } from "./result.js";
 import { buildRuntime } from "./runtime.js";
-import { getUpdateNotice, printHumanUpdateHint } from "./update-notifier.js";
 import { streamTask } from "./stream.js";
 import { toTaskView } from "./task-view.js";
 import { beginOperation, credentialBinding, credentialFingerprint, newOperationId, operationsRoot, payloadFingerprint, updateOperation, } from "./operation-store.js";
 import { originOf } from "./config.js";
-import { resolveWithinRoot, freezeRoot } from "./paths.js";
+import { freezeRoot, looksLikeFile, resolveWithinRoot } from "./paths.js";
 import { assertProjectMetadataPresent, indexRootFor, projectRecordCommand, recordTask, saveTaskSnapshot, stageFromTaskType } from "./project-store.js";
 import { existsSync } from "node:fs";
 import { dirname, join, resolve as resolvePath } from "node:path";
 const TASK_JSON_OPTIONS = (cmd) => cmd
+    .addOption(outputOption())
+    .addOption(allAssetsOption())
     .option("--save-json <file>", "save the full task JSON as received (never overwrites)")
-    .option("--include-raw", "v1: include the untouched task response under result.task.raw")
+    .option("--include-raw", "include the untouched task response under result.task.raw")
     .option("--project <dir>", "initialised meshy_output project: save task_<id>.json there and record the task in metadata.json")
     .option("--stage <name>", "stage label for the project record (default: derived from the task type, e.g. preview | refine | build)");
 const NOT_REQUESTED = () => ({ state: "not_requested", files: [], metadata_path: null });
@@ -69,9 +64,9 @@ function taskResult(o) {
 function nextCommands(descriptor, taskId) {
     const base = `meshy ${descriptor.commandPath.join(" ")}`;
     return {
-        get: `${base} get ${taskId} --output-schema v1`,
-        wait: `${base} wait ${taskId} --output-schema v1`,
-        stream: `${base} stream ${taskId} --format ndjson --output-schema v1`,
+        get: `${base} get ${taskId}`,
+        wait: `${base} wait ${taskId}`,
+        stream: `${base} stream ${taskId} --format ndjson`,
     };
 }
 /**
@@ -196,7 +191,7 @@ function attachToProject(opts, opened, descriptor, taskId, task, raw, extra, war
         stage,
         resource: descriptor.id,
         taskType: task?.type ?? null,
-        endpoint: descriptor.legacyEndpoint,
+        endpoint: descriptor.endpoint,
         parentTaskId: parentTaskIdFromPayload(extra.payload ?? null),
         status: task?.status ?? null,
         taskJson: null,
@@ -228,8 +223,6 @@ function attachToProject(opts, opened, descriptor, taskId, task, raw, extra, war
         const rec = recordTask(located, input, { root: indexRoot.root, skipIndex: indexRoot.skipIndex });
         if (!rec.index.updated)
             warnings.push(warning("index_dirty", `metadata.json committed but history.json was not updated: ${rec.index.error}; run \`meshy project rebuild-index\``));
-        if (rec.migrated_from_legacy)
-            warnings.push(warning("metadata_migrated", "legacy metadata.json migrated to schema_version 2 (backup kept beside it)"));
         return { project_dir: projectDir, snapshot: snapshot?.path ?? null, stage, action: rec.action, index: rec.index };
     }
     catch (err) {
@@ -349,7 +342,6 @@ export function buildResourceCommand(spec) {
     const descriptor = requireTaskResource(spec.name);
     const endpointOf = spec.endpointOf ?? ((client) => client.endpointFor(descriptor));
     const prefix = spec.commandPrefix ?? spec.name;
-    const defaultSchema = spec.defaultSchema ?? "legacy";
     const cmd = new Command(spec.commandName ?? spec.name).description(spec.description);
     // create
     const createCmd = new Command("create").description(spec.create.description);
@@ -360,7 +352,7 @@ export function buildResourceCommand(spec) {
         .addOption(new Option("--timeout <seconds>", "max seconds to poll in sync mode; the task keeps running after it (resume with `wait`; the API advises allowing up to 60 min)").default("600"))
         .addOption(new Option("--operation-id <id>", "local journal id for this submission; repeating it returns the recorded outcome instead of submitting again (local record only, not a server idempotency key)"))
         .action(async (opts, thisCmd) => {
-        const opened = openCommand(thisCmd, `${prefix}.create`, defaultSchema);
+        const opened = openCommand(thisCmd, `${prefix}.create`);
         const timeoutSeconds = parseTimeoutSeconds(opts.timeout ?? "600");
         const runAsync = Boolean(opts.async);
         const includeRaw = Boolean(opts.includeRaw);
@@ -369,45 +361,36 @@ export function buildResourceCommand(spec) {
         // 1. Build and validate the payload — every local failure happens here, before the journal and the POST.
         const data = parseJsonFlag(opts.data, "--data");
         const flagPayload = spec.create.toPayload(opts);
-        const defaults = spec.create.toDefaults?.(opts) ?? {};
+        const defaults = spec.create.toDefaults?.(opts, data) ?? {};
         const layers = [defaults, data, flagPayload];
         let merged = mergePayload(...layers);
         if (spec.create.nestedObjectKeys && spec.create.nestedObjectKeys.length > 0) {
             merged = mergeNestedObjects(merged, layers, spec.create.nestedObjectKeys);
         }
         spec.create.validatePayload?.(merged, opts);
+        const payloadWarnings = spec.create.warnPayload?.(merged) ?? [];
         const { payload } = await normalizeMediaPayload(merged, descriptor.mediaFields, { signal: abortSignal() });
         logger.debug("create payload", redactForLog(payload));
         // 2. Local targets that would fail after the POST are refused before it.
         preflightLocalTargets(opts, opened);
         // 3. Journal, then exactly one POST.
         const submitted = await submitCreate(runtime, descriptor, endpoint, payload, opts.operationId ?? null);
-        const { taskId, raw: createRaw, operationId, warnings } = submitted;
+        const { taskId, raw: createRaw, operationId } = submitted;
+        const warnings = [...payloadWarnings, ...submitted.warnings];
         const submission = { state: "accepted", operation_id: operationId, task_id: taskId, request_id: submitted.requestId };
         if (runAsync) {
             const ctx = { descriptor, taskId, task: null, raw: null, submission, includeRaw };
             const savedJson = saveJsonInContext(opts, opened, createRaw, ctx);
             const project = attachInContext(opts, opened, descriptor, taskId, null, null, { operationId, payload }, warnings, { ...ctx, savedJson });
-            if (opened.schema === "v1") {
-                await emitEnvelope(okEnvelope(opened.command, taskResult({
-                    task: null,
-                    raw: null,
-                    descriptor,
-                    includeRaw: false,
-                    submission,
-                    savedJson,
-                    extra: { task_id: taskId, next: nextCommands(descriptor, taskId), project },
-                }), warnings), opened.format);
-                return;
-            }
-            emit({
-                resource: spec.name,
-                task_id: taskId,
-                status: "PENDING",
-                hint: `meshy-cli ${descriptor.commandPath.join(" ")} wait ${taskId}`,
-                operation_id: operationId,
-                ...(project ? { project_dir: project.project_dir } : {}),
-            }, { format: opened.format, file: undefined });
+            await emitEnvelope(okEnvelope(opened.command, taskResult({
+                task: null,
+                raw: null,
+                descriptor,
+                includeRaw: false,
+                submission,
+                savedJson,
+                extra: { task_id: taskId, next: nextCommands(descriptor, taskId), project },
+            }), warnings), opened.format);
             return;
         }
         // 4. Sync: poll the id we just recorded.
@@ -416,7 +399,7 @@ export function buildResourceCommand(spec) {
     cmd.addCommand(createCmd);
     // get
     TASK_JSON_OPTIONS(cmd.command("get <task-id>").description("Retrieve a single task by id (any status is a successful query)")).action(async (taskId, opts, thisCmd) => {
-        const opened = openCommand(thisCmd, `${prefix}.get`, defaultSchema);
+        const opened = openCommand(thisCmd, `${prefix}.get`);
         beginProjectContext(opts, opened);
         const runtime = await buildRuntime(opened.flags);
         const { task, raw } = await endpointOf(runtime.client).retrieveDetailed(taskId, { signal: abortSignal() });
@@ -426,25 +409,16 @@ export function buildResourceCommand(spec) {
         const ctx = { descriptor, taskId, task, raw, submission, includeRaw };
         const savedJson = saveJsonInContext(opts, opened, raw, ctx);
         const project = attachInContext(opts, opened, descriptor, taskId, task, raw, {}, warnings, { ...ctx, savedJson });
-        if (opened.schema === "v1") {
-            const downloads = await maybeDownloadV1(opened, descriptor, task, raw, submission, warnings, { savedJson, includeRaw, project });
-            await emitEnvelope(okEnvelope(opened.command, taskResult({ task, raw, descriptor, includeRaw, submission, downloads, savedJson, extra: project ? { project } : {} }), warnings), opened.format);
-            return;
-        }
-        // Legacy shape, same rule: a download failure still names the task.
-        try {
-            await emitLegacyOutcome(task, false, undefined, spec.name, runtime, { query: true });
-        }
-        catch (err) {
-            throw withTaskContext(err, { ...ctx, savedJson, extra: project ? { project } : {} });
-        }
+        const downloads = await maybeDownloadV1(opened, descriptor, task, raw, submission, warnings, { savedJson, includeRaw, project });
+        await emitEnvelope(okEnvelope(opened.command, taskResult({ task, raw, descriptor, includeRaw, submission, downloads, savedJson, extra: project ? { project } : {} }), warnings), opened.format);
+        return;
     });
     // wait
     TASK_JSON_OPTIONS(cmd
         .command("wait <task-id>")
         .description("Poll until the task reaches a terminal status")
         .option("--timeout <seconds>", "max seconds to wait (0 = a single query); the task keeps running after it — the API advises allowing up to 60 min", "600")).action(async (taskId, opts, thisCmd) => {
-        const opened = openCommand(thisCmd, `${prefix}.wait`, defaultSchema);
+        const opened = openCommand(thisCmd, `${prefix}.wait`);
         beginProjectContext(opts, opened);
         const timeoutSeconds = parseTimeoutSeconds(opts.timeout ?? "600");
         const runtime = await buildRuntime(opened.flags);
@@ -457,7 +431,7 @@ export function buildResourceCommand(spec) {
         .description("Follow the task over Server-Sent Events until it is terminal")
         .option("--timeout <seconds>", "total deadline for the stream", "600")
         .option("--idle-timeout <seconds>", "abort when no bytes arrive for this long (keep-alives count)", "60")).action(async (taskId, opts, thisCmd) => {
-        const opened = openCommand(thisCmd, `${prefix}.stream`, defaultSchema);
+        const opened = openCommand(thisCmd, `${prefix}.stream`);
         beginProjectContext(opts, opened);
         if (!descriptor.supports.stream)
             throw new UsageError(`${spec.name} does not support stream`);
@@ -478,8 +452,8 @@ export function buildResourceCommand(spec) {
         ? "Cancel a task: PENDING is refunded, IN_PROGRESS is not; a finished task cannot be canceled (the task is kept as CANCELED, not deleted)"
         : "Permanently delete a task (a PENDING task is refunded; an IN_PROGRESS one cannot be stopped and is refused with exit 14; a finished one is deleted without a refund)")
         .action(async (taskId, _opts, thisCmd) => {
-        const opened = openCommand(thisCmd, `${prefix}.delete`, defaultSchema);
-        rejectOutputFlagForV1(opened, undefined);
+        const opened = openCommand(thisCmd, `${prefix}.delete`);
+        rejectOutputFlag(opened, undefined);
         const runtime = await buildRuntime(opened.flags);
         let raw;
         try {
@@ -489,7 +463,7 @@ export function buildResourceCommand(spec) {
             throw deleteFailure(err, taskId, nextCommands(descriptor, taskId).wait);
         }
         const outcome = cancels ? { deleted: false, canceled: true } : { deleted: true };
-        await emitResult(opened, { resource: spec.name, task_id: taskId, ...outcome }, { resource: spec.name, endpoint: descriptor.legacyEndpoint, task_id: taskId, ...outcome, response: raw ?? null }, { legacyFile: opened.flags.output });
+        await emitResult(opened, { resource: spec.name, endpoint: descriptor.endpoint, task_id: taskId, ...outcome, response: raw ?? null });
     });
     // list
     if (spec.supportsList !== false && descriptor.supports.list) {
@@ -500,10 +474,10 @@ export function buildResourceCommand(spec) {
             .option("--page-size <n>", "page size", "10")
             .option("--sort-by <field>", "sort order (e.g. -created_at)", "-created_at")
             .option("--save-json <file>", "save the raw list response (never overwrites)")
-            .option("--include-raw", "v1: include each raw task under items[].raw")
+            .option("--include-raw", "include each raw task under items[].raw")
             .action(async (opts, thisCmd) => {
-            const opened = openCommand(thisCmd, `${prefix}.list`, defaultSchema);
-            rejectOutputFlagForV1(opened, opts.saveJson);
+            const opened = openCommand(thisCmd, `${prefix}.list`);
+            rejectOutputFlag(opened, opts.saveJson);
             const runtime = await buildRuntime(opened.flags);
             const page = { page_num: Number(opts.page ?? 1), page_size: Number(opts.pageSize ?? 10), sort_by: String(opts.sortBy ?? "-created_at") };
             if (!Number.isInteger(page.page_num) || page.page_num < 1)
@@ -513,12 +487,12 @@ export function buildResourceCommand(spec) {
             const { tasks, raw } = await endpointOf(runtime.client).listDetailed(page, { signal: abortSignal() });
             const savedJson = opts.saveJson ? saveRawJson(opts.saveJson, raw, { workspace: opened.flags.workspaceRoot }) : null;
             const rawItems = Array.isArray(raw) ? raw : [];
-            await emitResult(opened, tasks.map((t) => summarizeTask(t)), {
+            await emitResult(opened, {
                 items: tasks.map((t, i) => toTaskView(rawItems[i] ?? t, { descriptor, includeRaw: Boolean(opts.includeRaw) })),
                 count: tasks.length,
                 page,
                 saved_json: savedJson,
-            }, { legacyFile: opened.flags.output });
+            });
         });
     }
     else {
@@ -598,7 +572,7 @@ export async function submitCreate(runtime, descriptor, endpoint, payload, reque
     const credential = credentialIdentityFor(runtime, apiOrigin);
     const identity = {
         resource: descriptor.id,
-        endpoint: descriptor.legacyEndpoint,
+        endpoint: descriptor.endpoint,
         apiOrigin,
         credentialFingerprint: credential.fingerprint,
         credentialVerified: credential.verified,
@@ -656,7 +630,7 @@ export async function submitCreate(runtime, descriptor, endpoint, payload, reque
             recovery: {
                 action: "reconcile",
                 automatic: false,
-                command: `meshy ${descriptor.commandPath.join(" ")} list --output-schema v1   # then match operation ${operationId} by time/prompt before creating again`,
+                command: `meshy ${descriptor.commandPath.join(" ")} list   # then match operation ${operationId} by time/prompt before creating again`,
             },
             hint: resolveHint(operationId),
             result: { submission: { state: "unknown", operation_id: operationId, task_id: null }, task: null, downloads: NOT_REQUESTED(), ...extra },
@@ -700,7 +674,7 @@ function replayExisting(record, descriptor, operationId, extra) {
         throw new CliError({
             code: "submission_unknown",
             message: `operation ${operationId} is recorded as '${record.state}' since ${record.updated_at}; reconcile it before submitting again (nothing was sent now)`,
-            recovery: { action: "reconcile", automatic: false, command: `meshy ${descriptor.commandPath.join(" ")} list --output-schema v1` },
+            recovery: { action: "reconcile", automatic: false, command: `meshy ${descriptor.commandPath.join(" ")} list` },
             hint: resolveHint(operationId),
             result: { submission: { state: "unknown", operation_id: operationId, task_id: record.task_id }, task: null, ...extra },
         });
@@ -732,8 +706,8 @@ function attachSubmission(err, submission, warnings) {
     return err;
 }
 /**
- * v1 `-o`: download a SUCCEEDED task's assets through the legacy layout,
- * confined to the workspace when one is set. A failure keeps the task in the
+ * `-o`: save a SUCCEEDED task's default selection (every asset with
+ * --all-assets), confined to the workspace when one is set. A failure keeps the task in the
  * result — the assets are still on the server, the task still exists.
  */
 async function maybeDownloadV1(opened, descriptor, task, raw, submission, warnings, ctx) {
@@ -743,14 +717,14 @@ async function maybeDownloadV1(opened, descriptor, task, raw, submission, warnin
     if (task.status !== "SUCCEEDED")
         return { state: "not_ready", files: [], metadata_path: null };
     try {
-        const { files, metadataPath, materialLinks } = await withSpinner(opened.format, "Downloading assets", () => downloadArtifacts(task, output, descriptor.id, { root: opened.flags.workspaceRoot, signal: abortSignal() }));
-        if (materialLinks)
-            warnings.push(...materialLinks.warnings);
+        const { files, metadataPath, materialLinks, skipped, warnings: transferWarnings } = await withSpinner(opened.format, "Downloading assets", () => downloadTaskAssets(task, output, descriptor, { root: opened.flags.workspaceRoot, signal: abortSignal(), allAssets: opened.flags.allAssets }));
+        warnings.push(...transferWarnings.map((w) => warning(w.code, w.message)));
         return {
             state: "completed",
             files: files.map((f) => ({ key: f.key, path: f.path, status: f.status, bytes: f.bytes, sha256: f.sha256, error: f.error })),
             metadata_path: metadataPath,
             material_links: materialLinks,
+            skipped,
         };
     }
     catch (err) {
@@ -835,10 +809,6 @@ async function waitAndReport(opened, runtime, descriptor, endpoint, taskId, time
         throw interruptedError(descriptor, taskId, task ? { task, raw } : seen.last, submission, opts, opened);
     if (task === null) {
         // The deadline passed before the first response arrived; the task id is all we know — and it is enough.
-        if (opened.schema !== "v1") {
-            emitLegacyTimeoutWithoutTask(taskId, descriptor.id, runtime);
-            return;
-        }
         throw new CliError({
             code: "timed_out",
             message: `task ${taskId} did not answer within ${timeoutSeconds}s (no status was received in time${poll.lastError ? `; ${poll.failedPolls} status request(s) failed, last: ${poll.lastError.message}` : ""}); the server keeps running it`,
@@ -851,18 +821,6 @@ async function waitAndReport(opened, runtime, descriptor, endpoint, taskId, time
     const savedJson = saveJsonInContext(opts, opened, raw, ctx);
     const project = attachInContext(opts, opened, descriptor, taskId, task, raw, { operationId: opts.__operationId ?? submission.operation_id ?? null, payload: opts.__payload ?? null }, warnings, { ...ctx, savedJson });
     const projectExtra = project ? { project } : {};
-    if (opened.schema !== "v1") {
-        // The legacy reporter downloads too; whatever fails there — an asset host
-        // 503, a sidecar that cannot be published, Ctrl-C — the error still
-        // carries the accepted task id, the real submission and the resume command.
-        try {
-            await emitLegacyOutcome(task, timedOut, elapsed, descriptor.id, runtime, { query: false });
-        }
-        catch (err) {
-            throw withTaskContext(err, { ...ctx, savedJson, extra: { wait: waitInfo, ...projectExtra } });
-        }
-        return;
-    }
     if (timedOut) {
         throw new CliError({
             code: "timed_out",
@@ -892,20 +850,6 @@ export function retriedPolls(poll) {
 export function retriedWarning(poll) {
     return warning("poll_retried", `${poll.failedPolls} status request(s) failed transiently and were retried at the next poll (last: ${poll.lastError?.message ?? "unknown"})`);
 }
-/** Legacy shape for a wait that timed out before any status arrived: still the task id, still exit 8. */
-function emitLegacyTimeoutWithoutTask(taskId, resourceName, runtime) {
-    if (runtime.flags.output) {
-        const report = { status: "FAIL", taskId, type: resourceName, timedOut: true };
-        const notice = getUpdateNotice();
-        if (notice)
-            report._notice = notice;
-        printReport(report);
-    }
-    else {
-        emit({ resource: resourceName, id: taskId, status: null, timed_out: true }, { format: runtime.flags.format });
-    }
-    process.exitCode = 8;
-}
 function interruptedError(descriptor, taskId, last, submission, opts, opened, savedJson = null) {
     let saved = savedJson;
     if (!saved && opts.saveJson && last) {
@@ -940,7 +884,7 @@ async function streamAndReport(opened, runtime, descriptor, endpoint, taskId, ti
         },
         onTask: async (task, raw) => {
             progress.tick(task.status, task.progress);
-            if (opened.schema === "v1" && ndjson) {
+            if (ndjson) {
                 sequence += 1;
                 const event = {
                     ...okEnvelope(opened.command, taskResult({ task, raw, descriptor, includeRaw, submission })),
@@ -1008,20 +952,6 @@ async function streamAndReport(opened, runtime, descriptor, endpoint, taskId, ti
             finalError = bookkeepingError;
         }
     }
-    if (opened.schema !== "v1") {
-        // Legacy has no stream shape to preserve: reuse the terminal summary path (which honours -o itself).
-        if (finalError)
-            throw finalError;
-        if (outcome.task) {
-            try {
-                await emitLegacyOutcome(outcome.task, false, outcome.elapsedMs / 1000, descriptor.id, runtime, { query: false });
-            }
-            catch (err) {
-                throw withTaskContext(err, { ...ctx, savedJson, extra: { stream: streamInfo, ...projectExtra } });
-            }
-        }
-        return;
-    }
     // The terminal outcome includes the requested download whatever the output
     // format: `-o` means "put the assets on disk", not "only when printing JSON".
     if (!finalError && outcome.task && outcome.task.status === "SUCCEEDED") {
@@ -1057,81 +987,6 @@ function wrapStreamError(err, result, warnings) {
     }
     return new CliError({ code: "protocol", message: "stream ended abnormally", result, warnings });
 }
-/**
- * Legacy reporter. `query: true` is `get`: a valid task is a successful query
- * whatever its status (0.2.0 exited 1 for PENDING/IN_PROGRESS — fixed); a
- * terminal FAILED/CANCELED still exits 1 for compatibility.
- */
-async function emitLegacyOutcome(task, timedOut, elapsedSeconds, resourceName, runtime, mode) {
-    const output = runtime.flags.output;
-    const succeeded = !timedOut && task.status === "SUCCEEDED";
-    const pretty = runtime.flags.format === "pretty";
-    if (output) {
-        if (succeeded) {
-            const { savedFiles, metadataPath } = await withSpinner(runtime.flags.format, "Downloading assets", () => downloadArtifacts(task, output, resourceName, { root: runtime.flags.workspaceRoot, signal: abortSignal() }));
-            if (pretty) {
-                printTaskCard(task, savedFiles);
-                return;
-            }
-            const successReport = {
-                status: "SUCCESS",
-                taskId: task.id,
-                type: task.type || resourceName,
-                savedFiles,
-                metadataPath,
-            };
-            const successNotice = getUpdateNotice();
-            if (successNotice)
-                successReport._notice = successNotice;
-            printReport(successReport);
-            return;
-        }
-        const report = {
-            status: "FAIL",
-            taskId: task.id,
-            type: task.type || resourceName,
-        };
-        if (timedOut)
-            report.timedOut = true;
-        else if (task.task_error?.message)
-            report.error = task.task_error.message;
-        else if (task.status)
-            report.error = `task status: ${task.status}`;
-        const failNotice = getUpdateNotice();
-        if (failNotice)
-            report._notice = failNotice;
-        if (pretty)
-            printTaskCard(task, []);
-        else
-            printReport(report);
-        if (timedOut)
-            process.exitCode = 8;
-        else if (mode.query && !isTerminalStatus(task.status))
-            process.exitCode = 0;
-        else
-            process.exitCode = 1;
-        return;
-    }
-    emit({
-        resource: resourceName,
-        ...summarizeTask(task, elapsedSeconds),
-        ...(timedOut ? { timed_out: true } : {}),
-    }, { format: runtime.flags.format });
-    if (timedOut)
-        process.exitCode = 8;
-    else if (task.status === "SUCCEEDED")
-        process.exitCode = 0;
-    else if (!isTerminalStatus(task.status))
-        process.exitCode = mode.query ? 0 : 1;
-    else
-        process.exitCode = 1;
-}
-/** Kept for make.ts (legacy path). */
-/** The `-o` report for a person: the task card with the files it saved, the update hint on stderr. */
-function printTaskCard(task, saved) {
-    process.stdout.write(`${taskCard(toTaskView(task), painterFor(process.stdout), { saved }).join("\n")}\n`);
-    printHumanUpdateHint(getUpdateNotice(), process);
-}
 /** Freeze the progress line with how the wait or stream ended. */
 function endProgress(progress, task, timedOut, abandoned) {
     if (abandoned)
@@ -1143,8 +998,5 @@ function endProgress(progress, task, timedOut, abandoned) {
     else
         progress.finish("failed", task?.status ?? "no status received");
 }
-export async function emitTerminalOutcome(task, timedOut, elapsedSeconds, resourceName, runtime) {
-    await emitLegacyOutcome(task, timedOut, elapsedSeconds, resourceName, runtime, { query: false });
-}
 export { taskResult as buildTaskResult, nextCommands as taskNextCommands };
 //# sourceMappingURL=task-command.js.map