@kici-dev/engine 0.1.22 → 0.1.24

package/dist/inputs/extract.d.ts

@@ -0,0 +1,15 @@
+import type { InputDescriptorT, InputsDescriptorMap } from './descriptor.js';
+/** Thrown when a declared dispatch input falls outside the closed Zod subset. */
+export declare class UnsupportedDispatchInputError extends Error {
+    readonly construct: string;
+    readonly key?: string | undefined;
+    constructor(construct: string, key?: string | undefined);
+}
+/**
+ * Walk a Zod schema's `_zod.def`, reject any construct outside the closed
+ * subset, and extract a JSON-safe `InputDescriptor`.
+ */
+export declare function extractInputDescriptor(schema: unknown, key?: string): InputDescriptorT;
+/** Extract a descriptor for every key in a `{ name: ZodSchema }` map. */
+export declare function extractInputsDescriptorMap(map: Record<string, unknown>): InputsDescriptorMap;
+//# sourceMappingURL=extract.d.ts.map

package/dist/inputs/extract.js

@@ -0,0 +1,117 @@
+import "../chunk-BTugEXQM.js";
+//#region src/inputs/extract.ts
+/** Thrown when a declared dispatch input falls outside the closed Zod subset. */
+var UnsupportedDispatchInputError = class extends Error {
+	construct;
+	key;
+	constructor(construct, key) {
+		super(`Unsupported dispatch input${key ? ` "${key}"` : ""}: ${construct}. Allowed: z.string/number/boolean/enum/literal with .optional/.nullable/.default/.min/.max/.regex/.int.`);
+		this.construct = construct;
+		this.key = key;
+		this.name = "UnsupportedDispatchInputError";
+	}
+};
+const defOf = (s) => s?._zod?.def;
+const checkDefOf = (c) => c?._zod?.def;
+/** Pull string/number checks (min/max/int/regex) into descriptor fields. */
+function applyChecks(d, checks, key) {
+	for (const c of checks ?? []) {
+		const cd = checkDefOf(c);
+		switch (cd?.check) {
+			case "greater_than":
+				d.min = Number(cd.value);
+				break;
+			case "less_than":
+				d.max = Number(cd.value);
+				break;
+			case "min_length":
+				d.min = Number(cd.minimum);
+				break;
+			case "max_length":
+				d.max = Number(cd.maximum);
+				break;
+			case "string_format":
+				if (cd.format === "regex" && cd.pattern) d.pattern = String(typeof cd.pattern === "object" ? cd.pattern.source ?? cd.pattern : cd.pattern);
+				else throw new UnsupportedDispatchInputError(`string format:${cd.format ?? "unknown"}`, key);
+				break;
+			case "number_format":
+				if (cd.format === "safeint" || cd.format === "int") d.type = "integer";
+				else throw new UnsupportedDispatchInputError(`number format:${cd.format ?? "unknown"}`, key);
+				break;
+			default: throw new UnsupportedDispatchInputError(`check:${cd?.check ?? "unknown"}`, key);
+		}
+	}
+}
+/**
+* Walk a Zod schema's `_zod.def`, reject any construct outside the closed
+* subset, and extract a JSON-safe `InputDescriptor`.
+*/
+function extractInputDescriptor(schema, key) {
+	let cur = schema;
+	let optional = false;
+	let nullable = false;
+	let hasDefault = false;
+	let defaultValue;
+	for (;;) {
+		const d = defOf(cur);
+		if (!d) throw new UnsupportedDispatchInputError("non-zod value", key);
+		if (d.type === "optional") {
+			optional = true;
+			cur = d.innerType;
+			continue;
+		}
+		if (d.type === "nullable") {
+			nullable = true;
+			cur = d.innerType;
+			continue;
+		}
+		if (d.type === "default") {
+			hasDefault = true;
+			defaultValue = typeof d.defaultValue === "function" ? d.defaultValue() : d.defaultValue;
+			cur = d.innerType;
+			continue;
+		}
+		break;
+	}
+	const d = defOf(cur);
+	if (!d) throw new UnsupportedDispatchInputError("non-zod value", key);
+	const out = {
+		type: "string",
+		optional,
+		nullable
+	};
+	if (hasDefault) out.default = defaultValue;
+	switch (d.type) {
+		case "string":
+			out.type = "string";
+			applyChecks(out, d.checks, key);
+			break;
+		case "number":
+			out.type = "number";
+			applyChecks(out, d.checks, key);
+			break;
+		case "boolean":
+			out.type = "boolean";
+			break;
+		case "enum":
+			out.type = "enum";
+			out.values = Object.values(d.entries ?? {});
+			break;
+		case "literal":
+			out.type = "literal";
+			out.literal = d.values?.[0] ?? d.value;
+			break;
+		default: throw new UnsupportedDispatchInputError(`z.${d.type}`, key);
+	}
+	return out;
+}
+/** Extract a descriptor for every key in a `{ name: ZodSchema }` map. */
+function extractInputsDescriptorMap(map) {
+	const out = {};
+	for (const [k, v] of Object.entries(map)) out[k] = extractInputDescriptor(v, k);
+	return out;
+}
+//#endregion
+export { UnsupportedDispatchInputError, extractInputDescriptor, extractInputsDescriptorMap };
+
+//# sourceMappingURL=extract.js.map

package/dist/inputs/index.d.ts

@@ -0,0 +1,6 @@
+export * from './descriptor.js';
+export * from './extract.js';
+export * from './build.js';
+export * from './coerce.js';
+export * from './schedule.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/inputs/index.js

@@ -0,0 +1,7 @@
+import "../chunk-BTugEXQM.js";
+import { DispatchInputType, InputDescriptor, InputsDescriptorMapSchema } from "./descriptor.js";
+import { UnsupportedDispatchInputError, extractInputDescriptor, extractInputsDescriptorMap } from "./extract.js";
+import { buildZodFromDescriptor, buildZodObjectFromMap } from "./build.js";
+import { DispatchInputError, coerceDispatchInputs, parseInputPairs } from "./coerce.js";
+import { assertScheduleInputsSatisfiable, isInputSatisfiableFromDefaults, resolveScheduleInputs } from "./schedule.js";
+export { DispatchInputError, DispatchInputType, InputDescriptor, InputsDescriptorMapSchema, UnsupportedDispatchInputError, assertScheduleInputsSatisfiable, buildZodFromDescriptor, buildZodObjectFromMap, coerceDispatchInputs, extractInputDescriptor, extractInputsDescriptorMap, isInputSatisfiableFromDefaults, parseInputPairs, resolveScheduleInputs };

package/dist/inputs/schedule.d.ts

@@ -0,0 +1,19 @@
+import type { InputDescriptorT, InputsDescriptorMap } from './descriptor.js';
+/**
+ * A schedule input resolves with no operator value, so it must be satisfiable
+ * from an empty value set: it either declares a default or is optional. Bare
+ * required and bare nullable inputs are not satisfiable (Zod still requires the
+ * key to be present).
+ */
+export declare function isInputSatisfiableFromDefaults(d: InputDescriptorT): boolean;
+/** Throw naming the first schedule input that can never resolve on a fire. */
+export declare function assertScheduleInputsSatisfiable(map: InputsDescriptorMap): void;
+/**
+ * Resolve defaults-only schedule inputs (no operator pairs). Returns undefined
+ * when the trigger declares no inputs or nothing resolves to a value. Throws
+ * `DispatchInputError` on an invalid descriptor — compile-time validation
+ * (`assertScheduleInputsSatisfiable`) makes this unreachable for a
+ * freshly-compiled lock; no silent fallback.
+ */
+export declare function resolveScheduleInputs(map: InputsDescriptorMap | undefined): Record<string, unknown> | undefined;
+//# sourceMappingURL=schedule.d.ts.map

package/dist/inputs/schedule.js

@@ -0,0 +1,33 @@
+import "../chunk-BTugEXQM.js";
+import { coerceDispatchInputs } from "./coerce.js";
+//#region src/inputs/schedule.ts
+/**
+* A schedule input resolves with no operator value, so it must be satisfiable
+* from an empty value set: it either declares a default or is optional. Bare
+* required and bare nullable inputs are not satisfiable (Zod still requires the
+* key to be present).
+*/
+function isInputSatisfiableFromDefaults(d) {
+	return d.default !== void 0 || d.optional === true;
+}
+/** Throw naming the first schedule input that can never resolve on a fire. */
+function assertScheduleInputsSatisfiable(map) {
+	for (const [name, d] of Object.entries(map)) if (!isInputSatisfiableFromDefaults(d)) throw new Error(`schedule input "${name}" must declare a .default() or be .optional() — schedule triggers fire with no operator input`);
+}
+/**
+* Resolve defaults-only schedule inputs (no operator pairs). Returns undefined
+* when the trigger declares no inputs or nothing resolves to a value. Throws
+* `DispatchInputError` on an invalid descriptor — compile-time validation
+* (`assertScheduleInputsSatisfiable`) makes this unreachable for a
+* freshly-compiled lock; no silent fallback.
+*/
+function resolveScheduleInputs(map) {
+	if (!map || Object.keys(map).length === 0) return void 0;
+	const r = coerceDispatchInputs({}, map);
+	if ("error" in r) throw r.error;
+	return Object.keys(r.values).length > 0 ? r.values : void 0;
+}
+//#endregion
+export { assertScheduleInputsSatisfiable, isInputSatisfiableFromDefaults, resolveScheduleInputs };
+
+//# sourceMappingURL=schedule.js.map

package/dist/labels/compile.d.ts

@@ -15,9 +15,12 @@ export declare function assertSafeRegex(source: string, flags: string, ctx: stri
  */
 export declare function toLabelMatcher(el: string | RegExp, ctx: string): LabelMatcher;
 export type SelectorEl = string | RegExp;
+/** Single-agent selection policy when multiple agents match a `runsOn` selector. */
+export type RunsOnPickInput = 'deterministic' | 'any';
 export type RunsOnAuthorInput = SelectorEl | readonly SelectorEl[] | {
     labels: SelectorEl | readonly SelectorEl[];
     exclude?: SelectorEl | readonly SelectorEl[];
+    pick?: RunsOnPickInput;
 };
 export type RunsOnAllAuthorInput = string | RegExp | readonly SelectorEl[] | {
     include: readonly {
@@ -30,6 +33,12 @@ export declare function normalizeRunsOnToMatchers(runsOn: RunsOnAuthorInput, ctx
     include: LabelMatcher[];
     exclude: LabelMatcher[];
 };
+/**
+ * Resolve a `runsOn` author value's single-agent selection policy, defaulting to
+ * `'deterministic'` for every form (string / array shorthand inherit the default
+ * after normalization; the selector object's explicit `pick` wins).
+ */
+export declare function runsOnPickFromInput(runsOn: RunsOnAuthorInput): RunsOnPickInput;
 /** Normalize a `runsOnAll` author value into include groups + exclude matchers. */
 export declare function normalizeRunsOnAllToMatchers(input: RunsOnAllAuthorInput, ctx: string): {
     include: LabelMatcher[][];

package/dist/labels/compile.js

@@ -59,6 +59,15 @@ function normalizeRunsOnToMatchers(runsOn, ctx) {
 		exclude: sel.exclude ? asArray(sel.exclude).map((e) => toLabelMatcher(e, ctx)) : []
 	};
 }
+/**
+* Resolve a `runsOn` author value's single-agent selection policy, defaulting to
+* `'deterministic'` for every form (string / array shorthand inherit the default
+* after normalization; the selector object's explicit `pick` wins).
+*/
+function runsOnPickFromInput(runsOn) {
+	if (typeof runsOn === "string" || runsOn instanceof RegExp || Array.isArray(runsOn)) return "deterministic";
+	return runsOn.pick ?? "deterministic";
+}
 /** Normalize a `runsOnAll` author value into include groups + exclude matchers. */
 function normalizeRunsOnAllToMatchers(input, ctx) {
 	if (typeof input === "string" || input instanceof RegExp) return {
@@ -86,6 +95,6 @@ function assertMatchersSafe(matchers, ctx) {
 	for (const m of matchers) if (m.kind === "regex") assertSafeRegex(m.source, m.flags, ctx);
 }
 //#endregion
-export { assertMatchersSafe, assertSafeRegex, normalizeRunsOnAllToMatchers, normalizeRunsOnToMatchers, toLabelMatcher };
+export { assertMatchersSafe, assertSafeRegex, normalizeRunsOnAllToMatchers, normalizeRunsOnToMatchers, runsOnPickFromInput, toLabelMatcher };
 
 //# sourceMappingURL=compile.js.map

package/dist/labels.d.ts

@@ -79,6 +79,35 @@ export declare const KNOWN_ROLES: readonly ["builder", "init-runner"];
 export type AgentRole = (typeof KNOWN_ROLES)[number];
 /** Reserved label prefix — labels starting with this are system-managed. */
 export declare const RESERVED_LABEL_PREFIX = "kici:";
+/**
+ * Capability label prefix — `kici:capability:<name>` grants an agent a
+ * privileged capability beyond plain execution. Distinct from `kici:role:`
+ * (which gates which internal job kinds an agent runs).
+ */
+export declare const CAPABILITY_LABEL_PREFIX = "kici:capability:";
+/** Build a `kici:capability:<name>` label. */
+export declare function capabilityLabel(name: string): string;
+/**
+ * The `ssh-transport` capability: an agent holding this may run the bootstrap
+ * bring-up (`ctx.kici.bootstrap.ensureInitRunner` / `preBootSend`) — i.e. SSH
+ * to a declared-but-un-agented host. The orchestrator refuses to run a
+ * bring-up on an agent that lacks it. Prod-critical: such an agent custodies
+ * the bootstrap SSH key.
+ */
+export declare const SSH_TRANSPORT_CAPABILITY = "kici:capability:ssh-transport";
+/**
+ * The `kici:init` lifecycle label carried by a temporary init-runner agent
+ * brought up on a fresh box for bootstrap. Marks it as ephemeral + privileged;
+ * it dies on reboot and is reaped. Distinct from `kici:role:init-runner`
+ * (which is the per-job `__init__` workspace-init capability — a different
+ * concept entirely).
+ */
+export declare const INIT_LABEL = "kici:init";
+/**
+ * The `kici:privileged:root` label a bootstrap init-runner carries — it runs
+ * as root in the target's rescue env to partition / format / install.
+ */
+export declare const PRIVILEGED_ROOT_LABEL = "kici:privileged:root";
 /** Role label prefix — used to generate role-specific labels. */
 export declare const ROLE_LABEL_PREFIX = "kici:role:";
 /**

package/dist/labels.js

@@ -116,6 +116,37 @@ function normalizeRunsOn(runsOn) {
 const KNOWN_ROLES = ["builder", "init-runner"];
 /** Reserved label prefix — labels starting with this are system-managed. */
 const RESERVED_LABEL_PREFIX = "kici:";
+/**
+* Capability label prefix — `kici:capability:<name>` grants an agent a
+* privileged capability beyond plain execution. Distinct from `kici:role:`
+* (which gates which internal job kinds an agent runs).
+*/
+const CAPABILITY_LABEL_PREFIX = "kici:capability:";
+/** Build a `kici:capability:<name>` label. */
+function capabilityLabel(name) {
+	return `${CAPABILITY_LABEL_PREFIX}${name}`;
+}
+/**
+* The `ssh-transport` capability: an agent holding this may run the bootstrap
+* bring-up (`ctx.kici.bootstrap.ensureInitRunner` / `preBootSend`) — i.e. SSH
+* to a declared-but-un-agented host. The orchestrator refuses to run a
+* bring-up on an agent that lacks it. Prod-critical: such an agent custodies
+* the bootstrap SSH key.
+*/
+const SSH_TRANSPORT_CAPABILITY = "kici:capability:ssh-transport";
+/**
+* The `kici:init` lifecycle label carried by a temporary init-runner agent
+* brought up on a fresh box for bootstrap. Marks it as ephemeral + privileged;
+* it dies on reboot and is reaped. Distinct from `kici:role:init-runner`
+* (which is the per-job `__init__` workspace-init capability — a different
+* concept entirely).
+*/
+const INIT_LABEL = "kici:init";
+/**
+* The `kici:privileged:root` label a bootstrap init-runner carries — it runs
+* as root in the target's rescue env to partition / format / install.
+*/
+const PRIVILEGED_ROOT_LABEL = "kici:privileged:root";
 /** Role label prefix — used to generate role-specific labels. */
 const ROLE_LABEL_PREFIX = "kici:role:";
 /**
@@ -203,6 +234,6 @@ function separateLabels(labels) {
 	};
 }
 //#endregion
-export { HOST_LABEL_PREFIX, KNOWN_ROLES, RESERVED_LABEL_PREFIX, ROLE_LABEL_PREFIX, SELF_REPORTED_LABEL_PREFIXES, agentTypeLabel, deriveOsArchLabels, hostLabel, isAutoLabel, isSelfReportedLabel, mergeAutoLabels, normalizeRunsOn, parseHostLabel, resolveRoleLabels, roleToLabel, scalerAgentLabels, scalerLabel, separateLabels, validateNoReservedLabels };
+export { CAPABILITY_LABEL_PREFIX, HOST_LABEL_PREFIX, INIT_LABEL, KNOWN_ROLES, PRIVILEGED_ROOT_LABEL, RESERVED_LABEL_PREFIX, ROLE_LABEL_PREFIX, SELF_REPORTED_LABEL_PREFIXES, SSH_TRANSPORT_CAPABILITY, agentTypeLabel, capabilityLabel, deriveOsArchLabels, hostLabel, isAutoLabel, isSelfReportedLabel, mergeAutoLabels, normalizeRunsOn, parseHostLabel, resolveRoleLabels, roleToLabel, scalerAgentLabels, scalerLabel, separateLabels, validateNoReservedLabels };
 
 //# sourceMappingURL=labels.js.map

package/dist/mcp/tool-schemas.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Zod argument schemas for the KiCI MCP tools.
+ *
+ * Browser-safe (zod only) and shared between the Platform-hosted developer MCP
+ * and the sibling orchestrator-side admin MCP so both expose an identical tool
+ * argument contract. Each export is a Zod *raw shape* (a plain object of Zod
+ * fields) so it can be passed directly as an MCP tool `inputSchema`.
+ */
+import { z } from 'zod';
+export declare const listRunsToolSchema: {
+    orgId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+};
+export declare const getRunToolSchema: {
+    orgId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
+};
+export declare const getStepLogsToolSchema: {
+    orgId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
+    jobId: z.ZodString;
+    stepIndex: z.ZodNumber;
+};
+export declare const listWorkflowsToolSchema: {
+    orgId: z.ZodOptional<z.ZodString>;
+};
+export declare const cancelRunToolSchema: {
+    orgId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
+    force: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const rerunRunToolSchema: {
+    orgId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
+};
+export declare const triggerRunToolSchema: {
+    orgId: z.ZodOptional<z.ZodString>;
+    registrationId: z.ZodString;
+};
+//# sourceMappingURL=tool-schemas.d.ts.map

package/dist/mcp/tool-schemas.js

@@ -0,0 +1,49 @@
+import "../chunk-BTugEXQM.js";
+import { z } from "zod";
+//#region src/mcp/tool-schemas.ts
+/**
+* Zod argument schemas for the KiCI MCP tools.
+*
+* Browser-safe (zod only) and shared between the Platform-hosted developer MCP
+* and the sibling orchestrator-side admin MCP so both expose an identical tool
+* argument contract. Each export is a Zod *raw shape* (a plain object of Zod
+* fields) so it can be passed directly as an MCP tool `inputSchema`.
+*/
+/**
+* Optional organization id. When the calling user belongs to exactly one org
+* it is resolved automatically; pass it explicitly when a member of several.
+*/
+const orgIdArg = z.string().min(1).optional().describe("Organization id. Optional when you belong to exactly one organization.");
+const listRunsToolSchema = {
+	orgId: orgIdArg,
+	status: z.string().optional().describe("Filter by run status (e.g. success, failed, running)."),
+	limit: z.number().int().min(1).max(100).optional().describe("Maximum number of runs to return (default 20).")
+};
+const getRunToolSchema = {
+	orgId: orgIdArg,
+	runId: z.string().min(1).describe("The run id to fetch.")
+};
+const getStepLogsToolSchema = {
+	orgId: orgIdArg,
+	runId: z.string().min(1).describe("The run id."),
+	jobId: z.string().min(1).describe("The job id within the run."),
+	stepIndex: z.number().int().min(0).describe("Zero-based step index within the job.")
+};
+const listWorkflowsToolSchema = { orgId: orgIdArg };
+const cancelRunToolSchema = {
+	orgId: orgIdArg,
+	runId: z.string().min(1).describe("The run id to cancel."),
+	force: z.boolean().optional().describe("Force-cancel (SIGKILL, skip cleanup hooks).")
+};
+const rerunRunToolSchema = {
+	orgId: orgIdArg,
+	runId: z.string().min(1).describe("The run id to re-run.")
+};
+const triggerRunToolSchema = {
+	orgId: orgIdArg,
+	registrationId: z.string().min(1).describe("The workflow registration id to trigger.")
+};
+//#endregion
+export { cancelRunToolSchema, getRunToolSchema, getStepLogsToolSchema, listRunsToolSchema, listWorkflowsToolSchema, rerunRunToolSchema, triggerRunToolSchema };
+
+//# sourceMappingURL=tool-schemas.js.map

package/dist/metrics/catalog-policy.d.ts

@@ -52,6 +52,13 @@ export declare const OVERFLOW_LABEL_VALUE = "__overflow__";
  * so they are valid push payloads alongside `kici_orch_*`.
  */
 export declare const ORCH_PUSHED_METRIC_NAMES: ReadonlySet<MetricName>;
+/**
+ * Closed enum of scaler-backend TYPE values the orchestrator's own
+ * resource-usage gauges carry on their `scalerType` rollup label.
+ * `__global__` is the orchestrator-wide rollup row; the other four match
+ * `AGENT_SCALER_VALUES`. Exported so the policy tests can assert against it.
+ */
+export declare const ORCH_SCALER_VALUES: readonly ["__global__", "stateful", "container", "firecracker", "bare-metal"];
 /**
  * Per-metric, per-label value policy. Missing entries (or missing label
  * keys within an entry) mean "no value-level constraint" — the label key

package/dist/metrics/catalog-policy.js

@@ -1,4 +1,5 @@
 import "../chunk-BTugEXQM.js";
+import { ExecutionRunStatus } from "../protocol/messages/execution-status.js";
 import { MetricNames, MetricService } from "./metric-catalog.generated.js";
 //#region src/metrics/catalog-policy.ts
 /**
@@ -48,9 +49,10 @@ const AGENT_SCALER_VALUES = [
 	"bare-metal"
 ];
 /**
-* Closed enum of scaler values the orchestrator's own resource-usage
-* gauges emit. `__global__` is the orchestrator-wide rollup row; the
-* other four match `AGENT_SCALER_VALUES`.
+* Closed enum of scaler-backend TYPE values the orchestrator's own
+* resource-usage gauges carry on their `scalerType` rollup label.
+* `__global__` is the orchestrator-wide rollup row; the other four match
+* `AGENT_SCALER_VALUES`. Exported so the policy tests can assert against it.
 */
 const ORCH_SCALER_VALUES = ["__global__", ...AGENT_SCALER_VALUES];
 /** Closed enum of the five scheduled jobs the orchestrator runs (mirrors `OrchestratorScheduledJobName`). */
@@ -94,12 +96,7 @@ const METRIC_LABEL_POLICY = {
 		"handled",
 		"dispatched"
 	] } },
-	kici_orch_executions_total: { status: { values: [
-		"running",
-		"success",
-		"failed",
-		"cancelled"
-	] } },
+	kici_orch_executions_total: { status: { values: ExecutionRunStatus.options } },
 	kici_orch_steps_total: { status: { values: [
 		"running",
 		"success",
@@ -130,11 +127,13 @@ const METRIC_LABEL_POLICY = {
 		] }
 	},
 	kici_orch_scaler_cpus_used: {
-		scaler: { values: ORCH_SCALER_VALUES },
+		scaler: { maxUniqueValues: 50 },
+		scalerType: { values: ORCH_SCALER_VALUES },
 		machinePool: { maxUniqueValues: 50 }
 	},
 	kici_orch_scaler_memory_bytes_used: {
-		scaler: { values: ORCH_SCALER_VALUES },
+		scaler: { maxUniqueValues: 50 },
+		scalerType: { values: ORCH_SCALER_VALUES },
 		machinePool: { maxUniqueValues: 50 }
 	},
 	kici_orch_install_secrets_decisions_total: {
@@ -278,6 +277,6 @@ const METRIC_LABEL_POLICY = {
 	}
 };
 //#endregion
-export { METRIC_LABEL_POLICY, ORCH_PUSHED_METRIC_NAMES, OVERFLOW_LABEL_VALUE };
+export { METRIC_LABEL_POLICY, ORCH_PUSHED_METRIC_NAMES, ORCH_SCALER_VALUES, OVERFLOW_LABEL_VALUE };
 
 //# sourceMappingURL=catalog-policy.js.map

package/dist/metrics/metric-catalog.generated.d.ts

@@ -86,13 +86,17 @@ export declare const MetricNames: {
     readonly KICI_PLATFORM_LOG_LINES_FORWARDED_TOTAL: "kici_platform_log_lines_forwarded_total";
     readonly KICI_PLATFORM_METRICS_QUERY_RATE_LIMITED_TOTAL: "kici_platform_metrics_query_rate_limited_total";
     readonly KICI_PLATFORM_MIMIR_RELAY_ERRORS_TOTAL: "kici_platform_mimir_relay_errors_total";
+    readonly KICI_PLATFORM_NOTIFICATIONS_DELIVERED_TOTAL: "kici_platform_notifications_delivered_total";
+    readonly KICI_PLATFORM_NOTIFICATIONS_SUPPRESSED_TOTAL: "kici_platform_notifications_suppressed_total";
     readonly KICI_PLATFORM_ORCH_METRICS_FILTERED_TOTAL: "kici_platform_orch_metrics_filtered_total";
     readonly KICI_PLATFORM_ORPHAN_CONNECTIONS_SWEPT_TOTAL: "kici_platform_orphan_connections_swept_total";
     readonly KICI_PLATFORM_PG_POOL_CLIENT_ERRORS_TOTAL: "kici_platform_pg_pool_client_errors_total";
+    readonly KICI_PLATFORM_PLAN_CAP_CHECK_ERRORS_TOTAL: "kici_platform_plan_cap_check_errors_total";
     readonly KICI_PLATFORM_STALE_ORCHESTRATORS_TOTAL: "kici_platform_stale_orchestrators_total";
     readonly KICI_PLATFORM_STALE_PLATFORM_CONNECTIONS_EVICTED_TOTAL: "kici_platform_stale_platform_connections_evicted_total";
     readonly KICI_PLATFORM_STALE_RUNS_FAILED_TOTAL: "kici_platform_stale_runs_failed_total";
     readonly KICI_PLATFORM_STEP_STATUS_FORWARDS_TOTAL: "kici_platform_step_status_forwards_total";
+    readonly KICI_PLATFORM_WS_ORG_RATE_LIMITED_TOTAL: "kici_platform_ws_org_rate_limited_total";
     readonly KICI_REGISTRATIONS_TOTAL: "kici_registrations_total";
     readonly KICI_UNIVERSAL_GIT_REGISTRATION_ERRORS_TOTAL: "kici_universal_git_registration_errors_total";
     readonly KICI_USER_REGISTRATION_NOTIFY_TOTAL: "kici_user_registration_notify_total";
@@ -183,8 +187,8 @@ export declare const MetricLabels: {
     readonly KICI_ORCH_LOG_CHUNKS_RECEIVED_TOTAL: readonly [];
     readonly KICI_ORCH_PG_POOL_CLIENT_ERRORS_TOTAL: readonly ["source"];
     readonly KICI_ORCH_SCALER_CONFIG_RELOADS_TOTAL: readonly ["result"];
-    readonly KICI_ORCH_SCALER_CPUS_USED: readonly ["scaler", "machinePool"];
-    readonly KICI_ORCH_SCALER_MEMORY_BYTES_USED: readonly ["scaler", "machinePool"];
+    readonly KICI_ORCH_SCALER_CPUS_USED: readonly ["scaler", "scalerType", "machinePool"];
+    readonly KICI_ORCH_SCALER_MEMORY_BYTES_USED: readonly ["scaler", "scalerType", "machinePool"];
     readonly KICI_ORCH_SCALER_SPAWN_FAILURES_TOTAL: readonly ["backend", "bound"];
     readonly KICI_ORCH_SCALER_SPAWN_REFUSALS_TOTAL: readonly [];
     readonly KICI_ORCH_SOURCE_CACHE_HITS_TOTAL: readonly [];
@@ -222,13 +226,17 @@ export declare const MetricLabels: {
     readonly KICI_PLATFORM_LOG_LINES_FORWARDED_TOTAL: readonly [];
     readonly KICI_PLATFORM_METRICS_QUERY_RATE_LIMITED_TOTAL: readonly ["org_id"];
     readonly KICI_PLATFORM_MIMIR_RELAY_ERRORS_TOTAL: readonly ["reason"];
+    readonly KICI_PLATFORM_NOTIFICATIONS_DELIVERED_TOTAL: readonly ["channel_type", "result"];
+    readonly KICI_PLATFORM_NOTIFICATIONS_SUPPRESSED_TOTAL: readonly ["org_id"];
     readonly KICI_PLATFORM_ORCH_METRICS_FILTERED_TOTAL: readonly ["reason", "metric"];
     readonly KICI_PLATFORM_ORPHAN_CONNECTIONS_SWEPT_TOTAL: readonly [];
     readonly KICI_PLATFORM_PG_POOL_CLIENT_ERRORS_TOTAL: readonly ["source"];
+    readonly KICI_PLATFORM_PLAN_CAP_CHECK_ERRORS_TOTAL: readonly ["org_id"];
     readonly KICI_PLATFORM_STALE_ORCHESTRATORS_TOTAL: readonly [];
     readonly KICI_PLATFORM_STALE_PLATFORM_CONNECTIONS_EVICTED_TOTAL: readonly ["org_id"];
     readonly KICI_PLATFORM_STALE_RUNS_FAILED_TOTAL: readonly [];
     readonly KICI_PLATFORM_STEP_STATUS_FORWARDS_TOTAL: readonly ["state"];
+    readonly KICI_PLATFORM_WS_ORG_RATE_LIMITED_TOTAL: readonly ["org_id"];
     readonly KICI_REGISTRATIONS_TOTAL: readonly [];
     readonly KICI_UNIVERSAL_GIT_REGISTRATION_ERRORS_TOTAL: readonly ["reason"];
     readonly KICI_USER_REGISTRATION_NOTIFY_TOTAL: readonly ["result"];
@@ -357,13 +365,17 @@ export declare const MetricKind: {
     readonly KICI_PLATFORM_LOG_LINES_FORWARDED_TOTAL: "counter";
     readonly KICI_PLATFORM_METRICS_QUERY_RATE_LIMITED_TOTAL: "counter";
     readonly KICI_PLATFORM_MIMIR_RELAY_ERRORS_TOTAL: "counter";
+    readonly KICI_PLATFORM_NOTIFICATIONS_DELIVERED_TOTAL: "counter";
+    readonly KICI_PLATFORM_NOTIFICATIONS_SUPPRESSED_TOTAL: "counter";
     readonly KICI_PLATFORM_ORCH_METRICS_FILTERED_TOTAL: "counter";
     readonly KICI_PLATFORM_ORPHAN_CONNECTIONS_SWEPT_TOTAL: "counter";
     readonly KICI_PLATFORM_PG_POOL_CLIENT_ERRORS_TOTAL: "counter";
+    readonly KICI_PLATFORM_PLAN_CAP_CHECK_ERRORS_TOTAL: "counter";
     readonly KICI_PLATFORM_STALE_ORCHESTRATORS_TOTAL: "counter";
     readonly KICI_PLATFORM_STALE_PLATFORM_CONNECTIONS_EVICTED_TOTAL: "counter";
     readonly KICI_PLATFORM_STALE_RUNS_FAILED_TOTAL: "counter";
     readonly KICI_PLATFORM_STEP_STATUS_FORWARDS_TOTAL: "counter";
+    readonly KICI_PLATFORM_WS_ORG_RATE_LIMITED_TOTAL: "counter";
     readonly KICI_REGISTRATIONS_TOTAL: "counter";
     readonly KICI_UNIVERSAL_GIT_REGISTRATION_ERRORS_TOTAL: "counter";
     readonly KICI_USER_REGISTRATION_NOTIFY_TOTAL: "counter";
@@ -492,13 +504,17 @@ export declare const MetricDescription: {
     readonly KICI_PLATFORM_LOG_LINES_FORWARDED_TOTAL: "Total log lines forwarded from orchestrators";
     readonly KICI_PLATFORM_METRICS_QUERY_RATE_LIMITED_TOTAL: "Total dashboard metric-query requests rate-limited (429).";
     readonly KICI_PLATFORM_MIMIR_RELAY_ERRORS_TOTAL: "Total Mimir push-relay errors (Platform-embedded metrics). Labels: reason.";
+    readonly KICI_PLATFORM_NOTIFICATIONS_DELIVERED_TOTAL: "Notification delivery attempts that reached a terminal outcome";
+    readonly KICI_PLATFORM_NOTIFICATIONS_SUPPRESSED_TOTAL: "Run-terminal notifications suppressed by the per-org notification quota";
     readonly KICI_PLATFORM_ORCH_METRICS_FILTERED_TOTAL: "Orchestrator-pushed metric data points dropped or rewritten by the catalog allow-list. Labels: reason, metric.";
     readonly KICI_PLATFORM_ORPHAN_CONNECTIONS_SWEPT_TOTAL: "Total orphan connections swept from platform_connections";
     readonly KICI_PLATFORM_PG_POOL_CLIENT_ERRORS_TOTAL: "Total pg connection errors absorbed without a process restart";
+    readonly KICI_PLATFORM_PLAN_CAP_CHECK_ERRORS_TOTAL: "WS connection rejected because the plan-limit check errored (fail-closed)";
     readonly KICI_PLATFORM_STALE_ORCHESTRATORS_TOTAL: "Total orchestrators detected as permanently disconnected";
     readonly KICI_PLATFORM_STALE_PLATFORM_CONNECTIONS_EVICTED_TOTAL: "platform_connections rows evicted by source.register DB dedup (same-instance reconnect path)";
     readonly KICI_PLATFORM_STALE_RUNS_FAILED_TOTAL: "Total execution runs failed due to orchestrator staleness";
     readonly KICI_PLATFORM_STEP_STATUS_FORWARDS_TOTAL: "Total step status forwards received";
+    readonly KICI_PLATFORM_WS_ORG_RATE_LIMITED_TOTAL: "Inbound orchestrator messages dropped by the per-org aggregate WS rate limit";
     readonly KICI_REGISTRATIONS_TOTAL: "Total user registrations (new personal orgs created on first login)";
     readonly KICI_UNIVERSAL_GIT_REGISTRATION_ERRORS_TOTAL: "Errors encountered while registering universal-git provider bundles";
     readonly KICI_USER_REGISTRATION_NOTIFY_TOTAL: "New-user Telegram notifications by result (sent|failed)";
@@ -634,13 +650,17 @@ export declare const MetricService: {
     readonly KICI_PLATFORM_LOG_LINES_FORWARDED_TOTAL: "platform";
     readonly KICI_PLATFORM_METRICS_QUERY_RATE_LIMITED_TOTAL: "platform";
     readonly KICI_PLATFORM_MIMIR_RELAY_ERRORS_TOTAL: "platform";
+    readonly KICI_PLATFORM_NOTIFICATIONS_DELIVERED_TOTAL: "platform";
+    readonly KICI_PLATFORM_NOTIFICATIONS_SUPPRESSED_TOTAL: "platform";
     readonly KICI_PLATFORM_ORCH_METRICS_FILTERED_TOTAL: "platform";
     readonly KICI_PLATFORM_ORPHAN_CONNECTIONS_SWEPT_TOTAL: "platform";
     readonly KICI_PLATFORM_PG_POOL_CLIENT_ERRORS_TOTAL: "platform";
+    readonly KICI_PLATFORM_PLAN_CAP_CHECK_ERRORS_TOTAL: "platform";
     readonly KICI_PLATFORM_STALE_ORCHESTRATORS_TOTAL: "platform";
     readonly KICI_PLATFORM_STALE_PLATFORM_CONNECTIONS_EVICTED_TOTAL: "platform";
     readonly KICI_PLATFORM_STALE_RUNS_FAILED_TOTAL: "platform";
     readonly KICI_PLATFORM_STEP_STATUS_FORWARDS_TOTAL: "platform";
+    readonly KICI_PLATFORM_WS_ORG_RATE_LIMITED_TOTAL: "platform";
     readonly KICI_REGISTRATIONS_TOTAL: "platform";
     readonly KICI_UNIVERSAL_GIT_REGISTRATION_ERRORS_TOTAL: "orchestrator";
     readonly KICI_USER_REGISTRATION_NOTIFY_TOTAL: "platform";