@kici-dev/compiler 0.1.16 → 0.1.17

package/dist/commands/run.js

@@ -1,15 +1,13 @@
-import "../chunk-gOLHoazu.js";
+import "../chunk-BTugEXQM.js";
 import { resolveKiciDir } from "../execution/executor.js";
 import "../execution/index.js";
-import { AuthenticationError, ConnectionError, OrchestratorClient } from "../remote/client.js";
 import { loadGlobalConfig } from "../remote/config.js";
 import { RunHistory } from "../remote/history.js";
-import { ObserverClient } from "../remote/observer.js";
+import { AccessDeniedError, AmbiguousClusterError, AuthenticationError, ConnectionError, NoClusterError, PlatformRunClient } from "../remote/platform-client.js";
 import { buildEncryptedSecrets } from "../remote/secret-upload.js";
 import { createOverlayTarball, getSizeWarning, uploadTarball } from "../remote/uploader.js";
 import { formatJsonResult } from "../remote/output/json.js";
 import { formatJunitResult } from "../remote/output/junit.js";
-import { StreamingFormatter } from "../remote/output/streaming.js";
 import { formatErrorHighlight, formatMultiFixtureSummary, formatSummary } from "../remote/output/summary.js";
 import { compileFixtures, filterFixtures } from "../fixtures/compiler.js";
 import path from "node:path";
@@ -17,6 +15,15 @@ import pc from "picocolors";
 import { readFile, writeFile } from "node:fs/promises";
 import { formatBytes, logger, toErrorMessage } from "@kici-dev/core";
 //#region src/commands/run.ts
+/** Terminal run statuses returned by the Platform run-status snapshot. */
+const TERMINAL_STATUSES = new Set([
+	"success",
+	"failed",
+	"cancelled",
+	"error"
+]);
+/** Interval between status/log polls while a run is active. */
+const POLL_INTERVAL_MS = 750;
 /**
 * Run a workflow locally using the local executor.
 * Thin wrapper that delegates to executeLocal from local-executor.
@@ -43,8 +50,7 @@ async function runLocalCommand(options) {
 	}
 }
 /**
-* Run fixtures remotely against the orchestrator.
-* Migrated from test.ts — full remote execution functionality.
+* Run fixtures remotely, routed through the Platform.
 */
 async function runRemoteCommand(fixture, options) {
 	if (options.debug) {
@@ -116,33 +122,59 @@ function describeEvent(event) {
 	return "custom";
 }
 /**
-* Run fixtures remotely against the orchestrator.
+* Resolve the authenticated Platform client and the run target (org + cluster).
+*
+* Org resolution: `--org` → `config.activeOrgId` → error.
+* Cluster resolution: `--orchestrator` → `config.defaultClusters[orgId]` →
+* omit and let the Platform sole-select (or return a 422 the CLI surfaces).
 */
-async function runFixturesRemotely(fixtures, options) {
-	const config = await loadGlobalConfig();
-	if (!config.token) {
-		logger.error(pc.red("Not authenticated. Run `kici login` to set up your API key."));
-		return false;
+function resolvePlatformContext(config, options) {
+	const token = config.pat;
+	if (!token) {
+		logger.error(pc.red("Not authenticated. Run `kici login` to authenticate."));
+		return null;
 	}
-	const endpoint = config.endpoint ?? config.platformEndpoint;
-	if (!endpoint) {
-		logger.error(pc.red("No orchestrator endpoint configured. Run `kici login --endpoint <url>` to set one."));
-		return false;
+	if (!config.platformEndpoint) {
+		logger.error(pc.red("No Platform endpoint configured. Run `kici login` to set up your Platform."));
+		return null;
+	}
+	const orgId = options.org ?? config.activeOrgId;
+	if (!orgId) {
+		logger.error(pc.red("No target organization. Select one with `kici org use <org>` or pass `--org <id>`."));
+		return null;
 	}
+	const orchestrator = options.orchestrator;
+	const defaultCluster = config.defaultClusters?.[orgId];
+	return {
+		client: new PlatformRunClient({
+			platformEndpoint: config.platformEndpoint,
+			token
+		}),
+		orgId,
+		target: {
+			orchestrator,
+			defaultCluster
+		}
+	};
+}
+/**
+* Run fixtures remotely against the Platform.
+*/
+async function runFixturesRemotely(fixtures, options) {
+	const config = await loadGlobalConfig();
+	const ctx = resolvePlatformContext(config, options);
+	if (!ctx) return false;
 	if (options.json) options.quiet = true;
-	const client = new OrchestratorClient({
-		endpoint,
-		token: config.token
-	});
 	const history = new RunHistory();
 	await history.load();
 	if (!options.quiet) {
-		logger.info(pc.gray(`Orchestrator: ${endpoint}`));
+		logger.info(pc.gray(`Platform: ${config.platformEndpoint}`));
+		logger.info(pc.gray(`Organization: ${ctx.orgId}`));
 		logger.info(pc.gray(`Fixtures: ${fixtures.length} to run\n`));
 	}
 	const results = [];
 	if (options.parallel && fixtures.length > 1) {
-		const promises = fixtures.map((f) => runSingleFixture(f, client, options, config, history));
+		const promises = fixtures.map((f) => runSingleFixture(f, ctx, options, config, history));
 		const settled = await Promise.allSettled(promises);
 		for (const s of settled) if (s.status === "fulfilled") results.push(s.value);
 		else results.push({
@@ -152,10 +184,16 @@ async function runFixturesRemotely(fixtures, options) {
 			reason: s.reason instanceof Error ? s.reason.message : String(s.reason)
 		});
 	} else for (const f of fixtures) {
-		const result = await runSingleFixture(f, client, options, config, history);
+		const result = await runSingleFixture(f, ctx, options, config, history);
 		results.push(result);
 		if (result.status === "failed" || result.status === "error") break;
 	}
+	return renderResults(results, options);
+}
+/**
+* Render the aggregated fixture results in the requested format.
+*/
+async function renderResults(results, options) {
 	const runResults = results.filter((r) => r.status === "success" || r.status === "failed" || r.status === "cancelled").map((r) => ({
 		fixtureId: r.fixtureId,
 		runId: r.runId,
@@ -173,44 +211,69 @@ async function runFixturesRemotely(fixtures, options) {
 	return results.every((r) => r.status === "accepted" || r.status === "success");
 }
 /**
-* Run a single fixture remotely.
+* Prepare the overlay tarball + routing metadata for a run.
+*
+* The overlay always carries the full local working tree (the run executes the
+* developer's local code, never a clone). The compiled lock is inlined so the
+* orchestrator can match triggers under the `remote:<orgId>` anchor without a
+* webhook provider to fetch it from a git host.
+*/
+async function prepareOverlay(options) {
+	const kiciDir = resolveKiciDir(options.kiciDir);
+	const repoRoot = path.resolve(kiciDir, "..");
+	if (!options.quiet) logger.info(pc.gray("Creating overlay tarball..."));
+	const { tarballPath, summary, hasRemote } = await createOverlayTarball(repoRoot, { fullWorkingTree: true });
+	if (!options.quiet) logger.info(pc.gray("Running your local working tree (overlay includes .git, so git steps work)"));
+	const inlineLockFile = await readFile(path.join(kiciDir, "kici.lock.json"), "utf-8");
+	if (!options.quiet) {
+		logger.info(pc.gray(`${summary.fileCount} files changed, ${summary.newFiles} new, ${summary.deletedFiles} deleted (${formatBytes(summary.compressedSize)} compressed)`));
+		const sizeWarning = getSizeWarning(summary.compressedSize);
+		if (sizeWarning) logger.info(pc.yellow(sizeWarning));
+	}
+	return {
+		tarballPath,
+		summary,
+		hasRemote,
+		inlineLockFile,
+		kiciDir,
+		repoRoot
+	};
+}
+/**
+* Init the upload (Platform) and PUT the encrypted tarball directly to the
+* object store (data plane). Returns the upload id + the encryption keys.
 */
-async function runSingleFixture(fixture, client, options, config, history) {
+async function initAndUpload(ctx, overlay, options) {
+	if (!options.quiet) logger.info(pc.gray("Initializing upload..."));
+	const upload = await ctx.client.initUpload(ctx.orgId, ctx.target, {
+		sha: overlay.summary.sha,
+		fileCount: overlay.summary.fileCount,
+		compressedSize: overlay.summary.compressedSize
+	});
+	if (!options.quiet) logger.info(pc.gray("Uploading overlay..."));
+	const uploadResult = await uploadTarball({
+		tarballPath: overlay.tarballPath,
+		signedUrl: upload.signedUrl,
+		orchestratorPublicKey: Buffer.from(upload.publicKey, "base64")
+	});
+	return {
+		uploadId: upload.uploadId,
+		publicKey: upload.publicKey,
+		cliPublicKey: uploadResult.cliPublicKey.toString("base64")
+	};
+}
+/**
+* Run a single fixture remotely through the Platform.
+*/
+async function runSingleFixture(fixture, ctx, options, config, history) {
 	const opts = typeof fixture.fixture.options === "function" ? await fixture.fixture.options() : fixture.fixture.options;
 	if (!options.quiet) logger.info(pc.cyan(`\n--- ${fixture.id} ---`));
 	try {
-		const kiciDir = resolveKiciDir(options.kiciDir);
-		const repoRoot = path.resolve(kiciDir, "..");
-		if (!options.quiet) logger.info(pc.gray("Creating overlay tarball..."));
-		const { tarballPath, summary, hasRemote } = await createOverlayTarball(repoRoot);
-		let routingKey = options.routingKey ?? config.routingKey ?? "default";
-		if (!hasRemote) {
-			routingKey = `local:${path.basename(repoRoot)}`;
-			if (!options.quiet) logger.warn("No remote detected -- steps that use git commands will fail (no .git directory)");
-		}
-		let inlineLockFile;
-		if (!hasRemote) inlineLockFile = await readFile(path.join(kiciDir, "kici.lock.json"), "utf-8");
-		if (!options.quiet) {
-			logger.info(pc.gray(`${summary.fileCount} files changed, ${summary.newFiles} new, ${summary.deletedFiles} deleted (${formatBytes(summary.compressedSize)} compressed)`));
-			const sizeWarning = getSizeWarning(summary.compressedSize);
-			if (sizeWarning) logger.info(pc.yellow(sizeWarning));
-		}
-		if (!options.quiet) logger.info(pc.gray("Initializing upload..."));
-		const upload = await client.initUpload({
-			routingKey,
-			sha: summary.sha,
-			fileCount: summary.fileCount,
-			compressedSize: summary.compressedSize
-		});
-		if (!options.quiet) logger.info(pc.gray("Uploading overlay..."));
-		const uploadResult = await uploadTarball({
-			tarballPath,
-			signedUrl: upload.signedUrl,
-			orchestratorPublicKey: Buffer.from(upload.publicKey, "base64")
-		});
+		const overlay = await prepareOverlay(options);
+		const uploaded = await initAndUpload(ctx, overlay, options);
 		const event = buildEventFromFixture(opts);
-		if (!hasRemote) {
-			const repoName = path.basename(repoRoot);
+		{
+			const repoName = path.basename(overlay.repoRoot);
 			const repo = event.payload.repository;
 			event.payload.repository = {
 				...repo ?? {},
@@ -218,21 +281,20 @@ async function runSingleFixture(fixture, client, options, config, history) {
 			};
 		}
 		if (!options.quiet) logger.info(pc.gray("Triggering test run..."));
-		const encrypted = await buildEncryptedSecrets(kiciDir, options.envFlags, options.context, upload.publicKey);
-		const triggerResult = await client.triggerTest({
+		const encrypted = await buildEncryptedSecrets(overlay.kiciDir, options.envFlags, options.context, uploaded.publicKey);
+		const triggerResult = await ctx.client.trigger(ctx.orgId, ctx.target, {
 			fixtureId: fixture.id,
 			event,
-			routingKey,
-			uploadId: upload.uploadId,
-			cliPublicKey: uploadResult.cliPublicKey.toString("base64"),
+			uploadId: uploaded.uploadId,
+			cliPublicKey: uploaded.cliPublicKey,
 			secrets: opts.secrets,
 			...encrypted && {
 				encryptedSecrets: encrypted.encryptedSecrets,
 				encryptedSecretsKey: encrypted.cliPublicKey
 			},
 			workflowName: opts.workflowName,
-			inlineLockFile,
-			fullRepo: !hasRemote || void 0
+			inlineLockFile: overlay.inlineLockFile,
+			fullRepo: true
 		});
 		if (triggerResult.status === "rejected") {
 			if (!options.quiet) logger.info(pc.red(`Rejected: ${triggerResult.reason ?? "unknown reason"}`));
@@ -240,29 +302,23 @@ async function runSingleFixture(fixture, client, options, config, history) {
 				fixtureId: fixture.id,
 				runId: triggerResult.runId,
 				status: "rejected",
-				reason: triggerResult.reason,
-				observeUrl: triggerResult.observeUrl
+				reason: triggerResult.reason
 			};
 		}
-		if (!options.quiet) {
-			logger.info(pc.green(`Run started: ${triggerResult.runId}`));
-			logger.info(pc.gray(`Observe: ${triggerResult.observeUrl}`));
-		}
-		const historyEndpoint = config.endpoint ?? config.platformEndpoint ?? "";
+		if (!options.quiet) logger.info(pc.green(`Run started: ${triggerResult.runId}`));
 		await history.addEntry({
 			runId: triggerResult.runId,
 			fixtureId: fixture.id,
 			status: "running",
 			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			endpoint: historyEndpoint
+			endpoint: config.platformEndpoint ?? ""
 		});
 		if (options.wait === false) return {
 			fixtureId: fixture.id,
 			runId: triggerResult.runId,
-			status: "accepted",
-			observeUrl: triggerResult.observeUrl
+			status: "accepted"
 		};
-		const result = await observeCompletion(fixture.id, triggerResult.runId, triggerResult.observeUrl, config.token, client, options);
+		const result = await pollRunToCompletion(ctx, triggerResult.runId, fixture.id, options);
 		await history.updateEntry(triggerResult.runId, {
 			status: result.status,
 			completedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -271,283 +327,168 @@ async function runSingleFixture(fixture, client, options, config, history) {
 		});
 		return result;
 	} catch (error) {
-		if (error instanceof AuthenticationError) logger.error(pc.red("Authentication failed. Run `kici login` to re-authenticate."));
-		else if (error instanceof ConnectionError) logger.error(pc.red(`Connection failed: ${error.message}`));
-		return {
-			fixtureId: fixture.id,
-			runId: "",
-			status: "error",
-			reason: toErrorMessage(error)
-		};
+		return handleRunError(fixture.id, error, options);
 	}
 }
-/**
-* Build a SimulatedEvent-compatible object from fixture options.
-*/
-function buildEventFromFixture(opts) {
-	const eventObj = opts.event;
-	const type = String(eventObj._type ?? "push");
-	const action = eventObj.action ? String(eventObj.action) : void 0;
-	const targetBranch = opts.branch ?? "main";
+/** Map a run-path error to a CLI message + a result. */
+function handleRunError(fixtureId, error, options) {
+	if (error instanceof AmbiguousClusterError) {
+		logger.error(pc.red(`Multiple orchestrators are connected. Pass --orchestrator <name>, one of: ${error.clusters.join(", ")}`));
+		logger.error(pc.gray("Or set a default with `kici orchestrators use <name>`."));
+	} else if (error instanceof NoClusterError) logger.error(pc.red("No orchestrator is connected for this organization."));
+	else if (error instanceof AuthenticationError) logger.error(pc.red("Authentication failed. Run `kici login` to re-authenticate."));
+	else if (error instanceof AccessDeniedError) logger.error(pc.red(`Access denied: ${error.message}`));
+	else if (error instanceof ConnectionError) logger.error(pc.red(`Connection failed: ${error.message}`));
+	else if (options.debug && error instanceof Error && error.stack) logger.error(pc.gray(error.stack));
 	return {
-		type,
-		action,
-		targetBranch,
-		sourceBranch: type === "pr" ? opts.branch ?? "feature/test" : void 0,
-		payload: {
-			ref: `refs/heads/${targetBranch}`,
-			repository: { full_name: opts.repo ?? "owner/repo" },
-			...opts.sha && { after: opts.sha },
-			...opts.pr && { number: opts.pr }
-		}
+		fixtureId,
+		runId: "",
+		status: "error",
+		reason: toErrorMessage(error)
 	};
 }
 /**
-* Observe run completion via WebSocket (primary path).
-* Falls back to HTTP polling if the WS connection fails.
+* Poll the Platform for run completion, streaming log lines as they arrive.
+*
+* Advances a monotonic line-offset cursor (spec §13a): each `runLogs(cursor)`
+* returns the next chunk + `nextCursor`; the run is done only when the status
+* is terminal and the log stream has drained.
 */
-async function observeCompletion(fixtureId, runId, observeUrl, token, client, options) {
-	const formatter = new StreamingFormatter();
-	formatter.isQuiet = options.quiet ?? false;
-	const lastLinesByJob = /* @__PURE__ */ new Map();
-	const MAX_ERROR_LINES = 50;
-	let completionResult = null;
-	let fallbackToPolling = false;
-	const observer = new ObserverClient({
-		observeUrl,
-		token,
-		runId,
-		onLog: (msg) => {
-			for (const line of msg.lines) {
-				const output = formatter.formatLogLine(msg.jobName, msg.stepName, line);
-				if (output) process.stdout.write(output);
-			}
-			if (!lastLinesByJob.has(msg.jobName)) lastLinesByJob.set(msg.jobName, []);
-			const buffer = lastLinesByJob.get(msg.jobName);
-			buffer.push(...msg.lines);
-			while (buffer.length > MAX_ERROR_LINES) buffer.shift();
-		},
-		onStep: (msg) => {
-			const output = formatter.formatStepChange(msg.jobName, msg.stepName, msg.state, msg.durationMs);
-			if (output) process.stdout.write(output);
-		},
-		onStatus: (msg) => {
-			const output = formatter.formatStatusChange(msg.status, msg.jobName);
-			if (output) process.stdout.write(output);
-		},
-		onComplete: (msg) => {
-			completionResult = msg;
-		},
-		onError: (err) => {
-			if (options.debug) logger.error(pc.gray(`Observer error: ${err.message}`));
-			fallbackToPolling = true;
-		}
-	});
+async function pollRunToCompletion(ctx, runId, fixtureId, options) {
+	const startTime = Date.now();
+	let cursor = 0;
+	const tailLines = [];
+	const MAX_TAIL = 50;
 	let cancelled = false;
 	const cancelHandler = async () => {
 		if (cancelled) return;
 		cancelled = true;
 		if (!options.quiet) logger.info(pc.yellow("\nCancelling test run..."));
-		observer.disconnect();
 		try {
-			const cancelResult = await client.cancelTest(runId);
-			if (!options.quiet) logger.info(pc.gray(`Cancel status: ${cancelResult.status}`));
+			await ctx.client.cancel(ctx.orgId, runId, ctx.target);
 		} catch {}
 	};
 	process.on("SIGINT", cancelHandler);
 	try {
-		try {
-			await observer.connect();
-		} catch {
-			if (options.debug) logger.info(pc.gray("WebSocket connection failed, falling back to HTTP polling"));
-			process.removeListener("SIGINT", cancelHandler);
-			return await pollForCompletionFallback(fixtureId, runId, observeUrl, client, options);
-		}
-		formatter.startElapsedTimer();
-		let complete;
-		try {
-			complete = await observer.waitForCompletion();
-		} catch {
-			if (cancelled) return {
-				fixtureId,
-				runId,
-				status: "cancelled",
-				observeUrl
-			};
-			observer.disconnect();
-			process.removeListener("SIGINT", cancelHandler);
-			if (options.debug) logger.info(pc.gray("Observer disconnected, falling back to HTTP polling"));
-			return await pollForCompletionFallback(fixtureId, runId, observeUrl, client, options);
-		}
-		completionResult = complete;
-		formatter.stopElapsedTimer();
-		if (fallbackToPolling && !completionResult) {
-			observer.disconnect();
-			process.removeListener("SIGINT", cancelHandler);
-			if (options.debug) logger.info(pc.gray("Observer errored, falling back to HTTP polling"));
-			return await pollForCompletionFallback(fixtureId, runId, observeUrl, client, options);
-		}
-		const runResult = {
-			fixtureId,
-			runId,
-			status: complete.status,
-			totalDurationMs: complete.summary.totalDurationMs,
-			jobs: complete.summary.jobs
-		};
-		if (!options.quiet) process.stdout.write("\n" + formatSummary(runResult) + "\n");
-		if (complete.status === "failed") {
-			for (const job of complete.summary.jobs) if (job.status === "failed") {
-				const lines = lastLinesByJob.get(job.name);
-				if (lines && lines.length > 0 && !options.quiet) process.stdout.write("\n" + formatErrorHighlight(job.name, lines) + "\n");
+		let lastStatus = null;
+		while (!cancelled) {
+			const logs = await ctx.client.runLogs(ctx.orgId, runId, cursor, ctx.target);
+			for (const line of logs.lines) {
+				if (!options.quiet) process.stdout.write(line + "\n");
+				tailLines.push(line);
+				while (tailLines.length > MAX_TAIL) tailLines.shift();
 			}
+			cursor = logs.nextCursor;
+			lastStatus = await ctx.client.runStatus(ctx.orgId, runId, ctx.target);
+			if ((lastStatus.done || TERMINAL_STATUSES.has(lastStatus.status)) && logs.done) return finishRun(fixtureId, runId, lastStatus, startTime, tailLines, options);
+			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
 		}
-		observer.disconnect();
 		return {
 			fixtureId,
 			runId,
-			status: complete.status,
-			observeUrl,
-			durationMs: complete.summary.totalDurationMs,
-			jobs: complete.summary.jobs
+			status: "cancelled",
+			durationMs: Date.now() - startTime,
+			jobs: jobsFromStatus(lastStatus)
 		};
 	} finally {
-		formatter.stopElapsedTimer();
 		process.removeListener("SIGINT", cancelHandler);
 	}
 }
-/**
-* Poll orchestrator for run completion (HTTP fallback when WebSocket fails).
-*/
-async function pollForCompletionFallback(fixtureId, runId, observeUrl, client, options) {
-	const POLL_INTERVAL_MS = 2e3;
-	const MAX_POLL_DURATION_MS = 1800 * 1e3;
-	const startTime = Date.now();
-	let cancelled = false;
-	const cancelHandler = async () => {
-		if (cancelled) return;
-		cancelled = true;
-		if (!options.quiet) logger.info(pc.yellow("\nCancelling test run..."));
-		try {
-			const cancelResult = await client.cancelTest(runId);
-			if (!options.quiet) logger.info(pc.gray(`Cancel status: ${cancelResult.status}`));
-		} catch {}
-	};
-	process.on("SIGINT", cancelHandler);
-	try {
-		while (!cancelled) {
-			if (Date.now() - startTime > MAX_POLL_DURATION_MS) return {
-				fixtureId,
-				runId,
-				status: "error",
-				reason: "Polling timeout exceeded (30 minutes)",
-				observeUrl
-			};
-			try {
-				const status = await client.getRunStatus(runId);
-				if (status.status === "success" || status.status === "failed" || status.status === "cancelled") {
-					const durationMs = Date.now() - startTime;
-					if (!options.quiet) {
-						const statusColor = status.status === "success" ? pc.green : pc.red;
-						logger.info(statusColor(`\nRun ${status.status} (${(durationMs / 1e3).toFixed(1)}s)`));
-						if (status.summary?.jobs) for (const job of status.summary.jobs) {
-							const jobColor = job.status === "success" ? pc.green : pc.red;
-							const duration = job.durationMs ? ` (${(job.durationMs / 1e3).toFixed(1)}s)` : "";
-							logger.info(`  ${jobColor(job.status.padEnd(10))} ${job.name}${duration}`);
-						}
-					}
-					return {
-						fixtureId,
-						runId,
-						status: status.status,
-						observeUrl,
-						durationMs: Date.now() - startTime,
-						jobs: status.summary?.jobs
-					};
-				}
-			} catch {}
-			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-		}
-		return {
+/** Build the final result + render the summary table for a completed run. */
+function finishRun(fixtureId, runId, status, startTime, tailLines, options) {
+	const durationMs = Date.now() - startTime;
+	const jobs = jobsFromStatus(status);
+	const finalStatus = status.status;
+	if (!options.quiet) {
+		const runResult = {
 			fixtureId,
 			runId,
-			status: "cancelled",
-			observeUrl,
-			durationMs: Date.now() - startTime
+			status: finalStatus === "failed" ? "failed" : finalStatus === "cancelled" ? "cancelled" : "success",
+			totalDurationMs: durationMs,
+			jobs
 		};
-	} finally {
-		process.removeListener("SIGINT", cancelHandler);
+		process.stdout.write("\n" + formatSummary(runResult) + "\n");
+		if (finalStatus === "failed" && tailLines.length > 0) {
+			const failedJob = status.jobs.find((j) => j.status === "failed");
+			process.stdout.write("\n" + formatErrorHighlight(failedJob?.jobName ?? "run", tailLines) + "\n");
+		}
 	}
+	return {
+		fixtureId,
+		runId,
+		status: finalStatus,
+		durationMs,
+		jobs
+	};
+}
+/** Map a Platform run-status snapshot to the CLI's job summary shape. */
+function jobsFromStatus(status) {
+	if (!status) return [];
+	return status.jobs.map((j) => ({
+		name: j.jobName,
+		status: j.status
+	}));
 }
 /**
-* Run a specific workflow directly (bypass trigger matching).
+* Build a SimulatedEvent-compatible object from fixture options.
+*/
+function buildEventFromFixture(opts) {
+	const eventObj = opts.event;
+	const type = String(eventObj._type ?? "push");
+	const action = eventObj.action ? String(eventObj.action) : void 0;
+	const targetBranch = opts.branch ?? "main";
+	return {
+		type,
+		action,
+		targetBranch,
+		sourceBranch: type === "pr" ? opts.branch ?? "feature/test" : void 0,
+		payload: {
+			ref: `refs/heads/${targetBranch}`,
+			repository: { full_name: opts.repo ?? "owner/repo" },
+			...opts.sha && { after: opts.sha },
+			...opts.pr && { number: opts.pr }
+		}
+	};
+}
+/**
+* Run a specific workflow directly (bypass trigger matching), through the
+* Platform.
 */
 async function runDirectWorkflow(workflowName, options) {
-	const config = await loadGlobalConfig();
-	if (!config.token) {
-		logger.error(pc.red("Not authenticated. Run `kici login` to set up your API key."));
-		return false;
-	}
-	const endpoint = config.endpoint ?? config.platformEndpoint;
-	if (!endpoint) {
-		logger.error(pc.red("No orchestrator endpoint configured. Run `kici login --endpoint <url>` to set one."));
-		return false;
-	}
-	const client = new OrchestratorClient({
-		endpoint,
-		token: config.token
-	});
+	const ctx = resolvePlatformContext(await loadGlobalConfig(), options);
+	if (!ctx) return false;
+	if (options.json) options.quiet = true;
 	if (!options.quiet) logger.info(pc.gray(`Running workflow "${workflowName}" directly (bypassing triggers)`));
-	const kiciDir = resolveKiciDir(options.kiciDir);
-	const repoRoot = path.resolve(kiciDir, "..");
-	const { tarballPath, summary, hasRemote } = await createOverlayTarball(repoRoot);
-	let routingKey = options.routingKey ?? config.routingKey ?? "default";
-	if (!hasRemote) {
-		routingKey = `local:${path.basename(repoRoot)}`;
-		logger.warn("No remote detected -- steps that use git commands will fail (no .git directory)");
-	}
-	let inlineLockFile;
-	if (!hasRemote) inlineLockFile = await readFile(path.join(kiciDir, "kici.lock.json"), "utf-8");
-	if (!options.quiet) logger.info(pc.gray(`${summary.fileCount} files changed, ${summary.newFiles} new, ${summary.deletedFiles} deleted (${formatBytes(summary.compressedSize)} compressed)`));
-	const upload = await client.initUpload({
-		routingKey,
-		sha: summary.sha,
-		fileCount: summary.fileCount,
-		compressedSize: summary.compressedSize
-	});
-	const directUploadResult = await uploadTarball({
-		tarballPath,
-		signedUrl: upload.signedUrl,
-		orchestratorPublicKey: Buffer.from(upload.publicKey, "base64")
-	});
-	const repoName = !hasRemote ? path.basename(repoRoot) : void 0;
-	const payload = {};
-	if (!hasRemote) payload.repository = { full_name: `local/${repoName}` };
-	const encrypted = await buildEncryptedSecrets(kiciDir, options.envFlags, options.context, upload.publicKey);
-	const result = await client.triggerTest({
-		fixtureId: `direct:${workflowName}`,
-		event: {
-			type: "manual",
-			targetBranch: "main",
-			payload
-		},
-		routingKey,
-		uploadId: upload.uploadId,
-		cliPublicKey: directUploadResult.cliPublicKey.toString("base64"),
-		...encrypted && {
-			encryptedSecrets: encrypted.encryptedSecrets,
-			encryptedSecretsKey: encrypted.cliPublicKey
-		},
-		workflowName,
-		inlineLockFile,
-		fullRepo: !hasRemote || void 0
-	});
-	if (!options.quiet) {
-		logger.info(pc.green(`Run started: ${result.runId}`));
-		logger.info(pc.gray(`Observe: ${result.observeUrl}`));
+	await new RunHistory().load();
+	const fixtureId = `direct:${workflowName}`;
+	try {
+		const overlay = await prepareOverlay(options);
+		const uploaded = await initAndUpload(ctx, overlay, options);
+		const payload = { repository: { full_name: `local/${path.basename(overlay.repoRoot)}` } };
+		const encrypted = await buildEncryptedSecrets(overlay.kiciDir, options.envFlags, options.context, uploaded.publicKey);
+		const triggerResult = await ctx.client.trigger(ctx.orgId, ctx.target, {
+			fixtureId,
+			event: {
+				type: "manual",
+				targetBranch: "main",
+				payload
+			},
+			uploadId: uploaded.uploadId,
+			cliPublicKey: uploaded.cliPublicKey,
+			...encrypted && {
+				encryptedSecrets: encrypted.encryptedSecrets,
+				encryptedSecretsKey: encrypted.cliPublicKey
+			},
+			workflowName,
+			inlineLockFile: overlay.inlineLockFile,
+			fullRepo: true
+		});
+		if (!options.quiet) logger.info(pc.green(`Run started: ${triggerResult.runId}`));
+		if (options.wait === false) return triggerResult.status === "accepted";
+		return (await pollRunToCompletion(ctx, triggerResult.runId, fixtureId, options)).status === "success";
+	} catch (error) {
+		return handleRunError(fixtureId, error, options).status === "success";
 	}
-	if (options.wait === false) return result.status === "accepted";
-	const observeResult = await observeCompletion(`direct:${workflowName}`, result.runId, result.observeUrl, config.token, client, options);
-	return observeResult.status === "success" || observeResult.status === "accepted";
 }
 /**
 * Display remote run results as a summary table.
@@ -568,6 +509,6 @@ function displayRemoteResults(results) {
 	logger.info("");
 }
 //#endregion
-export { observeCompletion, runLocalCommand, runRemoteCommand };
+export { runLocalCommand, runRemoteCommand };
 
 //# sourceMappingURL=run.js.map