@levr-one/cli 0.10.20 → 0.10.22

package/dist/cli.js

@@ -175,7 +175,7 @@ Examples:
 		aliases: { y: "yes" }
 	},
 	loader: async () => {
-		const { mcpAddHandler } = await import("./addHandler-r0Yw1vu-.js");
+		const { mcpAddHandler } = await import("./addHandler-DUulKXOX.js");
 		return mcpAddHandler;
 	}
 });
@@ -213,7 +213,7 @@ Examples:
 		aliases: { d: "device-code" }
 	},
 	loader: async () => {
-		const { loginHandler } = await import("./loginHandler-DMjKtKj5.js");
+		const { loginHandler } = await import("./loginHandler-DSznhtmk.js");
 		return loginHandler;
 	}
 });
@@ -232,7 +232,7 @@ Examples:
 	},
 	parameters: {},
 	loader: async () => {
-		const { logoutHandler } = await import("./logoutHandler-BFutKash.js");
+		const { logoutHandler } = await import("./logoutHandler-TSQlZGpU.js");
 		return logoutHandler;
 	}
 });
@@ -252,7 +252,7 @@ Examples:
 	},
 	parameters: {},
 	loader: async () => {
-		const { statusHandler } = await import("./statusHandler-WkN652yu.js");
+		const { statusHandler } = await import("./statusHandler-p6CmwgjS.js");
 		return statusHandler;
 	}
 });
@@ -280,7 +280,18 @@ Examples:
   levr push ./results.xml --source "backend-unit-tests"
   levr push ./results.xml --automation-source <uuid>
   levr push ./report.json --source e2e --team-id <uuid>   # explicit team
-  levr push ./test-results.xml   # in CI: source auto-detected`
+  levr push ./test-results.xml   # in CI: source auto-detected
+  levr push e2e-report.xml -s e2e --artifacts e2e-reports --output-results results.json
+
+--artifacts <dir> uploads the screenshots, traces and videos the report
+references (JUnit [[ATTACHMENT|path]], CTRF attachments[]) to their results.
+Paths resolve against <dir> (then the report's directory) and must stay
+inside the working directory. Files over 50 MiB are skipped. An artifact
+problem prints a summary and never changes the push exit code.
+
+--output-results <file> writes every imported result (id, name, suite,
+classname, status, test_key, attempts, attachments) as JSON, for
+levr attach --manifest or later uploads.`
 	},
 	parameters: {
 		positional: {
@@ -339,6 +350,20 @@ Examples:
 				brief: "File format (auto-detected if omitted)",
 				optional: true
 			},
+			artifacts: {
+				kind: "parsed",
+				parse: String,
+				brief: "Upload the artifacts the report references, resolved against this directory",
+				placeholder: "dir",
+				optional: true
+			},
+			"output-results": {
+				kind: "parsed",
+				parse: String,
+				brief: "Write the imported results (ids, test_key, attachments) to a JSON file",
+				placeholder: "file",
+				optional: true
+			},
 			verbose: {
 				kind: "boolean",
 				default: false,
@@ -356,7 +381,7 @@ Examples:
 		}
 	},
 	loader: async () => {
-		const { pushHandler } = await import("./pushHandler-C7nxljuh.js");
+		const { pushHandler } = await import("./pushHandler-Q9Cbo2HC.js");
 		return pushHandler;
 	}
 });
@@ -476,7 +501,7 @@ Examples:
 		}
 	},
 	loader: async () => {
-		const { importHandler } = await import("./importHandler-DAXXM42X.js");
+		const { importHandler } = await import("./importHandler-CUUroX_n.js");
 		return importHandler;
 	}
 });
@@ -497,7 +522,7 @@ Examples:
 	},
 	parameters: {},
 	loader: async () => {
-		const { listHandler } = await import("./listHandler-qFOGgW2z.js");
+		const { listHandler } = await import("./listHandler-CB_9cISi.js");
 		return listHandler;
 	}
 });
@@ -530,7 +555,7 @@ Examples:
 		flags: {}
 	},
 	loader: async () => {
-		const { selectHandler } = await import("./selectHandler-CPeH8ILF.js");
+		const { selectHandler } = await import("./selectHandler-CdOVuuTa.js");
 		return selectHandler;
 	}
 });
@@ -547,7 +572,7 @@ Examples:
 	},
 	parameters: {},
 	loader: async () => {
-		const { currentHandler } = await import("./currentHandler-BBHqC26D.js");
+		const { currentHandler } = await import("./currentHandler-B_sWXNeW.js");
 		return currentHandler;
 	}
 });
@@ -616,14 +641,203 @@ Examples:
 		}
 	},
 	loader: async () => {
-		const { gatesRunHandler } = await import("./runHandler-gaYkPS79.js");
+		const { gatesRunHandler } = await import("./runHandler-DmRAoyJc.js");
 		return gatesRunHandler;
 	}
 });
 
+//#endregion
+//#region src/commands/attach.ts
+const ATTACHMENT_KINDS = [
+	"screenshot",
+	"video",
+	"trace",
+	"stdout_log",
+	"stderr_log",
+	"har",
+	"report",
+	"attachment",
+	"other"
+];
+const attachCommand = buildCommand({
+	docs: {
+		brief: "Attach local files to a Levr entity",
+		fullDescription: `Upload local files (screenshots, trace.zip, videos, logs) and attach them to
+an issue, test, run or execution result, without passing base64 through an
+MCP call.
+
+Targets:
+  ENG-42                         an issue, by identifier
+  TC-5                           a test case
+  TR-3                           a run
+  <related_type>:<uuid>          any entity with attachments, e.g.
+                                 run_result_variant:<uuid>
+                                 automation_run_result:<uuid>
+  <related_type>:<identifier>    an explicit type, e.g. issue:TC-12 for a
+                                 team whose key is TC or TR
+Spoke identifiers (ENG-JP-5) work in every form.
+
+Files are private: only signed-in workspace members can open them. --embed
+also adds a link to the entity so they render there: a new comment on an
+issue, test or run, or an append to an execution result's actual result.
+Files over 50 MiB are skipped.
+
+--manifest <json> attaches a batch: [{ "target": "...", "files": ["..."],
+"kind": "trace", "attempt": 1 }]. --kind and --attempt apply to
+automation_run_result targets only.
+
+Exit code 1 when any file fails, is skipped, or an embed write fails.
+
+Examples:
+  levr attach ENG-42 screenshot.png
+  levr attach run_result_variant:<uuid> shot.png --embed
+  levr attach automation_run_result:<uuid> trace.zip --kind trace --attempt 0
+  levr attach --manifest extra-artifacts.json`
+	},
+	parameters: {
+		positional: {
+			kind: "array",
+			parameter: {
+				parse: String,
+				brief: "Target, then the files to attach",
+				placeholder: "target|file"
+			}
+		},
+		flags: {
+			"workspace-id": {
+				kind: "parsed",
+				parse: String,
+				brief: "Workspace ID (required for multi-workspace JWT auth)",
+				placeholder: "uuid",
+				optional: true
+			},
+			kind: {
+				kind: "enum",
+				values: ATTACHMENT_KINDS,
+				brief: "Artifact kind (automation_run_result targets only)",
+				optional: true
+			},
+			attempt: {
+				kind: "parsed",
+				parse: (v) => {
+					if (!/^\d+$/.test(v)) throw new Error("--attempt must be >= 0");
+					return Number(v);
+				},
+				brief: "Index of the earlier attempt (automation_run_result only; omit for the final attempt)",
+				placeholder: "n",
+				optional: true
+			},
+			embed: {
+				kind: "boolean",
+				default: false,
+				brief: "Also add a markdown link (comment, or actual-result append)"
+			},
+			manifest: {
+				kind: "parsed",
+				parse: String,
+				brief: "JSON file listing [{ target, files, kind?, attempt? }]",
+				placeholder: "file",
+				optional: true
+			},
+			verbose: {
+				kind: "boolean",
+				default: false,
+				brief: "Show detailed output"
+			}
+		},
+		aliases: {
+			w: "workspace-id",
+			k: "kind",
+			e: "embed",
+			m: "manifest",
+			v: "verbose"
+		}
+	},
+	loader: async () => {
+		const { attachHandler } = await import("./attachHandler-DgVCvhz7.js");
+		return attachHandler;
+	}
+});
+
+//#endregion
+//#region src/commands/result/append.ts
+const resultAppendCommand = buildCommand({
+	docs: {
+		brief: "Append to an execution result's actual result",
+		fullDescription: `Append text to an execution result's actual result, server-side (no
+read-modify-write), optionally with local files attached first and embedded
+as markdown links. Attached files are private: the links open for signed-in
+workspace members.
+
+The target is run_result_variant:<uuid> — the execution result id the levr
+MCP tools and levr-browser return.
+
+Examples:
+  levr result append run_result_variant:<uuid> --text "Checkout returns 500"
+  levr result append run_result_variant:<uuid> --file observed.md --attach shot.png trace.zip`
+	},
+	parameters: {
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				parse: String,
+				brief: "run_result_variant:<uuid>",
+				placeholder: "target"
+			}]
+		},
+		flags: {
+			"workspace-id": {
+				kind: "parsed",
+				parse: String,
+				brief: "Workspace ID (required for multi-workspace JWT auth)",
+				placeholder: "uuid",
+				optional: true
+			},
+			text: {
+				kind: "parsed",
+				parse: String,
+				brief: "Text to append",
+				placeholder: "text",
+				optional: true
+			},
+			file: {
+				kind: "parsed",
+				parse: String,
+				brief: "Read the text to append from a file",
+				placeholder: "path",
+				optional: true
+			},
+			attach: {
+				kind: "parsed",
+				parse: String,
+				brief: "Files to attach and embed (repeatable)",
+				placeholder: "file",
+				variadic: true,
+				optional: true
+			},
+			verbose: {
+				kind: "boolean",
+				default: false,
+				brief: "Show detailed output"
+			}
+		},
+		aliases: {
+			w: "workspace-id",
+			t: "text",
+			f: "file",
+			a: "attach",
+			v: "verbose"
+		}
+	},
+	loader: async () => {
+		const { resultAppendHandler } = await import("./appendHandler-u-NvHPDW.js");
+		return resultAppendHandler;
+	}
+});
+
 //#endregion
 //#region package.json
-var version = "0.10.20";
+var version = "0.10.22";
 
 //#endregion
 //#region src/app.ts
@@ -647,6 +861,10 @@ const gatesRoutes = buildRouteMap({
 	routes: { run: gatesRunCommand },
 	docs: { brief: "Run a deliverable's gates and report the raw results" }
 });
+const resultRoutes = buildRouteMap({
+	routes: { append: resultAppendCommand },
+	docs: { brief: "Work with execution results" }
+});
 const routes = buildRouteMap({
 	routes: {
 		mcp: buildRouteMap({
@@ -658,6 +876,8 @@ const routes = buildRouteMap({
 		gates: gatesRoutes,
 		push: pushCommand,
 		import: importCommand,
+		attach: attachCommand,
+		result: resultRoutes,
 		completion: completionCommand
 	},
 	docs: { brief: "The command-line interface for Levr" }
@@ -738,10 +958,10 @@ function envFilePath(cwd, env) {
 * getting silence is the one case where quiet failure hides a real mistake.
 */
 function loadEnvFile(cwd = process.cwd(), env = process.env) {
-	const path = envFilePath(cwd, env);
+	const path$1 = envFilePath(cwd, env);
 	const explicitlyRequested = Boolean(env["LEVR_ENV_FILE"]);
-	if (!existsSync(path)) {
-		if (explicitlyRequested) throw new Error(`LEVR_ENV_FILE points at "${path}", which does not exist.`);
+	if (!existsSync(path$1)) {
+		if (explicitlyRequested) throw new Error(`LEVR_ENV_FILE points at "${path$1}", which does not exist.`);
 		return {
 			path: null,
 			applied: []
@@ -749,7 +969,7 @@ function loadEnvFile(cwd = process.cwd(), env = process.env) {
 	}
 	let parsed;
 	try {
-		parsed = parse(readFileSync(path, "utf8"));
+		parsed = parse(readFileSync(path$1, "utf8"));
 	} catch (error) {
 		if (explicitlyRequested) throw error;
 		return {
@@ -765,7 +985,7 @@ function loadEnvFile(cwd = process.cwd(), env = process.env) {
 		applied.push(key);
 	}
 	return {
-		path,
+		path: path$1,
 		applied
 	};
 }

package/dist/connect-DX41Im8c.js

@@ -0,0 +1,36 @@
+import { client, configureClient } from "./sdk-client-CTvYVr7D.js";
+import { resolveToken } from "./resolve-token-7xb7kG7h.js";
+import { resolveWorkspace } from "./resolve-workspace-B3Gz3-Vh.js";
+
+//#region src/utils/connect.ts
+/**
+* Authenticate the SDK client for a command (ENG-6164): resolve the token,
+* and for a JWT the workspace. Reports the failure and sets exit code 1;
+* returns false when the command must stop.
+*/
+async function connect(ctx, workspaceIdFlag) {
+	let auth;
+	try {
+		auth = await resolveToken();
+	} catch (err) {
+		ctx.logger.error(err instanceof Error ? err.message : "Authentication failed.");
+		ctx.process.exitCode = 1;
+		return false;
+	}
+	configureClient(auth);
+	if (auth.type === "jwt") try {
+		const ws = await resolveWorkspace(workspaceIdFlag);
+		client.setConfig({
+			...client.getConfig(),
+			workspaceId: ws.workspaceId
+		});
+	} catch (err) {
+		ctx.logger.error(err instanceof Error ? err.message : "Workspace resolution failed.");
+		ctx.process.exitCode = 1;
+		return false;
+	}
+	return true;
+}
+
+//#endregion
+export { connect };

package/dist/{currentHandler-BBHqC26D.js → currentHandler-B_sWXNeW.js}

@@ -1,4 +1,4 @@
-import { loadWorkspace } from "./workspace-store-DDOxnut1.js";
+import { loadWorkspace } from "./workspace-store-CnrxyYRB.js";
 
 //#region src/commands/workspace/currentHandler.ts
 function currentHandler() {

package/dist/{importHandler-DAXXM42X.js → importHandler-CUUroX_n.js}

@@ -1,9 +1,9 @@
-import { getApiUrl, getTeamId } from "./env-CHeKHu5S.js";
-import { authGetProfileV1, configureClient, teamFindAllV1, testCaseImportCommitV1, testCaseImportPreviewV1 } from "./sdk-client-vQsoMCez.js";
-import "./workspace-store-DDOxnut1.js";
-import { resolveWorkspace } from "./resolve-workspace--4K7N4VU.js";
-import "./token-refresh-Cu5RpkLJ.js";
-import { resolveToken } from "./resolve-token-DbQsmn03.js";
+import { authGetProfileV1, configureClient, teamFindAllV1, testCaseImportCommitV1, testCaseImportPreviewV1 } from "./sdk-client-CTvYVr7D.js";
+import { getApiUrl, getTeamId } from "./env-CdwyPHGV.js";
+import "./token-refresh-DeusLK8H.js";
+import { resolveToken } from "./resolve-token-7xb7kG7h.js";
+import "./workspace-store-CnrxyYRB.js";
+import { resolveWorkspace } from "./resolve-workspace-B3Gz3-Vh.js";
 import chalk from "chalk";
 import { createReadStream } from "node:fs";
 import { basename } from "node:path";
@@ -269,9 +269,9 @@ const MATCH_COLORS = {
 	manual: chalk.green
 };
 /** Stream the file into a Blob — no readFileSync, no sync stall. */
-async function fileToBlob(path) {
+async function fileToBlob(path$1) {
 	const chunks = [];
-	for await (const chunk of createReadStream(path)) chunks.push(chunk);
+	for await (const chunk of createReadStream(path$1)) chunks.push(chunk);
 	return new Blob(chunks);
 }
 function printMapping(logger, mapping) {

package/dist/{listHandler-qFOGgW2z.js → listHandler-CB_9cISi.js}

@@ -1,8 +1,8 @@
-import "./env-CHeKHu5S.js";
-import { authGetSitesV1, configureClient } from "./sdk-client-vQsoMCez.js";
-import { loadWorkspace } from "./workspace-store-DDOxnut1.js";
-import "./token-refresh-Cu5RpkLJ.js";
-import { resolveToken } from "./resolve-token-DbQsmn03.js";
+import { authGetSitesV1, configureClient } from "./sdk-client-CTvYVr7D.js";
+import "./env-CdwyPHGV.js";
+import "./token-refresh-DeusLK8H.js";
+import { resolveToken } from "./resolve-token-7xb7kG7h.js";
+import { loadWorkspace } from "./workspace-store-CnrxyYRB.js";
 
 //#region src/commands/workspace/listHandler.ts
 async function listHandler() {

package/dist/{loginHandler-DMjKtKj5.js → loginHandler-DSznhtmk.js}

@@ -1,7 +1,8 @@
-import { CLI_CLIENT_ID, getApiUrl, getAuthUrl, setSessionApiUrl, writeCredentials } from "./env-CHeKHu5S.js";
-import { configureClient } from "./sdk-client-vQsoMCez.js";
-import "./workspace-store-DDOxnut1.js";
-import { autoSelectWorkspace } from "./resolve-workspace--4K7N4VU.js";
+import { configureClient } from "./sdk-client-CTvYVr7D.js";
+import { CLI_CLIENT_ID, getApiUrl, getAuthUrl, setSessionApiUrl, writeCredentials } from "./env-CdwyPHGV.js";
+import "./workspace-store-CnrxyYRB.js";
+import { autoSelectWorkspace } from "./resolve-workspace-B3Gz3-Vh.js";
+import { sleep } from "./sleep-BpJ39Ypm.js";
 import chalk from "chalk";
 import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
@@ -153,12 +154,6 @@ function startCallbackServer(options = {}) {
 	};
 }
 
-//#endregion
-//#region src/utils/sleep.ts
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 //#endregion
 //#region src/auth/device-flow.ts
 /**

package/dist/{logoutHandler-BFutKash.js → logoutHandler-TSQlZGpU.js}

@@ -1,5 +1,5 @@
-import { deleteCredentials, getPatToken } from "./env-CHeKHu5S.js";
-import { clearWorkspace } from "./workspace-store-DDOxnut1.js";
+import { deleteCredentials, getPatToken } from "./env-CdwyPHGV.js";
+import { clearWorkspace } from "./workspace-store-CnrxyYRB.js";
 
 //#region src/commands/auth/logoutHandler.ts
 function logoutHandler() {

package/dist/{pushHandler-C7nxljuh.js → pushHandler-Q9Cbo2HC.js}

@@ -1,11 +1,13 @@
-import { getApiUrl, getAutomationSourceIdOverride, getSourceOverride, getTeamId } from "./env-CHeKHu5S.js";
-import { client, configureClient, uploadImport } from "./sdk-client-vQsoMCez.js";
-import "./workspace-store-DDOxnut1.js";
-import { resolveWorkspace } from "./resolve-workspace--4K7N4VU.js";
-import "./token-refresh-Cu5RpkLJ.js";
-import { resolveToken } from "./resolve-token-DbQsmn03.js";
-import { readFileSync, statSync } from "node:fs";
-import { basename } from "node:path";
+import { client, configureClient, uploadImport } from "./sdk-client-CTvYVr7D.js";
+import { getApiUrl, getAutomationSourceIdOverride, getSourceOverride, getTeamId } from "./env-CdwyPHGV.js";
+import "./token-refresh-DeusLK8H.js";
+import { resolveToken } from "./resolve-token-7xb7kG7h.js";
+import "./workspace-store-CnrxyYRB.js";
+import { resolveWorkspace } from "./resolve-workspace-B3Gz3-Vh.js";
+import "./sleep-BpJ39Ypm.js";
+import { resolveArtifactPath, uploadArtifactFile } from "./artifact-upload-CF2iXUiR.js";
+import { readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
 import { execSync } from "node:child_process";
 import ora from "ora";
 
@@ -356,6 +358,98 @@ function getCiMetadata() {
 	return detectCiEnvironment() ?? void 0;
 }
 
+//#endregion
+//#region src/utils/push-artifacts.ts
+const ARTIFACT_UPLOAD_CONCURRENCY = 4;
+function formatArtifactSummary(s) {
+	return `Artifacts: uploaded ${s.uploaded}, deduplicated ${s.deduplicated}, skipped ${s.skipped} (too large), missing ${s.missing}, rejected ${s.rejected} (outside the working directory), failed ${s.failed}`;
+}
+async function uploadReportArtifacts(options) {
+	const summary = {
+		uploaded: 0,
+		deduplicated: 0,
+		skipped: 0,
+		missing: 0,
+		rejected: 0,
+		failed: 0
+	};
+	const tasks = [];
+	for (const result of options.results) for (const att of result.attachments) {
+		if (att.stored || !att.path) continue;
+		const ref = att.path;
+		const upload = async () => {
+			let resolved = resolveArtifactPath(ref, options.artifactsDir, options.root);
+			if (resolved && resolved.status === "missing") resolved = resolveArtifactPath(ref, options.reportDir, options.root) ?? resolved;
+			if (resolved === null) {
+				summary.rejected += 1;
+				options.onProblem?.(ref, "rejected");
+				return;
+			}
+			if (resolved.status === "missing") {
+				summary.missing += 1;
+				options.onProblem?.(ref, { status: "missing" });
+				return;
+			}
+			const outcome = await uploadArtifactFile({
+				target: {
+					relatedType: "automation_run_result",
+					relatedId: result.id
+				},
+				filePath: resolved.path,
+				validated: resolved,
+				name: att.name ?? void 0,
+				kind: att.kind,
+				attemptIndex: att.attempt_index
+			});
+			switch (outcome.status) {
+				case "uploaded":
+					summary.uploaded += 1;
+					return;
+				case "deduplicated":
+					summary.deduplicated += 1;
+					return;
+				case "skipped":
+					summary.skipped += 1;
+					break;
+				case "missing":
+					summary.missing += 1;
+					break;
+				case "rejected":
+					summary.rejected += 1;
+					break;
+				case "failed":
+					summary.failed += 1;
+					break;
+			}
+			options.onProblem?.(ref, outcome);
+		};
+		tasks.push(async () => {
+			try {
+				await upload();
+			} catch (err) {
+				summary.failed += 1;
+				options.onProblem?.(ref, {
+					status: "failed",
+					message: err instanceof Error ? err.message : String(err)
+				});
+			}
+		});
+	}
+	await runBounded(tasks, options.concurrency ?? ARTIFACT_UPLOAD_CONCURRENCY);
+	return summary;
+}
+/** Run tasks with at most `limit` in flight. Tasks must not throw. */
+async function runBounded(tasks, limit) {
+	let next = 0;
+	const worker = async () => {
+		while (next < tasks.length) {
+			const task = tasks[next++];
+			if (task) await task();
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, tasks.length) }, worker));
+}
+
 //#endregion
 //#region src/commands/pushHandler.ts
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
@@ -425,6 +519,9 @@ async function pushHandler(flags, file) {
 	if (automationSourceId && sourceName && sourceOrigin !== "auto-detected") this.logger.warning(`--automation-source (${automationSourceOrigin}) takes precedence; ignoring source name "${sourceName}" (${sourceOrigin}).`);
 	const uploadTeamId = automationSourceId && !flags["team-id"] ? void 0 : teamId;
 	const ciMeta = getCiMetadata();
+	const outputResults = flags["output-results"];
+	const artifactsDir = flags.artifacts;
+	const includeResults = Boolean(outputResults || artifactsDir);
 	if (flags.verbose) {
 		this.logger.debug(`Team: ${uploadTeamId ?? (automationSourceId ? "(automation source's team)" : "(server default)")}`);
 		this.logger.debug(`File: ${file} (${formatBytes(fileStat.size)})`);
@@ -453,7 +550,8 @@ async function pushHandler(flags, file) {
 			format: flags.format,
 			runName: flags["run-name"],
 			...automationSourceId ? { automationSourceId } : { automationSource: sourceName },
-			importMetadata: ciMeta
+			importMetadata: ciMeta,
+			includeResults
 		});
 		spinner.stop();
 		if (result?.status === "failed") {
@@ -489,6 +587,11 @@ async function pushHandler(flags, file) {
 				const ciLabel = ciMeta.ci_build_id ? `${prettyProvider} #${ciMeta.ci_build_id}` : prettyProvider;
 				this.process.stdout.write(`  CI:       ${ciLabel}\n`);
 			}
+			if (includeResults) await handleResultArtifacts(this, result, {
+				outputResults,
+				artifactsDir,
+				reportFile: file
+			});
 			if (flags.verbose && result.result?.stats) {
 				const s = result.result.stats;
 				this.process.stdout.write("\n  Details:\n");
@@ -506,6 +609,36 @@ async function pushHandler(flags, file) {
 		this.process.exitCode = 1;
 	}
 }
+/**
+* ENG-6164: write the results file and upload the report's artifacts.
+* fail_fallback(warn) throughout — nothing here changes the push exit code
+* (DD5, ENG-591): every problem becomes a warning or a summary count.
+*/
+async function handleResultArtifacts(ctx, result, options) {
+	const results = result.result?.results ?? [];
+	if (options.outputResults) try {
+		writeFileSync(options.outputResults, `${JSON.stringify(results, null, 2)}\n`);
+		ctx.process.stdout.write(`  Results:  ${results.length} written to ${options.outputResults}\n`);
+	} catch (err) {
+		ctx.logger.warning(`Could not write ${options.outputResults}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (options.artifactsDir) try {
+		const summary = await uploadReportArtifacts({
+			results,
+			artifactsDir: resolve(options.artifactsDir),
+			reportDir: dirname(resolve(options.reportFile)),
+			onProblem: (path$1, outcome) => {
+				const why = outcome === "rejected" ? "outside the working directory" : outcome.status === "skipped" ? "larger than 50 MiB" : "message" in outcome ? outcome.message : outcome.status;
+				ctx.logger.debug(`artifact ${path$1}: ${why}`);
+			}
+		});
+		const line = formatArtifactSummary(summary);
+		if (summary.skipped + summary.missing + summary.rejected + summary.failed > 0) ctx.logger.warning(line);
+		else ctx.process.stdout.write(`  ${line}\n`);
+	} catch (err) {
+		ctx.logger.warning(`Artifact upload stopped: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
 
 //#endregion
 export { pushHandler };