@kici-dev/orchestrator 0.7.0 → 0.8.0

package/dist/standalone.js

@@ -1382,7 +1382,7 @@ var logger$134, SOFTWARE_VERSION$1, PeerClient$1;
 var init_peer_client = __esmMin((() => {
 	init_peer_crypto();
 	logger$134 = createLogger({ prefix: "peer-client" });
-	SOFTWARE_VERSION$1 = "0.7.0";
+	SOFTWARE_VERSION$1 = "0.8.0";
 	PeerClient$1 = class {
 		ws = null;
 		_state = "disconnected";
@@ -3396,7 +3396,7 @@ var init_peer_handler = __esmMin((() => {
 	init_peer_crypto();
 	init_join_token();
 	logger$132 = createLogger({ prefix: "peer-handler" });
-	SOFTWARE_VERSION = "0.7.0";
+	SOFTWARE_VERSION = "0.8.0";
 	RATE_LIMIT_MAX = 5;
 	RATE_LIMIT_WINDOW_MS = 6e4;
 }));
@@ -24348,7 +24348,10 @@ async function clusterRouteRootJobs(args) {
 			runsOnLabels: [sel.runsOnLabels],
 			runsOnPatterns: sel.runsOnPatterns,
 			excludePatterns: sel.excludePatterns,
-			jobConfig: buildJobConfig(mj),
+			jobConfig: {
+				...buildJobConfig(mj),
+				...ctx.extraJobConfig
+			},
 			repoUrl: bundle?.repoUrlBuilder?.buildCloneUrl(repoIdentifier) ?? "",
 			ref: event.sourceBranch ?? event.targetBranch,
 			sha: ref,
@@ -25328,7 +25331,10 @@ async function dispatchExecutionAfterInit(args) {
 			runsOnLabels: [runsOnLabels],
 			runsOnPatterns: selectors.runsOnPatterns,
 			excludePatterns: selectors.excludePatterns,
-			jobConfig: buildJobConfig(mat),
+			jobConfig: {
+				...buildJobConfig(mat),
+				...ctx.extraJobConfig
+			},
 			repoUrl: bundle?.repoUrlBuilder?.buildCloneUrl(repoIdentifier) ?? "",
 			ref: event.sourceBranch ?? event.targetBranch,
 			sha: ref,
@@ -29323,6 +29329,7 @@ var init_lockfile_cache = __esmMin((() => {
 		*/
 		async get(fetcher, repoIdentifier, ref, credentials) {
 			const cacheKey = `${fetcher.provider}:${repoIdentifier}:${ref}`;
+			if (fetcher.cacheable === false) return this.fetchAndValidate(fetcher, repoIdentifier, ref, credentials, void 0);
 			const cached = this.cache.get(cacheKey);
 			if (cached !== void 0) {
 				this.hits++;
@@ -29378,7 +29385,7 @@ var init_lockfile_cache = __esmMin((() => {
 				if (error instanceof LockFileParseError) throw error;
 				throw new LockFileParseError(repoIdentifier, ref, message);
 			}
-			this.cache.set(cacheKey, lockFile);
+			if (cacheKey !== void 0) this.cache.set(cacheKey, lockFile);
 			return lockFile;
 		}
 		/**
@@ -33859,10 +33866,12 @@ var init_warm_pool = __esmMin((() => {
 		* Start the periodic tick: reap surplus agents past their idle timeout, then
 		* top the pools back up.
 		*
-		* The first pass runs immediately rather than a tick later. Both hosts call
-		* this only after `ensureHostsReady()`, so spawning here is safe — and
-		* waiting would leave the pool empty for 30 seconds after every restart,
-		* which is precisely the cold start it exists to remove.
+		* The first pass runs immediately rather than a tick later. The one caller
+		* is `ScalerManager.startWarmPools()`, which each host reaches only after
+		* `ensureHostsReady()` and — on the coordinator — after the event emitter
+		* is assigned, so spawning here is safe. Waiting a tick instead would leave
+		* the pool empty for 30 seconds after every restart, which is precisely the
+		* cold start it exists to remove.
 		*/
 		start() {
 			if (this.idleCheckInterval) return;
@@ -34775,10 +34784,10 @@ var init_event_backend = __esmMin((() => {
 		async spawn(labelSet, agentId, orchestratorUrl, _onEvent, effectiveLimits, spawnContext, signal) {
 			if (signal?.aborted) throw new Error("event scaler spawn aborted before start");
 			const fullLabels = scalerAgentLabels(labelSet, this.type, this.entry.name, this.entry.roles, spawnContext?.platformTaints);
+			const mandatoryLabels = [...spawnContext?.mandatoryLabels ?? this.entry.mandatoryLabels ?? []];
 			const claimCode = await this.claimStore.register({
 				agentId,
 				labels: fullLabels,
-				mandatoryLabels: this.entry.mandatoryLabels ?? [],
 				agentTokenTtlSeconds: this.entry.agentTokenTtlSeconds ?? DEFAULT_AGENT_TOKEN_TTL_SECONDS,
 				orchestratorUrl
 			});
@@ -34797,7 +34806,7 @@ var init_event_backend = __esmMin((() => {
 					scalerName: this.entry.name,
 					agentId,
 					labels: fullLabels,
-					mandatoryLabels: this.entry.mandatoryLabels ?? [],
+					mandatoryLabels,
 					resources,
 					orchestratorUrl,
 					claimCode,
@@ -34911,12 +34920,13 @@ var init_event_backend = __esmMin((() => {
 			if (this.agents.size > 0) logger$81.info(`Leaving ${this.agents.size} event provision(s) to the cluster on shutdown; teardown is the holding coordinator's or the reaper's`);
 		}
 		/**
-		* Apply the new config. The backend reads `roles`, `mandatoryLabels`,
-		* `agentTokenTtlSeconds` and `provisioningTargets` off its entry at every
-		* spawn, so the entry is replaced here — otherwise a reload that retargets
-		* the provisioning workflow, or changes the scaler's roles, would keep
-		* emitting scale-up events to the old workflow refs and minting agent labels
-		* from the old roles, while the manager's own routing gate used the new ones.
+		* Apply the new config. The backend reads `roles`, `agentTokenTtlSeconds`
+		* and `provisioningTargets` off its entry at every spawn (and
+		* `mandatoryLabels` only when a spawn reaches it without a context), so the
+		* entry is replaced here — otherwise a reload that retargets the
+		* provisioning workflow, or changes the scaler's roles, would keep emitting
+		* scale-up events to the old workflow refs and minting agent labels from the
+		* old roles, while the manager's own routing gate used the new ones.
 		*/
 		reload(labelSets, opts) {
 			this.labelSets = labelSets;
@@ -35943,7 +35953,10 @@ var init_manager = __esmMin((() => {
 				await this.spawnSemaphoreFor(backendName).run(() => {
 					const entry = this.spawningAgents.get(agentId);
 					if (entry) entry.spawnStartedAt = Date.now();
-					return this.runSpawnWithTimeout(void 0, (signal) => backend.spawn(labelSet, agentId, this.getOrchestratorUrl(backendName), onEvent, spawnLimitsFor(effective.limits), { platformTaints: this.platformTaintsFor(backendName, backend.type) }, signal));
+					return this.runSpawnWithTimeout(void 0, (signal) => backend.spawn(labelSet, agentId, this.getOrchestratorUrl(backendName), onEvent, spawnLimitsFor(effective.limits), {
+						platformTaints: this.platformTaintsFor(backendName, backend.type),
+						mandatoryLabels: this.labelSetMandatoryLabels(backendName, backend, labelSet)
+					}, signal));
 				});
 				this.startLogForwarding(backend, agentId);
 			} catch (err) {
@@ -36459,6 +36472,7 @@ var init_manager = __esmMin((() => {
 				boundJobId: jobId,
 				runId,
 				platformTaints: this.platformTaintsFor(backendName, backend.type),
+				mandatoryLabels: this.labelSetMandatoryLabels(backendName, backend, spawnLabelSet),
 				...containerSpawn ? { container: containerSpawn } : {}
 			};
 			this.spawnSemaphoreFor(backendName).run(() => {
@@ -37820,12 +37834,16 @@ var init_manager = __esmMin((() => {
 			return backend.getScalerContext?.(agentId);
 		}
 		/**
-		* Start the warm pool idle check interval, the machine-pool ledger reaper,
-		* and the retirement sweep that tears down drained retiring backends.
+		* Start the machine-pool ledger reaper and the retirement sweep that tears
+		* down drained retiring backends, and publish the warm-pool gauges so each
+		* pool's target is visible before its first fill.
+		*
+		* The warm pools themselves are NOT started here — see
+		* {@link startWarmPools}, which the host calls once every dependency a fill
+		* can reach is wired.
 		*/
 		start() {
 			this.started = true;
-			this.warmPool.start();
 			this.publishWarmPoolGauges();
 			if (this.machineLedger) this.machineLedger.start();
 			this.retirementSweep ??= setInterval(() => {
@@ -37834,6 +37852,18 @@ var init_manager = __esmMin((() => {
 			this.retirementSweep.unref?.();
 		}
 		/**
+		* Run the warm pools' first deficit pass and arm their periodic tick.
+		*
+		* Separate from {@link start} because the first pass spawns immediately,
+		* and on an event backend a spawn emits through the event emitter — which
+		* the coordinator assigns after the scaler is built. The coordinator calls
+		* this once the emitter exists; the worker, which hosts no event backend,
+		* calls it right after `start()`.
+		*/
+		startWarmPools() {
+			this.warmPool.start();
+		}
+		/**
 		* Provision/heal every backend's host prerequisites before spawning starts.
 		* Awaits each backend's optional ensureHostReady, catching per-backend so one
 		* scaler's host-prep failure degrades only that scaler (its spawns will fail
@@ -38085,6 +38115,7 @@ var init_manager = __esmMin((() => {
 		* coord boot or Raft leader switch. Reconstructs:
 		*
 		*   - `spawningAgents` (with `boundJobId` preserved for eager-dispatch on register)
+		*     — event-backend rows only; a local-backend row is dropped, see below
 		*   - `agentJobCorrelation` (so scaler-lifecycle events route correctly)
 		*   - `reservations` + `perScalerUsage` (so the cap-check critical
 		*     section reflects the cluster-wide truth, not the local empty
@@ -38106,6 +38137,7 @@ var init_manager = __esmMin((() => {
 		async recoverState() {
 			const recovery = {
 				spawningAgentsRehydrated: 0,
+				spawningDropped: 0,
 				agentJobsRehydrated: 0,
 				reservationsRehydrated: 0,
 				reservationsDropped: 0,
@@ -38114,17 +38146,25 @@ var init_manager = __esmMin((() => {
 			if (!this.stateStore) return recovery;
 			try {
 				const spawning = await this.stateStore.listSpawningAgentsForOwner(this.instanceId);
-				for (const entry of spawning) this.spawningAgents.set(entry.agentId, {
-					labelSet: entry.labelSet,
-					backendName: entry.scalerName,
-					provisioningTargets: entry.provisioningTargets ?? [],
-					spawnedAt: entry.spawnedAt.getTime(),
-					spawnStartedAt: entry.spawnedAt.getTime(),
-					...entry.backendType !== void 0 && { backendType: entry.backendType },
-					...entry.boundJobId !== void 0 && { boundJobId: entry.boundJobId },
-					...entry.runId !== void 0 && { runId: entry.runId }
-				});
-				recovery.spawningAgentsRehydrated = spawning.length;
+				for (const entry of spawning) {
+					const backendType = entry.backendType ?? this.backends.get(entry.scalerName)?.type;
+					if (backendType !== void 0 && backendType !== ScalerBackendType.enum.event) {
+						this.deleteUnadoptedSpawningAgentFromStore(entry.agentId);
+						recovery.spawningDropped += 1;
+						continue;
+					}
+					this.spawningAgents.set(entry.agentId, {
+						labelSet: entry.labelSet,
+						backendName: entry.scalerName,
+						provisioningTargets: entry.provisioningTargets ?? [],
+						spawnedAt: entry.spawnedAt.getTime(),
+						spawnStartedAt: entry.spawnedAt.getTime(),
+						...entry.backendType !== void 0 && { backendType: entry.backendType },
+						...entry.boundJobId !== void 0 && { boundJobId: entry.boundJobId },
+						...entry.runId !== void 0 && { runId: entry.runId }
+					});
+				}
+				recovery.spawningAgentsRehydrated = spawning.length - recovery.spawningDropped;
 				const correlations = await this.stateStore.listAgentJobs();
 				for (const c of correlations) this.agentJobCorrelation.set(c.agentId, {
 					runId: c.runId,
@@ -39979,7 +40019,8 @@ function createAgentWsHandler(deps) {
 			if (rateLimiter) {
 				const messageSize = typeof evt.data === "string" ? evt.data.length : 0;
 				const isHeartbeat = raw !== null && typeof raw === "object" && "type" in raw && raw.type === "heartbeat";
-				const rlResult = rateLimiter.check(messageSize, isHeartbeat);
+				const isSolicitedFleetChunk = raw !== null && typeof raw === "object" && raw.type === "fleet.bundle.chunk" && typeof raw.requestId === "string" && deps.fleetAgentCollector !== void 0 && wsToAgentId.has(ws) && deps.fleetAgentCollector.isPendingFor(raw.requestId, wsToAgentId.get(ws));
+				const rlResult = rateLimiter.check(messageSize, isHeartbeat || isSolicitedFleetChunk);
 				if (!rlResult.allowed) {
 					if (rlResult.action === "disconnect") {
 						logger$75.warn("Rate limit disconnect", { reason: rlResult.reason });
@@ -57591,6 +57632,14 @@ var init_lock_file_fetcher = __esmMin((() => {
 		repoBasePath;
 		provider = "local";
 		/**
+		* Never cached: `ref` is ignored below, so a cache keyed on it would serve the
+		* first lock file read to every later trigger for the lifetime of the entry —
+		* a `kici run --local` dispatch always triggers at `HEAD`, and an in-place run
+		* carries its uncommitted edits under an unchanged sha. Reading the file from
+		* disk is what makes those edits reach the run.
+		*/
+		cacheable = false;
+		/**
 		* @param repoBasePath - Base directory for the repo(s). When repoIdentifier
 		*   starts with 'file://', it is stripped and used as-is. Otherwise
 		*   repoBasePath is used as the root.
@@ -61486,15 +61535,15 @@ var init_admin_config = __esmMin((() => {
 function createHealthRoutes$1(deps = {}) {
 	return createHealthRoutes({
 		livenessInfo: () => ({
-			version: "0.7.0",
-			buildDate: "2026-09-11T06:52:31.673Z",
-			buildCommit: "31843a21c",
-			sdkVersion: "0.7.0",
+			version: "0.8.0",
+			buildDate: "2026-09-13T11:42:43.287Z",
+			buildCommit: "57712173f",
+			sdkVersion: "0.8.0",
 			sdkBundleHash: "065963c7765dc8d87e04d45f57d7e15be1613da705e4ff3ec3742fd1408b7bf5",
-			sharedVersion: "0.7.0",
-			sharedBundleHash: "a79be949815735b9e36eecc716f7eb07aa36c7bffba62e798e7e19f31a474eff",
-			engineVersion: "0.7.0",
-			engineBundleHash: "380f6edf7e0e5cfe988fa0f98512de6e6864f4f2a7a8d07f67e2ab84ed637d19"
+			sharedVersion: "0.8.0",
+			sharedBundleHash: "c1c70e41a1ec14fd7cf3a6047251e9aa11258a21e3694ea89a50e8bf14b99f9d",
+			engineVersion: "0.8.0",
+			engineBundleHash: "b26b2f23059c2ceb06a65feb2dcfe2d8c8be45ccf66622823ffedf742d2d7599"
 		}),
 		readinessCheck: deps.db ? async () => {
 			const checks = {};
@@ -61529,7 +61578,7 @@ function createCapabilitiesRoutes() {
 	const app = new Hono();
 	app.get("/api/v1/capabilities", (c) => {
 		const manifest = {
-			orchestratorVersion: "0.7.0",
+			orchestratorVersion: "0.8.0",
 			protocolVersion: PROTOCOL_VERSION,
 			minProtocolVersion: MIN_PROTOCOL_VERSION
 		};
@@ -64497,7 +64546,7 @@ var init_app = __esmMin((() => {
 	init_log_chunk_sink();
 	init_agent_metrics_aggregator();
 	logger$31 = createLogger({ prefix: "app" });
-	ORCHESTRATOR_VERSION$2 = "0.7.0";
+	ORCHESTRATOR_VERSION$2 = "0.8.0";
 	SourceLocationStore = class {
 		cache = /* @__PURE__ */ new Map();
 		key(workflowName, jobName) {
@@ -64552,6 +64601,15 @@ var init_fleet_agent_collector = __esmMin((() => {
 		onChunk(requestId, seq, dataB64, isLast) {
 			this.waiter.onChunk(requestId, seq, dataB64, isLast);
 		}
+		/**
+		* Whether `requestId` is a collection this orchestrator asked `agentId` for
+		* and is still waiting on. The agent handler consults this before rate
+		* limiting a `fleet.bundle.chunk`: a solicited transfer is exempt, an
+		* unsolicited one is not.
+		*/
+		isPendingFor(requestId, agentId) {
+			return this.requestAgent.get(requestId) === agentId;
+		}
 		onError(requestId, message) {
 			this.waiter.onError(requestId, message);
 		}
@@ -65700,6 +65758,9 @@ var init_container_backend = __esmMin((() => {
 				state: "spawning"
 			};
 			this.agents.set(managed.id, managed);
+			const assertStillTracked = () => {
+				if (this.agents.get(managed.id) !== managed) throw new Error(`Agent ${agentId} was torn down while its container was being provisioned`);
+			};
 			try {
 				const agentEnvForwarded = [];
 				for (const [key, value] of Object.entries(process.env)) if (key.startsWith(KICI_AGENT_ENV_PREFIX) && value !== void 0) {
@@ -65773,17 +65834,24 @@ var init_container_backend = __esmMin((() => {
 					...this.networkIsolation && { NetworkingConfig: { EndpointsConfig: { ["kici-agent-net"]: {} } } }
 				});
 				createdContainer = container;
+				managed.backendRef = container.id;
+				this.containerToManaged.set(container.id, managed.id);
+				assertStillTracked();
 				if (this.networkIsolation) emit(ScalerEventType$1.enum["scaler.network"], "configuring network isolation");
 				await container.start({ abortSignal: signal });
+				assertStillTracked();
 				emit(ScalerEventType$1.enum["scaler.ready"], "container started");
-				if (this.networkIsolation) await this.applyIsolationRules({
-					agentId,
-					managedId: managed.id,
-					containerId: container.id,
-					networkPolicy: matchedLabelSet.networkPolicy,
-					orchestratorUrl,
-					...signal ? { signal } : {}
-				});
+				if (this.networkIsolation) {
+					await this.applyIsolationRules({
+						agentId,
+						managedId: managed.id,
+						containerId: container.id,
+						networkPolicy: matchedLabelSet.networkPolicy,
+						orchestratorUrl,
+						...signal ? { signal } : {}
+					});
+					assertStillTracked();
+				}
 				try {
 					const capture = await createContainerLogCapture(this.docker, container.id);
 					this.logCaptures.set(managed.id, capture);
@@ -65793,13 +65861,17 @@ var init_container_backend = __esmMin((() => {
 						error: toErrorMessage(err)
 					});
 				}
+				assertStillTracked();
 				managed.state = "running";
-				managed.backendRef = container.id;
-				this.containerToManaged.set(container.id, managed.id);
 				emit(ScalerEventType$1.enum["agent.connecting"], "waiting for agent WS registration");
 				return managed;
 			} catch (err) {
-				const t = this.logCaptures.get(managed.id)?.tail() ?? "";
+				const capture = this.logCaptures.get(managed.id);
+				const t = capture?.tail() ?? "";
+				if (capture) {
+					capture.close();
+					this.logCaptures.delete(managed.id);
+				}
 				const base = toErrorMessage(err);
 				emit(ScalerEventType$1.enum["scaler.failed"], t ? `${base}\n--- captured output ---\n${t}` : base);
 				const failedIp = this.containerIps.get(managed.id);
@@ -65809,10 +65881,13 @@ var init_container_backend = __esmMin((() => {
 					} catch {}
 					this.containerIps.delete(managed.id);
 				}
-				if (createdContainer) try {
-					await createdContainer.remove({ force: true });
-				} catch {}
-				this.agents.delete(managed.id);
+				if (createdContainer) {
+					this.containerToManaged.delete(createdContainer.id);
+					try {
+						await createdContainer.remove({ force: true });
+					} catch {}
+				}
+				if (this.agents.get(managed.id) === managed) this.agents.delete(managed.id);
 				throw err;
 			}
 		}
@@ -65849,6 +65924,7 @@ var init_container_backend = __esmMin((() => {
 				capture.close();
 				this.logCaptures.delete(managedId);
 			}
+			if (!managed.backendRef) return;
 			try {
 				const container = this.docker.getContainer(managed.backendRef);
 				try {
@@ -81376,6 +81452,7 @@ async function bootstrapOrchestrator$1(config, hooks, options) {
 		nodeId: config.instanceId
 	});
 	eventEmitter = new EventEmitter$1(eventRouter);
+	scalerManager?.startWarmPools();
 	const invokeGateDeps = {
 		db,
 		executionTracker,
@@ -82909,6 +82986,17 @@ var init_in_memory_job_queue = __esmMin((() => {
 		async getPendingJobs() {
 			return [...this.jobs.values()].filter((j) => j.status === "pending");
 		}
+		/**
+		* Oldest-first listing of pending jobs, capped at `limit` — the worker-side
+		* twin of `JobQueue.listPending`. The dispatcher's capacity-freed re-drive
+		* (`retryPendingScaleRequests`) reads it on every worker whose scaler frees
+		* a slot; `worker-core` wires that hook exactly as the coordinator does.
+		* Insertion order is the enqueue order, which is what `created_at ASC` gives
+		* the DB queue.
+		*/
+		async listPending(limit) {
+			return (await this.getPendingJobs()).slice(0, Math.max(0, limit));
+		}
 		/** Always returns empty array. */
 		async getDispatchedJobIdsByRunId(_runId) {
 			return [];
@@ -83417,6 +83505,7 @@ async function initializeWorkerScaler(config, tokenStore, onScalerEvent, tokenTt
 	}
 	await scalerManager.ensureHostsReady();
 	scalerManager.start();
+	scalerManager.startWarmPools();
 	logger$2.info("Worker scaler initialized", {
 		backends: backends.map((b) => b.name),
 		globalMaxAgents: scalerConfig.globalMaxAgents
@@ -84109,14 +84198,14 @@ var init_worker_core = __esmMin((() => {
 	init_peer_outbox();
 	init_worker_outbox_relay();
 	init_app_on_error();
-	ORCHESTRATOR_VERSION$1 = "0.7.0";
-	WORKER_BUILD_COMMIT = "31843a21c";
-	WORKER_SDK_VERSION = "0.7.0";
+	ORCHESTRATOR_VERSION$1 = "0.8.0";
+	WORKER_BUILD_COMMIT = "57712173f";
+	WORKER_SDK_VERSION = "0.8.0";
 	WORKER_SDK_BUNDLE_HASH = "065963c7765dc8d87e04d45f57d7e15be1613da705e4ff3ec3742fd1408b7bf5";
-	WORKER_SHARED_VERSION = "0.7.0";
-	WORKER_SHARED_BUNDLE_HASH = "a79be949815735b9e36eecc716f7eb07aa36c7bffba62e798e7e19f31a474eff";
-	WORKER_ENGINE_VERSION = "0.7.0";
-	WORKER_ENGINE_BUNDLE_HASH = "380f6edf7e0e5cfe988fa0f98512de6e6864f4f2a7a8d07f67e2ab84ed637d19";
+	WORKER_SHARED_VERSION = "0.8.0";
+	WORKER_SHARED_BUNDLE_HASH = "c1c70e41a1ec14fd7cf3a6047251e9aa11258a21e3694ea89a50e8bf14b99f9d";
+	WORKER_ENGINE_VERSION = "0.8.0";
+	WORKER_ENGINE_BUNDLE_HASH = "b26b2f23059c2ceb06a65feb2dcfe2d8c8be45ccf66622823ffedf742d2d7599";
 	logger$2 = createLogger({ prefix: "worker" });
 	DRAIN_TIMEOUT_MS = 3e5;
 }));
@@ -84140,14 +84229,14 @@ var init_worker_core = __esmMin((() => {
 * Graceful shutdown:
 * agent WS -> heartbeat -> HTTP -> DB
 */
-const ORCHESTRATOR_VERSION = "0.7.0";
-const BUILD_COMMIT = "31843a21c";
-const SDK_VERSION = "0.7.0";
+const ORCHESTRATOR_VERSION = "0.8.0";
+const BUILD_COMMIT = "57712173f";
+const SDK_VERSION = "0.8.0";
 const SDK_BUNDLE_HASH = "065963c7765dc8d87e04d45f57d7e15be1613da705e4ff3ec3742fd1408b7bf5";
-const SHARED_VERSION = "0.7.0";
-const SHARED_BUNDLE_HASH = "a79be949815735b9e36eecc716f7eb07aa36c7bffba62e798e7e19f31a474eff";
-const ENGINE_VERSION = "0.7.0";
-const ENGINE_BUNDLE_HASH = "380f6edf7e0e5cfe988fa0f98512de6e6864f4f2a7a8d07f67e2ab84ed637d19";
+const SHARED_VERSION = "0.8.0";
+const SHARED_BUNDLE_HASH = "c1c70e41a1ec14fd7cf3a6047251e9aa11258a21e3694ea89a50e8bf14b99f9d";
+const ENGINE_VERSION = "0.8.0";
+const ENGINE_BUNDLE_HASH = "b26b2f23059c2ceb06a65feb2dcfe2d8c8be45ccf66622823ffedf742d2d7599";
 const otelSdk = initTelemetry({
 	serviceName: "kici-orchestrator",
 	otlpEndpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT

package/dist/webhook/ingest-overflow-replayer.d.ts

@@ -80,7 +80,7 @@ export interface IngestOverflowReplayerDeps {
  * Refusal is per fairness key: a saturated org's rows are skipped for the rest
  * of the pass while other orgs' rows keep draining, mirroring the fair skip the
  * controller's own queue does. Reclaiming is not gated on load at all: a
- * stranded claim is stranded regardless, and the row it frees simply waits in
+ * stranded claim is stranded regardless, and the row it frees waits in
  * `buffered` until a reservation succeeds.
  */
 export declare class IngestOverflowReplayer {

package/dist/webhook/relay-reinject.d.ts

@@ -36,7 +36,7 @@ export declare function parseRelayPayload(body: Buffer, headers: Record<string,
  * would be a second, redundant gate — and a refusal from it would be charged to
  * the delivery as a failed replay attempt, which is the defect this ordering
  * exists to remove. The slot is genuinely held: nothing here bypasses the
- * controller, the decision was simply made one step earlier.
+ * controller, the decision was made one step earlier.
  */
 export declare function buildRelayReinject(seams: RelayReinjectSeams): ReinjectFn;
 //# sourceMappingURL=relay-reinject.d.ts.map

package/dist/worker/in-memory-job-queue.d.ts

@@ -104,6 +104,15 @@ export declare class InMemoryJobQueue {
     getFullJobById(jobId: string): Promise<QueuedJob | null>;
     /** Return all pending jobs. */
     getPendingJobs(): Promise<QueuedJob[]>;
+    /**
+     * Oldest-first listing of pending jobs, capped at `limit` — the worker-side
+     * twin of `JobQueue.listPending`. The dispatcher's capacity-freed re-drive
+     * (`retryPendingScaleRequests`) reads it on every worker whose scaler frees
+     * a slot; `worker-core` wires that hook exactly as the coordinator does.
+     * Insertion order is the enqueue order, which is what `created_at ASC` gives
+     * the DB queue.
+     */
+    listPending(limit: number): Promise<QueuedJob[]>;
     /** Always returns empty array. */
     getDispatchedJobIdsByRunId(_runId: string): Promise<string[]>;
     /** Lookup across pending and dispatched jobs (id / runId / status). */

package/dist/ws/fleet-agent-collector.d.ts

@@ -14,6 +14,13 @@ export declare class FleetAgentCollector {
      */
     request(requestId: string, agentId: string, send: () => void): Promise<Buffer>;
     onChunk(requestId: string, seq: number, dataB64: string, isLast: boolean): void;
+    /**
+     * Whether `requestId` is a collection this orchestrator asked `agentId` for
+     * and is still waiting on. The agent handler consults this before rate
+     * limiting a `fleet.bundle.chunk`: a solicited transfer is exempt, an
+     * unsolicited one is not.
+     */
+    isPendingFor(requestId: string, agentId: string): boolean;
     onError(requestId: string, message: string): void;
     /** Reject every pending request owned by `agentId` (called on its disconnect). */
     rejectAgent(agentId: string, reason: string): void;

package/dist/ws/test-relay-handlers.d.ts

@@ -67,6 +67,8 @@ export interface TestRunStatusPayload {
         jobName: string;
         status: string;
         errorMessage?: string | null;
+        /** Wall-clock job duration once the job has finished; null while it runs. */
+        durationMs?: number | null;
     }>;
     done: boolean;
 }

package/installer-image-digests.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.7.0",
+  "version": "0.8.0",
   "images": {
-    "kici-agent": "sha256:ad6028feb1eda81eb8c1b53490fad8530a0b9137650d436250a8cfd2ec699eed",
-    "kici-orchestrator": "sha256:f2706520bf3b8b196e2613deb8d0530ce4b50cc376261304b6eecee7f433385f"
+    "kici-agent": "sha256:81dbd07842282809140f620eceec60978793e1aea6972297b78933c2f66f34b1",
+    "kici-orchestrator": "sha256:0cc0c914b0ce08cb1f3532073d1c70f18532024f69dceeb3a719f1160a62554f"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kici-dev/orchestrator",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Customer-deployable orchestrator for the KiCI CI/CD stack. Receives webhook events (direct or via Platform relay), matches triggers against the lock file, and dispatches jobs to connected agents.",
   "keywords": [
     "ci",
@@ -89,8 +89,8 @@
     "ws": "^8.21.3",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@kici-dev/shared": "0.7.0",
-    "@kici-dev/engine": "0.7.0"
+    "@kici-dev/engine": "0.8.0",
+    "@kici-dev/shared": "0.8.0"
   },
   "kici": {
     "metrics": {
@@ -105,7 +105,7 @@
     "@types/dockerode": "^4.0.1",
     "@types/ws": "^8.18.1",
     "kysely-ctl": "^0.21.0",
-    "@kici-dev/agent": "0.7.0"
+    "@kici-dev/agent": "0.8.0"
   },
   "scripts": {
     "build": "node ../../scripts/build-service.mjs && tsgo --emitDeclarationOnly",