@kici-dev/orchestrator 0.7.0 → 0.8.0

package/dist/cli.js

@@ -22056,7 +22056,7 @@ init_manifest();
 const ALL_PLATFORMS = AgentPlatform.options;
 /** The orchestrator's own version (single-version invariant) = the packaged agent version. */
 function resolveKiciVersion() {
-	return "0.7.0";
+	return "0.8.0";
 }
 /** Parse the --platform value: default set | single | CSV | `all`. */
 function parsePlatforms(raw) {
@@ -32216,6 +32216,9 @@ var ContainerScalerBackend = class ContainerScalerBackend {
 			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) {
@@ -32289,17 +32292,24 @@ var ContainerScalerBackend = class ContainerScalerBackend {
 				...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.enum["scaler.network"], "configuring network isolation");
 			await container.start({ abortSignal: signal });
+			assertStillTracked();
 			emit(ScalerEventType.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);
@@ -32309,13 +32319,17 @@ var ContainerScalerBackend = class ContainerScalerBackend {
 					error: toErrorMessage(err)
 				});
 			}
+			assertStillTracked();
 			managed.state = "running";
-			managed.backendRef = container.id;
-			this.containerToManaged.set(container.id, managed.id);
 			emit(ScalerEventType.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.enum["scaler.failed"], t ? `${base}\n--- captured output ---\n${t}` : base);
 			const failedIp = this.containerIps.get(managed.id);
@@ -32325,10 +32339,13 @@ var ContainerScalerBackend = class ContainerScalerBackend {
 				} 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;
 		}
 	}
@@ -32365,6 +32382,7 @@ var ContainerScalerBackend = class ContainerScalerBackend {
 			capture.close();
 			this.logCaptures.delete(managedId);
 		}
+		if (!managed.backendRef) return;
 		try {
 			const container = this.docker.getContainer(managed.backendRef);
 			try {
@@ -33025,7 +33043,7 @@ Token vocabulary:
 * where no bundler substituted the constant — the same shape `server.ts` and
 * `standalone.ts` use for `ORCHESTRATOR_VERSION`.
 */
-const CLI_VERSION = "0.7.0";
+const CLI_VERSION = "0.8.0";
 /**
 * Build the kici-admin Commander program with every command group registered.
 * Exported so the surface registry can walk the real command tree without

package/dist/providers/local/lock-file-fetcher.d.ts

@@ -15,6 +15,14 @@ import type { LockFileFetcher, LockFile } from '@kici-dev/engine';
 export declare class LocalLockFileFetcher implements LockFileFetcher {
     private readonly repoBasePath;
     readonly 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.
+     */
+    readonly cacheable: false;
     /**
      * @param repoBasePath - Base directory for the repo(s). When repoIdentifier
      *   starts with 'file://', it is stripped and used as-is. Otherwise

package/dist/scaler/claim-store.d.ts

@@ -34,8 +34,6 @@ export interface ClaimSpec {
     agentId: string;
     /** Exact label set the ephemeral token is authorized for. */
     labels: string[];
-    /** Mandatory (taint) labels the pool gates on, carried for the workflow. */
-    mandatoryLabels: string[];
     /** TTL of the ephemeral agent token minted on claim (seconds). */
     agentTokenTtlSeconds: number;
     /** Orchestrator WS URL the provisioned agent connects back to. */

package/dist/scaler/event-backend.d.ts

@@ -108,12 +108,13 @@ export declare class EventScalerBackend implements ScalerBackend {
      */
     shutdownAll(): Promise<void>;
     /**
-     * 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: LabelSetConfig[], opts?: {
         maxAgents?: number;

package/dist/scaler/manager.d.ts

@@ -1281,10 +1281,25 @@ export declare class ScalerManager {
      */
     getScalerContextForAgent(agentId: string): Record<string, unknown> | undefined;
     /**
-     * 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(): void;
+    /**
+     * 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(): void;
     /**
      * Provision/heal every backend's host prerequisites before spawning starts.
      * Awaits each backend's optional ensureHostReady, catching per-backend so one
@@ -1385,6 +1400,7 @@ export declare class ScalerManager {
      * 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

package/dist/scaler/scaler-state-store.d.ts

@@ -374,6 +374,13 @@ export declare class ScalerStateStore {
  */
 export interface ScalerStateRecovery {
     spawningAgentsRehydrated: number;
+    /**
+     * Spawn rows released during recovery because their backend is local
+     * (container / firecracker / bare-metal): such a spawn cannot outlive the
+     * process that started it, so nothing could ever register against it, and
+     * rehydrating it would hold its reservation until the stale prune.
+     */
+    spawningDropped: number;
     agentJobsRehydrated: number;
     reservationsRehydrated: number;
     /**

package/dist/scaler/types.d.ts

@@ -97,6 +97,16 @@ export interface SpawnContext {
      * single source, and computing them twice is the defect this field closes.
      */
     platformTaints?: readonly string[];
+    /**
+     * The full taint gate the spawned agent is registered under: the pool's
+     * configured `mandatoryLabels` plus every derived platform taint, resolved
+     * by `ScalerManager` for the label set this spawn belongs to — the same set
+     * the durable spawn row carries. A backend publishes it (an event scaler puts
+     * it on the scale-up payload) so a provisioning workflow sees the gate the
+     * agent will actually be held to. A backend must never derive it itself: the
+     * manager is the single source, exactly as for `platformTaints`.
+     */
+    mandatoryLabels?: readonly string[];
 }
 /**
  * Network policy controlling RFC1918 and internet access for agents in this

package/dist/scaler/warm-pool.d.ts

@@ -125,10 +125,12 @@ export declare class WarmPoolManager {
      * 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(): void;
     /**

package/dist/security/identity-link.d.ts

@@ -40,7 +40,7 @@ export interface IdentityLink {
  * the answer is unambiguous; when they disagree there is no way to tell here
  * which provider serves the commit, so this answers undefined rather than
  * naming the wrong account. Undefined is a safe answer at every call site: the
- * attribution is simply omitted, never replaced by the raw subject id.
+ * attribution is omitted, never replaced by the raw subject id.
  */
 export declare function resolveLinkedUsername(identityLinks: IdentityLink[], userId: string): string | undefined;
 /**

package/dist/security/trust-directory-store.d.ts

@@ -64,7 +64,7 @@ import type { Database } from '../db/types.js';
  * What it does not pin: the field *set*. A fourth directory field added to
  * `trustPolicyUpdateSchema` is not picked up here, and `server.ts` hand-builds
  * the value it passes to `upsertFromPlatform`, so nothing would fail — the new
- * field would simply go unpersisted. Adding one means extending this object and
+ * field would go unpersisted. Adding one means extending this object and
  * that literal together.
  */
 export declare const trustDirectorySchema: z.ZodObject<{