@kici-dev/agent 0.1.22 → 0.1.24

package/dist/server.js

@@ -25,7 +25,7 @@ import { format, promisify } from "node:util";
 import { gcStaleTmpDirs } from "@kici-dev/core/tmp-gc";
 import fs$1, { access, lstat, mkdir, mkdtemp, readFile, readdir, realpath, rm, unlink, writeFile } from "node:fs/promises";
 import Docker from "dockerode";
-import { buildKiciApi, buildNeedsContext, isDynamicGroupRef, isDynamicJobFn, isStaticArray, isStaticObject } from "@kici-dev/sdk";
+import { buildKiciApi, buildNeedsContext, isDynamicGroupRef, isDynamicJobFn, isParallelGroup, isStaticArray, isStaticObject } from "@kici-dev/sdk";
 import { c, x } from "tar";
 import https from "node:https";
 import http from "node:http";
@@ -1310,14 +1310,14 @@ var init_console_capture = __esmMin((() => {
 init_console_capture();
 function safe(name, fallback = "unknown") {
 	switch (name) {
-		case "version": return "0.1.22";
-		case "buildCommit": return "5afd16303";
-		case "sdkVersion": return "0.1.22";
-		case "sdkBundleHash": return "4b26a42978f77e29db110d47523ec947d3d673c3109fc48141c1a62814bde7a1";
-		case "sharedVersion": return "0.1.22";
-		case "sharedBundleHash": return "991385c024392c395d3eb8a68946ef8ed3fcba96f2652f21c3164a54eafa1b1b";
-		case "engineVersion": return "0.1.22";
-		case "engineBundleHash": return "ff74a3afb2b1db2870c03d47543642f64d04b660bebdcde6681f76d874f26757";
+		case "version": return "0.1.24";
+		case "buildCommit": return "73592f67f";
+		case "sdkVersion": return "0.1.24";
+		case "sdkBundleHash": return "031712cf8cd02f483365113aad7e946da982110d544b177eb05edcc0d4421253";
+		case "sharedVersion": return "0.1.24";
+		case "sharedBundleHash": return "b977224129c767c4851458a795fa470264b2fc51255baf06cf14640e29e2f44c";
+		case "engineVersion": return "0.1.24";
+		case "engineBundleHash": return "734acca885cd70eed07a1a9426b08c04c07a9bf99484c18100d3d797b3eb8f39";
 		default: return fallback;
 	}
 }
@@ -2080,8 +2080,8 @@ async function extractStepsFromDynamicJob(workflow, dynamicIndex, jobName, event
 }
 var AGENT_SDK_VERSION, AGENT_SDK_BUNDLE_HASH, hookRegistered;
 var init_workflow_loader = __esmMin((() => {
-	AGENT_SDK_VERSION = "0.1.22";
-	AGENT_SDK_BUNDLE_HASH = "4b26a42978f77e29db110d47523ec947d3d673c3109fc48141c1a62814bde7a1";
+	AGENT_SDK_VERSION = "0.1.24";
+	AGENT_SDK_BUNDLE_HASH = "031712cf8cd02f483365113aad7e946da982110d544b177eb05edcc0d4421253";
 	hookRegistered = false;
 }));
 //#endregion
@@ -2548,9 +2548,16 @@ async function evaluateDynamicFields(workflow, jobName, event, flags, timeoutMs
 		if (job.include || job.exclude) combos = applyIncludeExclude(combos, job.include, job.exclude);
 		result.matrixValues = combos;
 	}
-	if (flags.dynamicEnvironment && typeof job.environment === "function") {
-		const value = await withTimeout(() => job.environment(event), timeoutMs, `dynamicEnvironment for job '${jobName}'`);
-		if (value !== void 0 && value !== null) result.environmentName = value;
+	if (flags.dynamicEnvironment) {
+		const envRefs = job.environments ?? (job.environment !== void 0 ? [job.environment] : void 0);
+		if (envRefs && envRefs.length > 0) {
+			const names = [];
+			for (const ref of envRefs) if (typeof ref === "function") {
+				const value = await withTimeout(() => ref(event), timeoutMs, `dynamicEnvironment for job '${jobName}'`);
+				if (value !== void 0 && value !== null) names.push(value);
+			} else if (typeof ref === "string") names.push(ref);
+			if (names.length > 0) result.environmentNames = names;
+		}
 	}
 	if (flags.dynamicEnv && typeof job.env === "function") {
 		const value = await withTimeout(() => job.env(event), timeoutMs, `dynamicEnv for job '${jobName}'`);
@@ -2566,6 +2573,274 @@ var init_init_runner = __esmMin((() => {
 	init_timeout_util();
 }));
 //#endregion
+//#region src/bootstrap/ssh-exec.ts
+/**
+* Agent-side SSH helper for bootstrap bring-up.
+*
+* Lifts the discipline from `infra/prod/hw/ssh.sh` + the deploy-prod
+* `runOnBox` helper into the agent: the bring-up private key is piped into an
+* **ephemeral ssh-agent** (`ssh-add -` reads it from stdin) and the agent is
+* torn down in a `finally`, so the key never lands on disk and never enters a
+* long-lived process environment. The agent only holds the key for the
+* lifetime of the one `ssh` / `scp` invocation.
+*
+* `sshExec` runs a remote command; `sshPush` ships local bytes to a remote
+* path (`ssh 'cat > path'`). Both accept a resolved private key string
+* (supplied by the caller — the orchestrator resolves the scoped secret and
+* hands the key down). `sshExec` supports `{ stdin, port, hostKeyMode }` so it
+* can also drive a pre-boot dropbear / initramfs prompt (a forced-command
+* endpoint such as `cryptroot-unlock` on port 2222, which accepts the unlock
+* input on stdin and uses a transient host key distinct from the OS sshd key).
+*/
+/** Common `-o` flags every bootstrap SSH connection carries. */
+function baseSshOptions(hostKeyMode) {
+	return [
+		"-o",
+		`StrictHostKeyChecking=${HOST_KEY_FLAG[hostKeyMode]}`,
+		"-o",
+		"ConnectTimeout=10",
+		"-o",
+		"BatchMode=yes"
+	];
+}
+/** Resolve the `user@address` target + port from reach metadata. */
+function resolveTarget(reach, portOverride) {
+	if (!reach.address) throw new Error(`host ${reach.agentId} has no SSH reach address declared`);
+	const user = reach.sshUser ?? SSH_USER_DEFAULT;
+	const port = portOverride ?? reach.sshPort ?? SSH_PORT_DEFAULT;
+	return {
+		dest: `${user}@${reach.address}`,
+		port
+	};
+}
+/**
+* Run a command on the target over SSH using an ephemeral, in-memory key.
+*
+* The key is loaded into a per-call ssh-agent (never written to disk) and the
+* agent is killed in `finally`. The remote command's exit code / stdout /
+* stderr are returned verbatim — a non-zero exit is reported, not swallowed
+* (a pre-boot unlock legitimately drops the session, so the caller decides
+* what a "success" looks like).
+*/
+async function sshExec(reach, privateKey, command, opts = {}, deps = {}) {
+	const spawnFn = deps.spawnFn ?? defaultSpawn;
+	const hostKeyMode = opts.hostKeyMode ?? "accept-new";
+	const { dest, port } = resolveTarget(reach, opts.port);
+	return withEphemeralAgent(privateKey, spawnFn, async (env) => {
+		return spawnFn("ssh", [
+			...baseSshOptions(hostKeyMode),
+			"-p",
+			String(port),
+			dest,
+			command
+		], {
+			env,
+			stdin: opts.stdin
+		});
+	});
+}
+/**
+* Ship local bytes to a remote path over SSH (`ssh 'cat > path'`), using the
+* same ephemeral-key discipline. Throws on a non-zero exit (a push must
+* succeed end-to-end, unlike a pre-boot unlock).
+*/
+async function sshPush(reach, privateKey, localBytes, remotePath, opts = {}, deps = {}) {
+	const spawnFn = deps.spawnFn ?? defaultSpawn;
+	const hostKeyMode = opts.hostKeyMode ?? "accept-new";
+	const { dest, port } = resolveTarget(reach, opts.port);
+	const result = await withEphemeralAgent(privateKey, spawnFn, async (env) => {
+		return spawnFn("ssh", [
+			...baseSshOptions(hostKeyMode),
+			"-p",
+			String(port),
+			dest,
+			`cat > '${remotePath.replace(/'/g, `'\\''`)}'`
+		], {
+			env,
+			stdin: localBytes
+		});
+	});
+	if (result.exitCode !== 0) throw new Error(`sshPush(${reach.agentId}:${remotePath}): exit ${result.exitCode}${result.stderr ? `\n${result.stderr}` : ""}`);
+}
+/**
+* Start a per-call ephemeral ssh-agent, load the key via stdin (never a file),
+* run `body` with `SSH_AUTH_SOCK` in env, and kill the agent in `finally`.
+*/
+async function withEphemeralAgent(privateKey, spawnFn, body) {
+	const baseEnv = { ...process.env };
+	const start = await spawnFn("ssh-agent", ["-s"], { env: baseEnv });
+	if (start.exitCode !== 0) throw new Error(`ssh-agent start failed: exit ${start.exitCode}\n${start.stderr}`);
+	const sock = parseAgentSocket(start.stdout);
+	const pid = parseAgentPid(start.stdout);
+	const agentEnv = {
+		...baseEnv,
+		SSH_AUTH_SOCK: sock,
+		...pid ? { SSH_AGENT_PID: pid } : {},
+		SSH_ASKPASS: "/bin/false",
+		DISPLAY: ""
+	};
+	try {
+		const add = await spawnFn("ssh-add", ["-"], {
+			env: agentEnv,
+			stdin: privateKey.endsWith("\n") ? privateKey : `${privateKey}\n`
+		});
+		if (add.exitCode !== 0) throw new Error(`ssh-add failed: exit ${add.exitCode}\n${add.stderr}`);
+		return await body(agentEnv);
+	} finally {
+		await spawnFn("ssh-agent", ["-k"], { env: agentEnv }).catch(() => {});
+	}
+}
+/** Extract `SSH_AUTH_SOCK=<path>;` from `ssh-agent -s` output. */
+function parseAgentSocket(out) {
+	const m = out.match(/SSH_AUTH_SOCK=([^;\n]+)/);
+	if (!m) throw new Error("ssh-agent -s did not emit SSH_AUTH_SOCK");
+	return m[1];
+}
+/** Extract `SSH_AGENT_PID=<n>;` from `ssh-agent -s` output (best-effort). */
+function parseAgentPid(out) {
+	return out.match(/SSH_AGENT_PID=([^;\n]+)/)?.[1];
+}
+var defaultSpawn, SSH_USER_DEFAULT, SSH_PORT_DEFAULT, HOST_KEY_FLAG;
+var init_ssh_exec = __esmMin((() => {
+	defaultSpawn = (command, args, opts) => new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			env: opts.env,
+			stdio: [
+				opts.stdin !== void 0 ? "pipe" : "ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.on("data", (b) => {
+			stdout += b.toString();
+		});
+		child.stderr?.on("data", (b) => {
+			stderr += b.toString();
+		});
+		child.on("error", reject);
+		child.on("close", (code) => resolve({
+			exitCode: code ?? -1,
+			stdout,
+			stderr
+		}));
+		if (opts.stdin !== void 0) child.stdin?.end(opts.stdin);
+	});
+	SSH_USER_DEFAULT = "root";
+	SSH_PORT_DEFAULT = 22;
+	HOST_KEY_FLAG = {
+		"accept-new": "accept-new",
+		strict: "yes"
+	};
+}));
+//#endregion
+//#region src/bootstrap/ensure-init-runner.ts
+/**
+* Build the launcher script that starts the init-runner on the target with its
+* bootstrap env. Detached (`setsid … &`) so the SSH session can return while
+* the agent keeps running and dials the orchestrator.
+*/
+function buildLauncher(material, agentCommand) {
+	return [
+		"#!/usr/bin/env bash",
+		"set -euo pipefail",
+		`setsid env ${[
+			`KICI_AGENT_TOKEN=${shQuote(material.bootstrapToken)}`,
+			`KICI_AGENT_ID=${shQuote(material.targetAgentId)}`,
+			`KICI_ORCHESTRATOR_URL=${shQuote(material.orchestratorUrl)}`,
+			`KICI_LABELS=${shQuote(material.labels.join(","))}`,
+			"KICI_EXECUTION_MODE=bare-metal",
+			"KICI_PORT=0"
+		].join(" \\\n  ")} \\`,
+		`  ${agentCommand} >/tmp/kici-init-runner.log 2>&1 &`,
+		"echo \"init-runner started pid=$!\""
+	].join("\n");
+}
+/** Single-quote a value for safe embedding in the launcher's env assignment. */
+function shQuote(v) {
+	return `'${v.replace(/'/g, `'\\''`)}'`;
+}
+/**
+* Bring up a temporary init-runner on `targetAgentId`. Returns `{ broughtUp }`:
+* false when the target already had a live agent (the orchestrator no-op'd),
+* true when this call dropped + started the init-runner.
+*/
+async function ensureInitRunner(transport, targetAgentId, deps = {}) {
+	const material = await transport("kici.ensureInitRunner", { targetAgentId });
+	if (!material.broughtUp) return { broughtUp: false };
+	const { reach, privateKey, bootstrapToken, orchestratorUrl, labels } = material;
+	if (!reach || !privateKey || !bootstrapToken || !orchestratorUrl || !labels) throw new Error(`orchestrator returned incomplete bring-up material for ${targetAgentId}`);
+	const agentCommand = deps.agentCommand ?? DEFAULT_AGENT_COMMAND;
+	await sshPush(reach, privateKey, buildLauncher({
+		bootstrapToken,
+		targetAgentId,
+		orchestratorUrl,
+		labels
+	}, agentCommand), LAUNCHER_REMOTE_PATH, {}, deps);
+	const run = await sshExec(reach, privateKey, `chmod 0700 ${LAUNCHER_REMOTE_PATH} && ${LAUNCHER_REMOTE_PATH}`, {}, deps);
+	if (run.exitCode !== 0) throw new Error(`init-runner launch on ${targetAgentId} failed: exit ${run.exitCode}${run.stderr ? `\n${run.stderr}` : ""}`);
+	return { broughtUp: true };
+}
+var DEFAULT_AGENT_COMMAND, LAUNCHER_REMOTE_PATH;
+var init_ensure_init_runner = __esmMin((() => {
+	init_ssh_exec();
+	DEFAULT_AGENT_COMMAND = "kici-agent";
+	LAUNCHER_REMOTE_PATH = "/tmp/kici-init-runner.sh";
+}));
+//#endregion
+//#region src/bootstrap/pre-boot-send.ts
+/**
+* Ship a pre-boot input to the target's dropbear/initramfs SSH channel. The
+* input plaintext is resolved server-side and never logged. Resolves once the
+* send completes (the SSH session legitimately drops as the box boots).
+*/
+async function preBootSend(transport, targetAgentId, opts, deps = {}) {
+	const material = await transport("kici.preBootSend", {
+		targetAgentId,
+		inputSecret: opts.inputSecret,
+		...opts.port !== void 0 ? { port: opts.port } : {},
+		...opts.command !== void 0 ? { command: opts.command } : {}
+	});
+	await sshExec(material.reach, material.privateKey, material.command, {
+		stdin: material.input,
+		port: material.port,
+		hostKeyMode: "accept-new"
+	}, deps);
+}
+var init_pre_boot_send = __esmMin((() => {
+	init_ssh_exec();
+}));
+//#endregion
+//#region src/bootstrap/api-intercept.ts
+/**
+* Wrap the orchestrator API transport so the two bootstrap methods are handled
+* in-process (SSH transport here; privileged resolve relayed to the
+* orchestrator). `relay` is the raw orchestrator transport (the WS
+* `sendApiRequest`).
+*/
+function withBootstrapInterception(relay, deps = {}) {
+	return async (method, params = {}) => {
+		if (method === ENSURE_INIT_RUNNER) return ensureInitRunner(relay, String(params.targetAgentId ?? ""), deps);
+		if (method === PRE_BOOT_SEND) {
+			await preBootSend(relay, String(params.targetAgentId ?? ""), {
+				inputSecret: String(params.inputSecret ?? ""),
+				...typeof params.port === "number" ? { port: params.port } : {},
+				...typeof params.command === "string" ? { command: params.command } : {}
+			}, deps);
+			return;
+		}
+		return relay(method, params);
+	};
+}
+var ENSURE_INIT_RUNNER, PRE_BOOT_SEND;
+var init_api_intercept = __esmMin((() => {
+	init_ensure_init_runner();
+	init_pre_boot_send();
+	ENSURE_INIT_RUNNER = "kici.ensureInitRunner";
+	PRE_BOOT_SEND = "kici.preBootSend";
+}));
+//#endregion
 //#region src/execution/dynamic-job-serializer.ts
 /**
 * Convert an array of SDK Job objects into LockJob format for the orchestrator.
@@ -2589,11 +2864,22 @@ async function serializeJobsToLock(jobs, ctx, staticNames, allowedGroups) {
 }
 async function serializeJob(job, generatedNames, ctx, staticNames, allowedGroups) {
 	const { include: runsOn, exclude: excludeLabels } = normalizeRunsOnToMatchers(job.runsOn, `generated job '${job.name}' runsOn`);
-	let resolvedEnvironment;
-	if (typeof job.environment === "function") {
-		const value = await withTimeout(() => job.environment(ctx.event), DYNAMIC_FIELD_TIMEOUT_MS, `dynamic environment for generated job '${job.name}'`);
-		if (value !== void 0 && value !== null) resolvedEnvironment = value;
-	} else if (typeof job.environment === "string") resolvedEnvironment = job.environment;
+	const envRefs = job.environments ?? (job.environment !== void 0 ? [job.environment] : void 0);
+	let resolvedEnvironments;
+	if (envRefs !== void 0 && envRefs.length > 0) {
+		const resolved = [];
+		for (const ref of envRefs) if (typeof ref === "function") {
+			const value = await withTimeout(() => ref(ctx.event), DYNAMIC_FIELD_TIMEOUT_MS, `dynamic environment for generated job '${job.name}'`);
+			if (value !== void 0 && value !== null) resolved.push({
+				value,
+				dynamic: false
+			});
+		} else if (typeof ref === "string") resolved.push({
+			value: ref,
+			dynamic: false
+		});
+		if (resolved.length > 0) resolvedEnvironments = resolved;
+	}
 	let resolvedEnv;
 	if (typeof job.env === "function") {
 		const value = await withTimeout(() => job.env(ctx.event), DYNAMIC_FIELD_TIMEOUT_MS, `dynamic env for generated job '${job.name}'`);
@@ -2619,7 +2905,7 @@ async function serializeJob(job, generatedNames, ctx, staticNames, allowedGroups
 		...job.include ? { include: job.include } : {},
 		...job.exclude ? { exclude: job.exclude } : {},
 		...job.description ? { description: job.description } : {},
-		...resolvedEnvironment !== void 0 ? { environment: resolvedEnvironment } : {},
+		...resolvedEnvironments !== void 0 ? { environments: resolvedEnvironments } : {},
 		...resolvedEnv !== void 0 ? { env: resolvedEnv } : {},
 		...resolvedConcurrencyGroup !== void 0 ? { concurrencyGroup: resolvedConcurrencyGroup } : {}
 	};
@@ -2677,20 +2963,41 @@ function resolveNeeds(needs, generatedNames, staticNames, allowedGroups) {
 * are loaded from the workflow bundle at execution time.
 */
 function serializeSteps(steps) {
-	return steps.map((stepOrFn, index) => {
-		if (typeof stepOrFn === "function") return {
-			name: `step-${index}`,
-			hasOutputs: false
-		};
-		const step = stepOrFn;
-		return {
-			name: step.name || `step-${index}`,
-			hasOutputs: !!step.outputs,
-			...step.continueOnError ? { continueOnError: true } : {},
-			...step.timeout ? { timeout: step.timeout } : {}
-		};
+	let flatIndex = 0;
+	return steps.map((entry) => {
+		if (isParallelGroup(entry)) {
+			const children = entry.steps.map((child) => serializeSequentialStep(child, flatIndex++));
+			return {
+				kind: "parallel",
+				name: entry.name ?? `parallel-${children[0]?.name ?? "group"}`,
+				failFast: entry.failFast,
+				...entry.maxParallel !== void 0 ? { maxParallel: entry.maxParallel } : {},
+				children
+			};
+		}
+		return serializeSequentialStep(entry, flatIndex++);
 	});
 }
+/** Serialize one sequential step (or bare function) to a flat `LockStep`. */
+function serializeSequentialStep(stepOrFn, index) {
+	if (typeof stepOrFn === "function") return {
+		name: `step-${index}`,
+		hasOutputs: false
+	};
+	const step = stepOrFn;
+	return {
+		name: step.name || `step-${index}`,
+		hasOutputs: !!step.outputs,
+		...step.continueOnError ? { continueOnError: true } : {},
+		...step.timeout ? { timeout: step.timeout } : {},
+		...step.retry ? { retry: {
+			maxAttempts: step.retry.maxAttempts,
+			delayMs: step.retry.delayMs,
+			backoff: step.retry.backoff,
+			maxDelayMs: step.retry.maxDelayMs
+		} } : {}
+	};
+}
 /**
 * Serialize matrix configuration. Static array/object matrices are embedded as-is;
 * dynamic matrix functions are invoked against the eval context (mirroring the
@@ -4263,6 +4570,9 @@ function buildRequest(dispatch, workDir) {
 		matrixValues: jobConfig.matrixValues,
 		host: jobConfig.host,
 		agent: jobConfig.agent,
+		dispatchInputs: jobConfig.dispatchInputs,
+		fanoutIndex: jobConfig.fanoutIndex,
+		fanoutTotal: jobConfig.fanoutTotal,
 		secrets: dispatch.secrets,
 		namespacedSecrets: dispatch.namespacedSecrets,
 		sourceFile: jobConfig.source?.file,
@@ -4606,10 +4916,17 @@ function relayChildIpcMessage(msg, dispatch, ctx) {
 		case "log.line":
 			ctx.execOptions.onLogLine(msg.stepIndex, msg.line);
 			return;
-		case "step.start":
+		case "step.start": {
 			ctx.stepNames.set(msg.stepIndex, msg.stepName);
-			ctx.execOptions.onStepStatus(msg.stepIndex, msg.stepName, ExecutionStepStatus.enum.running);
+			const startState = msg.state === "pending" ? ExecutionStepStatus.enum.pending : ExecutionStepStatus.enum.running;
+			const startData = {
+				...msg.concurrencyKind && { concurrencyKind: msg.concurrencyKind },
+				...msg.groupId && { groupId: msg.groupId }
+			};
+			if (Object.keys(startData).length > 0) ctx.execOptions.onStepStatus(msg.stepIndex, msg.stepName, startState, startData);
+			else ctx.execOptions.onStepStatus(msg.stepIndex, msg.stepName, startState);
 			return;
+		}
 		case "step.complete":
 			ctx.execOptions.onStepStatus(msg.stepIndex, ctx.stepNames.get(msg.stepIndex) ?? "", msg.status, {
 				durationMs: msg.durationMs,
@@ -4619,6 +4936,8 @@ function relayChildIpcMessage(msg, dispatch, ctx) {
 				...msg.checkOutcome !== void 0 && { checkOutcome: msg.checkOutcome },
 				...msg.driftSummary !== void 0 && { driftSummary: msg.driftSummary },
 				...msg.drift !== void 0 && { drift: msg.drift },
+				...msg.concurrencyKind && { concurrencyKind: msg.concurrencyKind },
+				...msg.groupId && { groupId: msg.groupId },
 				...msg.data && msg.data
 			});
 			return;
@@ -5332,10 +5651,17 @@ var init_container_sandbox = __esmMin((() => {
 				case "ready":
 					this.sendExecuteRequest(stream, options);
 					return false;
-				case "step.start":
+				case "step.start": {
 					stepNames.set(msg.stepIndex, msg.stepName);
-					options.onStepStatus(msg.stepIndex, msg.stepName, ExecutionStepStatus.enum.running);
+					const startState = msg.state === "pending" ? ExecutionStepStatus.enum.pending : ExecutionStepStatus.enum.running;
+					const startData = {
+						...msg.concurrencyKind && { concurrencyKind: msg.concurrencyKind },
+						...msg.groupId && { groupId: msg.groupId }
+					};
+					if (Object.keys(startData).length > 0) options.onStepStatus(msg.stepIndex, msg.stepName, startState, startData);
+					else options.onStepStatus(msg.stepIndex, msg.stepName, startState);
 					return false;
+				}
 				case "step.complete": {
 					const name = stepNames.get(msg.stepIndex) ?? `step-${msg.stepIndex}`;
 					options.onStepStatus(msg.stepIndex, name, msg.status, {
@@ -5346,6 +5672,8 @@ var init_container_sandbox = __esmMin((() => {
 						...msg.checkOutcome !== void 0 && { checkOutcome: msg.checkOutcome },
 						...msg.driftSummary !== void 0 && { driftSummary: msg.driftSummary },
 						...msg.drift !== void 0 && { drift: msg.drift },
+						...msg.concurrencyKind && { concurrencyKind: msg.concurrencyKind },
+						...msg.groupId && { groupId: msg.groupId },
 						...msg.data && msg.data
 					});
 					stepResults.push({
@@ -5543,6 +5871,8 @@ var init_job_runner = __esmMin((() => {
 	init_source_packer();
 	init_source_restore();
 	init_init_runner();
+	init_api_intercept();
+	init_ensure_init_runner();
 	init_timeout_util();
 	init_dynamic_job_serializer();
 	init_log_streamer();
@@ -5655,6 +5985,10 @@ var init_job_runner = __esmMin((() => {
 				await this.handleDynamicJobFn(dispatch, workDir, abortController);
 				return true;
 			}
+			if (jobConfig.bringupOnly === true) {
+				await this.handleBringupJob(dispatch);
+				return true;
+			}
 			if (jobConfig.buildOnly === true) {
 				if (jobConfig.fullRepo) {
 					logger$2.warn("Build job received for fullRepo run -- skipping (should not happen)", {
@@ -5827,7 +6161,7 @@ var init_job_runner = __esmMin((() => {
 						reason: ack.reason
 					};
 				},
-				onApiRequest: this._sendApiRequest ? async (method, params) => this._sendApiRequest(method, params) : void 0,
+				onApiRequest: this._sendApiRequest ? withBootstrapInterception(async (method, params) => this._sendApiRequest(method, params)) : void 0,
 				onCacheRequest: this._requestUserCache ? async (request) => this._requestUserCache(jobId, request) : void 0,
 				onProvenanceRequest: this._relayProvenance ? async (request) => this._relayProvenance(jobId, request) : void 0,
 				onApprovalRequest: this._sendStepApproval ? async (request) => this._sendStepApproval(dispatch.runId, dispatch.jobId, request) : void 0,
@@ -5889,6 +6223,53 @@ var init_job_runner = __esmMin((() => {
 			}, result.secretOutputs);
 		}
 		/**
+		* Handle a bring-up job: bring up a temporary init-runner on a declared-but-
+		* un-agented host over SSH (fresh-box bootstrap convergence). The orchestrator
+		* dispatches this synthetic `__bringup__` job to an agent holding the
+		* `kici:capability:ssh-transport` capability; here we run the agent-side
+		* `ensureInitRunner` helper (the privileged resolve is relayed to the
+		* orchestrator, the SSH transport happens in this agent process — never
+		* reaching workflow code). No clone, no sandbox — the init-runner then
+		* connects under the target's agent id and the orchestrator's pinned-hold
+		* drains the target's bootstrap steps onto it.
+		*/
+		async handleBringupJob(dispatch) {
+			const { runId, jobId, jobConfig } = dispatch;
+			const targetAgentId = String(jobConfig.bringupTarget ?? "");
+			logger$2.info("Starting bring-up job", {
+				jobId,
+				runId,
+				targetAgentId
+			});
+			this.sendJobStatus(dispatch, ExecutionJobStatus.enum.running);
+			const streamer = this.createStepStreamer(dispatch, 0);
+			this.sendStepStatus(dispatch, 0, "bring-up", ExecutionStepStatus.enum.running);
+			try {
+				if (!targetAgentId) throw new Error("bring-up job missing bringupTarget");
+				if (!this._sendApiRequest) throw new Error("bring-up job requires an orchestrator API transport");
+				streamer.addLine(`Bringing up init-runner on ${targetAgentId}…`);
+				const result = await ensureInitRunner(async (method, params) => this._sendApiRequest(method, params), targetAgentId);
+				streamer.addLine(result.broughtUp ? `Init-runner brought up on ${targetAgentId}.` : `${targetAgentId} already has a live agent — no bring-up needed.`);
+				await streamer.flush();
+				this.sendStepStatus(dispatch, 0, "bring-up", ExecutionStepStatus.enum.success, void 0, streamer.getTotalBytes());
+				streamer.destroy();
+				this.sendJobStatus(dispatch, ExecutionJobStatus.enum.success);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				streamer.addLine(`Bring-up failed: ${message}`);
+				await streamer.flush();
+				this.sendStepStatus(dispatch, 0, "bring-up", ExecutionStepStatus.enum.failed, void 0, streamer.getTotalBytes());
+				streamer.destroy();
+				this.sendJobStatus(dispatch, ExecutionJobStatus.enum.failed, { error: message });
+				logger$2.warn("Bring-up job failed", {
+					jobId,
+					runId,
+					targetAgentId,
+					error: message
+				});
+			}
+		}
+		/**
 		* Handle a build-only job.
 		*
 		* Build jobs install dependencies, pack them into a tarball,
@@ -6164,7 +6545,7 @@ var init_job_runner = __esmMin((() => {
 				});
 				logger$2.info("Init job completed successfully", {
 					jobId,
-					hasEnvironment: initResult.environmentName !== void 0,
+					hasEnvironment: initResult.environmentNames !== void 0,
 					hasEnv: initResult.env !== void 0,
 					hasConcurrencyGroup: initResult.concurrencyGroup !== void 0
 				});
@@ -6281,7 +6662,7 @@ var init_job_runner = __esmMin((() => {
 					error: (msg, ..._args) => evalLog(`ERROR: ${msg}`),
 					debug: (msg, ..._args) => evalLog(`DEBUG: ${msg}`)
 				};
-				const kici = buildKiciApi(this._sendApiRequest ? (method, params) => this._sendApiRequest(method, params ?? {}) : () => Promise.reject(/* @__PURE__ */ new Error("Agent API not available")));
+				const kici = buildKiciApi(this._sendApiRequest ? withBootstrapInterception((method, params) => this._sendApiRequest(method, params ?? {})) : () => Promise.reject(/* @__PURE__ */ new Error("Agent API not available")));
 				const lockJobs = await runCaptured(evalSink, async () => {
 					const { module } = await loadWorkflowSource(workDir, config.source.file, config.contentHash, config.resolvedHashFiles);
 					evalLog("Workflow loaded");
@@ -6471,7 +6852,9 @@ var init_job_runner = __esmMin((() => {
 		*/
 		sendStepStatus(dispatch, stepIndex, stepName, state, data, logBytesStreamed) {
 			const secretsAccessed = data?.secretsAccessed;
-			const { secretsAccessed: _, ...restData } = data ?? {};
+			const concurrencyKind = data?.concurrencyKind;
+			const groupId = data?.groupId;
+			const { secretsAccessed: _s, concurrencyKind: _c, groupId: _g, ...restData } = data ?? {};
 			const hasRestData = Object.keys(restData).length > 0;
 			this.sendDirect({
 				type: "step.status",
@@ -6484,6 +6867,8 @@ var init_job_runner = __esmMin((() => {
 				timestamp: Date.now(),
 				...hasRestData && { data: restData },
 				...secretsAccessed !== void 0 && { secretsAccessed },
+				...concurrencyKind !== void 0 && { concurrencyKind },
+				...groupId !== void 0 && { groupId },
 				...logBytesStreamed !== void 0 && { logBytesStreamed }
 			});
 		}
@@ -6511,14 +6896,14 @@ var init_job_runner = __esmMin((() => {
 */
 init_console_capture();
 init_npm_resolver();
-const AGENT_VERSION = "0.1.22";
-const BUILD_COMMIT = "5afd16303";
-const SDK_VERSION = "0.1.22";
-const SDK_BUNDLE_HASH = "4b26a42978f77e29db110d47523ec947d3d673c3109fc48141c1a62814bde7a1";
-const SHARED_VERSION = "0.1.22";
-const SHARED_BUNDLE_HASH = "991385c024392c395d3eb8a68946ef8ed3fcba96f2652f21c3164a54eafa1b1b";
-const ENGINE_VERSION = "0.1.22";
-const ENGINE_BUNDLE_HASH = "ff74a3afb2b1db2870c03d47543642f64d04b660bebdcde6681f76d874f26757";
+const AGENT_VERSION = "0.1.24";
+const BUILD_COMMIT = "73592f67f";
+const SDK_VERSION = "0.1.24";
+const SDK_BUNDLE_HASH = "031712cf8cd02f483365113aad7e946da982110d544b177eb05edcc0d4421253";
+const SHARED_VERSION = "0.1.24";
+const SHARED_BUNDLE_HASH = "b977224129c767c4851458a795fa470264b2fc51255baf06cf14640e29e2f44c";
+const ENGINE_VERSION = "0.1.24";
+const ENGINE_BUNDLE_HASH = "734acca885cd70eed07a1a9426b08c04c07a9bf99484c18100d3d797b3eb8f39";
 initTelemetry({
 	serviceName: "kici-agent",
 	otlpEndpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT