@kici-dev/engine 0.1.26 → 0.2.0

package/dist/context/scope-resolver.d.ts

@@ -0,0 +1,79 @@
+import type { ContextBinding, ScopedSecret } from './types.js';
+import { type HostFacts } from './host-match.js';
+export type { HostFacts } from './host-match.js';
+/**
+ * Check whether a scope string matches a pattern.
+ *
+ * Supports exact match and glob patterns (via picomatch).
+ * Scope paths use '/' as separator (e.g., 'aws/prod/db').
+ *
+ * For prefixed scopes (e.g., 'pg:aws/prod'), the pattern may be prefixed too
+ * (e.g., 'pg:**'). In this case, the backend prefix must match exactly and
+ * the path portion is matched separately against the glob. This is needed
+ * because picomatch's '**' requires '/' separators — 'pg:**' wouldn't match
+ * 'pg:aws/prod' without splitting on the colon.
+ */
+export declare function matchScopePattern(scope: string, pattern: string): boolean;
+/**
+ * Strip the backend prefix from a scope string.
+ * Prefixed scopes have the form "backendName:path" (e.g., "pg:aws/prod").
+ * Returns the path after the first colon, or the full scope if no prefix.
+ */
+export declare function stripScopePrefix(scope: string): string;
+/** The winning scoped secret for a key, with the precedence tuple that selected it. */
+export interface ResolvedSecretCandidate {
+    secret: ScopedSecret;
+    scopeDepth: number;
+    hostSpec: number;
+}
+/**
+ * Resolve the winning secret per key by matching bindings against scoped secrets,
+ * applying the host gate and `(host specificity, scope depth)` precedence — WITHOUT
+ * decrypting, keeping this module crypto-free. This is the single source of truth for
+ * scope precedence; `resolveSecretsForContext` delegates to it and adds the decrypt step.
+ *
+ * Takes already-filtered bindings (for the target context). For each binding, finds
+ * secrets whose (substituted) scope matches the binding's scopePattern via picomatch.
+ * When multiple scopes provide the same key, precedence is the tuple
+ * `(host specificity, scope depth)` — a per-host binding (exact host) overrides a
+ * fleet-wide one, then longest scope path wins. Scope depth is computed AFTER stripping
+ * the backend prefix.
+ *
+ * When `hostFacts` is supplied (a fan-out child's identity), each binding is gated by
+ * its `host_pattern` and its `scope_pattern` is templated per-child
+ * (`${agentId}`/`${host}`/`${label:NAME}`). When omitted, only fleet-wide (`'**'`/NULL)
+ * non-templated bindings contribute — preserving the workflow-level (no-host) behaviour.
+ *
+ * @param bindings - Bindings already filtered for the target context
+ * @param allSecrets - All scoped secrets in the org
+ * @param hostFacts - Optional fan-out child identity for per-host resolution
+ * @returns Map of secret key → winning candidate (secret + precedence tuple)
+ */
+export declare function resolveSecretsWithProvenance(bindings: ContextBinding[], allSecrets: ScopedSecret[], hostFacts?: HostFacts): Map<string, ResolvedSecretCandidate>;
+/**
+ * Resolve secrets for a context by matching bindings against scoped secrets.
+ *
+ * Takes already-filtered bindings (for the target context). For each binding,
+ * finds secrets whose (substituted) scope matches the binding's scopePattern via
+ * picomatch. When multiple scopes provide the same key, precedence is the tuple
+ * `(host specificity, scope depth)` — a per-host binding (exact host) overrides a
+ * fleet-wide one, then longest scope path wins. Scope depth is computed AFTER
+ * stripping the backend prefix.
+ *
+ * When `hostFacts` is supplied (a fan-out child's identity), each binding is
+ * gated by its `host_pattern` and its `scope_pattern` is templated per-child
+ * (`${agentId}`/`${host}`/`${label:NAME}`). When omitted, only fleet-wide
+ * (`'**'`/NULL) non-templated bindings contribute — preserving the workflow-level
+ * (no-host) behaviour.
+ *
+ * Delegates precedence to `resolveSecretsWithProvenance` and applies `decryptFn`
+ * to each winning secret.
+ *
+ * @param bindings - Bindings already filtered for the target context
+ * @param allSecrets - All scoped secrets in the org
+ * @param decryptFn - Pure decryption function (keeps this module crypto-free)
+ * @param hostFacts - Optional fan-out child identity for per-host resolution
+ * @returns Flat record of decrypted secret key-value pairs
+ */
+export declare function resolveSecretsForContext(bindings: ContextBinding[], allSecrets: ScopedSecret[], decryptFn: (s: ScopedSecret) => string, hostFacts?: HostFacts): Record<string, string>;
+//# sourceMappingURL=scope-resolver.d.ts.map

package/dist/{environment → context}/scope-resolver.js

@@ -2,7 +2,7 @@ import "../rolldown-runtime-ClRpJifh.js";
 import { hostSpecificity, matchHostPattern } from "./host-match.js";
 import { substituteScopePattern } from "./scope-template.js";
 import picomatch from "picomatch";
-//#region src/environment/scope-resolver.ts
+//#region src/context/scope-resolver.ts
 /**
 * Check whether a scope string matches a pattern.
 *
@@ -70,28 +70,29 @@ function candidateWins(c, existing) {
 	return c.scopeDepth > existing.scopeDepth;
 }
 /**
-* Resolve secrets for an environment by matching bindings against scoped secrets.
+* Resolve the winning secret per key by matching bindings against scoped secrets,
+* applying the host gate and `(host specificity, scope depth)` precedence — WITHOUT
+* decrypting, keeping this module crypto-free. This is the single source of truth for
+* scope precedence; `resolveSecretsForContext` delegates to it and adds the decrypt step.
 *
-* Takes already-filtered bindings (for the target environment). For each binding,
-* finds secrets whose (substituted) scope matches the binding's scopePattern via
-* picomatch. When multiple scopes provide the same key, precedence is the tuple
+* Takes already-filtered bindings (for the target context). For each binding, finds
+* secrets whose (substituted) scope matches the binding's scopePattern via picomatch.
+* When multiple scopes provide the same key, precedence is the tuple
 * `(host specificity, scope depth)` — a per-host binding (exact host) overrides a
-* fleet-wide one, then longest scope path wins. Scope depth is computed AFTER
-* stripping the backend prefix.
+* fleet-wide one, then longest scope path wins. Scope depth is computed AFTER stripping
+* the backend prefix.
 *
-* When `hostFacts` is supplied (a fan-out child's identity), each binding is
-* gated by its `host_pattern` and its `scope_pattern` is templated per-child
-* (`${agentId}`/`${host}`/`${label:NAME}`). When omitted, only fleet-wide
-* (`'**'`/NULL) non-templated bindings contribute — preserving the workflow-level
-* (no-host) behaviour.
+* When `hostFacts` is supplied (a fan-out child's identity), each binding is gated by
+* its `host_pattern` and its `scope_pattern` is templated per-child
+* (`${agentId}`/`${host}`/`${label:NAME}`). When omitted, only fleet-wide (`'**'`/NULL)
+* non-templated bindings contribute — preserving the workflow-level (no-host) behaviour.
 *
-* @param bindings - Bindings already filtered for the target environment
+* @param bindings - Bindings already filtered for the target context
 * @param allSecrets - All scoped secrets in the org
-* @param decryptFn - Pure decryption function (keeps this module crypto-free)
 * @param hostFacts - Optional fan-out child identity for per-host resolution
-* @returns Flat record of decrypted secret key-value pairs
+* @returns Map of secret key → winning candidate (secret + precedence tuple)
 */
-function resolveSecretsForEnvironment(bindings, allSecrets, decryptFn, hostFacts) {
+function resolveSecretsWithProvenance(bindings, allSecrets, hostFacts) {
 	const resolved = /* @__PURE__ */ new Map();
 	for (const binding of bindings) {
 		const scopePattern = bindingScopeForHost(binding, hostFacts);
@@ -107,11 +108,40 @@ function resolveSecretsForEnvironment(bindings, allSecrets, decryptFn, hostFacts
 			if (candidateWins(candidate, resolved.get(secret.key))) resolved.set(secret.key, candidate);
 		}
 	}
+	return resolved;
+}
+/**
+* Resolve secrets for a context by matching bindings against scoped secrets.
+*
+* Takes already-filtered bindings (for the target context). For each binding,
+* finds secrets whose (substituted) scope matches the binding's scopePattern via
+* picomatch. When multiple scopes provide the same key, precedence is the tuple
+* `(host specificity, scope depth)` — a per-host binding (exact host) overrides a
+* fleet-wide one, then longest scope path wins. Scope depth is computed AFTER
+* stripping the backend prefix.
+*
+* When `hostFacts` is supplied (a fan-out child's identity), each binding is
+* gated by its `host_pattern` and its `scope_pattern` is templated per-child
+* (`${agentId}`/`${host}`/`${label:NAME}`). When omitted, only fleet-wide
+* (`'**'`/NULL) non-templated bindings contribute — preserving the workflow-level
+* (no-host) behaviour.
+*
+* Delegates precedence to `resolveSecretsWithProvenance` and applies `decryptFn`
+* to each winning secret.
+*
+* @param bindings - Bindings already filtered for the target context
+* @param allSecrets - All scoped secrets in the org
+* @param decryptFn - Pure decryption function (keeps this module crypto-free)
+* @param hostFacts - Optional fan-out child identity for per-host resolution
+* @returns Flat record of decrypted secret key-value pairs
+*/
+function resolveSecretsForContext(bindings, allSecrets, decryptFn, hostFacts) {
+	const resolved = resolveSecretsWithProvenance(bindings, allSecrets, hostFacts);
 	const result = {};
 	for (const [key, { secret }] of resolved) result[key] = decryptFn(secret);
 	return result;
 }
 //#endregion
-export { matchScopePattern, resolveSecretsForEnvironment, stripScopePrefix };
+export { matchScopePattern, resolveSecretsForContext, resolveSecretsWithProvenance, stripScopePrefix };
 
 //# sourceMappingURL=scope-resolver.js.map

package/dist/{environment → context}/scope-template.js

@@ -1,5 +1,5 @@
 import "../rolldown-runtime-ClRpJifh.js";
-//#region src/environment/scope-template.ts
+//#region src/context/scope-template.ts
 /** A substituted value must be a single literal path segment — no `/` or glob. */
 const SAFE_SEGMENT = /^[A-Za-z0-9._-]+$/;
 const PLACEHOLDER = /\$\{(agentId|host|label:[^}]+)\}/g;

package/dist/{environment → context}/types.d.ts

@@ -1,13 +1,16 @@
 /**
- * Environment types for KiCI's deployment environment model.
+ * Context types for KiCI's named-context model.
  *
- * Environments are org-level entities that group secrets, variables,
+ * Contexts are org-level entities that group secrets, variables,
  * and protection rules for deployment targets (dev, staging, production).
  */
 import { z } from 'zod';
 import type { ApproverClause } from '../approval/types.js';
-/** Environment entity — org-level deployment target with protection rules. */
-export interface Environment {
+import type { HoldType } from './hold-type.js';
+import type { HeldRunStatus } from './held-run-status.js';
+import type { ConcurrencyStrategy } from './concurrency-strategy.js';
+/** Context entity — org-level deployment target with protection rules. */
+export interface Context {
     id: string;
     orgId: string;
     name: string;
@@ -17,14 +20,14 @@ export interface Environment {
     triggerTypeFilters: string[];
     repoPatterns: string[];
     concurrencyLimit: number | null;
-    concurrencyStrategy: 'queue' | 'cancel-pending';
+    concurrencyStrategy: ConcurrencyStrategy;
     concurrencyTimeoutMs: number;
     requiredReviewers: string[] | null;
     waitTimerSeconds: number | null;
     holdExpirySeconds: number;
-    /** Minimum trust tier required for CI execution in this environment. */
+    /** Minimum trust tier required for CI execution in this context. */
     minimumTrust?: 'known' | 'trusted';
-    /** Whether this environment allows local (no-remote) executions. Default false. */
+    /** Whether this context allows local (no-remote) executions. Default false. */
     allowLocalExecution?: boolean;
     enabled: boolean;
     createdAt: string;
@@ -43,11 +46,11 @@ export interface ScopedSecret {
     createdAt: string;
     updatedAt: string;
 }
-/** Binding that maps a scope pattern to an environment. */
-export interface EnvironmentBinding {
+/** Binding that maps a scope pattern to a context. */
+export interface ContextBinding {
     id: string;
     orgId: string;
-    environmentId: string;
+    contextId: string;
     scopePattern: string;
     /**
      * Host selector this binding applies to (exact / glob / regex, matched
@@ -58,22 +61,22 @@ export interface EnvironmentBinding {
     hostPattern: string;
     createdAt: string;
 }
-/** Non-secret key-value config per environment, with optional lock. */
-export interface EnvironmentVariable {
+/** Non-secret key-value config per context, with optional lock. */
+export interface ContextVariable {
     id: string;
     orgId: string;
-    environmentId: string;
+    contextId: string;
     key: string;
     value: string;
     locked: boolean;
     createdAt: string;
     updatedAt: string;
 }
-/** Per-source override for an environment variable. */
-export interface EnvironmentSourceOverride {
+/** Per-source override for a context variable. */
+export interface ContextSourceOverride {
     id: string;
     orgId: string;
-    environmentId: string;
+    contextId: string;
     routingKey: string;
     key: string;
     value: string;
@@ -82,9 +85,9 @@ export interface EnvironmentSourceOverride {
 }
 /** Trust tier for contributor-based CI execution gating (single source of truth). */
 export declare const TrustTierSchema: z.ZodEnum<{
-    unknown: "unknown";
     known: "known";
     trusted: "trusted";
+    unknown: "unknown";
 }>;
 export type TrustTier = z.infer<typeof TrustTierSchema>;
 /** Held run record for protection gate enforcement. */
@@ -93,9 +96,9 @@ export interface HeldRun {
     orgId: string;
     runId: string;
     jobId: string;
-    environmentId: string;
-    holdType: 'reviewer' | 'timer' | 'concurrency' | 'security';
-    status: 'pending' | 'approved' | 'rejected' | 'expired';
+    contextId: string;
+    holdType: HoldType;
+    status: HeldRunStatus;
     reason: string | null;
     approvedBy: string | null;
     createdAt: string;
@@ -107,9 +110,9 @@ export interface ProtectionGateResult {
     action: 'pass' | 'reject' | 'hold' | 'queue' | 'wait';
     reason?: string;
     holdUntil?: string;
-    holdType?: 'reviewer' | 'timer' | 'concurrency' | 'security';
+    holdType?: HoldType;
     /**
-     * Approver clauses for a reviewer hold, mapped from the environment's
+     * Approver clauses for a reviewer hold, mapped from the context's
      * `requiredReviewers`. Each reviewer string maps to a `{ user }` clause
      * (team-named reviewers are a documented follow-up). Empty/undefined means
      * "any approval-capable member".

package/dist/{environment → context}/types.js

@@ -1,10 +1,10 @@
 import "../rolldown-runtime-ClRpJifh.js";
 import { z } from "zod";
-//#region src/environment/types.ts
+//#region src/context/types.ts
 /**
-* Environment types for KiCI's deployment environment model.
+* Context types for KiCI's named-context model.
 *
-* Environments are org-level entities that group secrets, variables,
+* Contexts are org-level entities that group secrets, variables,
 * and protection rules for deployment targets (dev, staging, production).
 */
 /** Trust tier for contributor-based CI execution gating (single source of truth). */

package/dist/dev-ops/operations.d.ts

@@ -21,7 +21,7 @@
  * Browser-safe: data + TypeScript types only, no Node imports, so it lives in
  * the engine barrel importable by the web UI, the CLI, and the Platform.
  */
-export type DeveloperOpDomain = 'runs' | 'workflows' | 'environments' | 'secrets' | 'held-runs' | 'diagnostics' | 'orchestrators' | 'sources' | 'dlq' | 'attestations' | 'activity' | 'orgs';
+export type DeveloperOpDomain = 'runs' | 'workflows' | 'contexts' | 'secrets' | 'held-runs' | 'diagnostics' | 'orchestrators' | 'sources' | 'dlq' | 'attestations' | 'activity' | 'orgs';
 export type DeveloperOpKind = 'read' | 'write';
 /** Which of the three entrypoints a developer op is (or should be) exposed on. */
 export interface DeveloperOpEntrypoints {
@@ -45,6 +45,14 @@ export interface DeveloperOperation {
     mcpAppropriate: boolean;
     /** MCP tool name when `entrypoints.mcp` is true; null otherwise. */
     mcpTool: string | null;
+    /**
+     * True when the op acts on a specific repository's resource and must honour
+     * the caller's repo glob patterns on EVERY entrypoint. Required on every row
+     * so a new op cannot compile without an explicit decision, and NOT derivable
+     * from `domain` — `workflows.list` is repo-scoped while `secrets.list`, whose
+     * rows are context-keyed with no repository to scope against, is not.
+     */
+    repoScoped: boolean;
 }
 /**
  * The workflow-developer core. Developer plane only — org-membership-scoped,

package/dist/dev-ops/operations.js

@@ -1,7 +1,7 @@
 import "../rolldown-runtime-ClRpJifh.js";
 //#region src/dev-ops/operations.ts
 /** Build a row, defaulting every unspecified entrypoint to false. */
-function op(id, domain, kind, ep, mcpAppropriate, mcpTool) {
+function op(id, domain, kind, ep, mcpAppropriate, mcpTool, repoScoped) {
 	return {
 		id,
 		domain,
@@ -14,7 +14,8 @@ function op(id, domain, kind, ep, mcpAppropriate, mcpTool) {
 			...ep
 		},
 		mcpAppropriate,
-		mcpTool
+		mcpTool,
+		repoScoped
 	};
 }
 /**
@@ -27,103 +28,119 @@ const DEVELOPER_OPERATIONS = [
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "list_runs"),
+	}, true, "list_runs", true),
 	op("runs.get", "runs", "read", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "get_run"),
+	}, true, "get_run", true),
 	op("runs.stepLogs", "runs", "read", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "get_step_logs"),
+	}, true, "get_step_logs", true),
 	op("runs.cancel", "runs", "write", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "cancel_run"),
+	}, true, "cancel_run", true),
 	op("runs.cancelByBranch", "runs", "write", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: false
-	}, true, "cancel_runs_by_branch"),
+	}, true, "cancel_runs_by_branch", true),
 	op("runs.rerun", "runs", "write", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "rerun_run"),
+	}, true, "rerun_run", true),
 	op("workflows.list", "workflows", "read", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "list_workflows"),
+	}, true, "list_workflows", true),
 	op("workflows.trigger", "workflows", "write", {
 		http: true,
 		cli: false,
 		mcp: true,
 		ui: true
-	}, true, "trigger_run"),
+	}, true, "trigger_run", true),
+	op("workflows.disable", "workflows", "write", {
+		http: true,
+		cli: false,
+		mcp: false,
+		ui: true
+	}, false, null, true),
+	op("workflows.delete", "workflows", "write", {
+		http: true,
+		cli: false,
+		mcp: false,
+		ui: true
+	}, false, null, true),
 	op("secrets.list", "secrets", "read", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "list_secrets"),
+	}, true, "list_secrets", false),
 	op("secrets.set", "secrets", "write", {
 		http: true,
 		cli: false,
 		mcp: false,
 		ui: true
-	}, false, null),
+	}, false, null, false),
 	op("secrets.delete", "secrets", "write", {
 		http: true,
 		cli: false,
 		mcp: false,
 		ui: true
-	}, false, null),
-	op("environments.delete", "environments", "write", {
+	}, false, null, false),
+	op("contexts.delete", "contexts", "write", {
 		http: true,
 		cli: false,
 		mcp: false,
 		ui: true
-	}, false, null),
+	}, false, null, false),
+	op("held-runs.list", "held-runs", "read", {
+		http: true,
+		ui: true
+	}, false, null, true),
 	op("held-runs.approve", "held-runs", "write", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "approve_run"),
+	}, true, "approve_run", true),
 	op("held-runs.reject", "held-runs", "write", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "reject_run"),
+	}, true, "reject_run", true),
 	op("diagnostics.get", "diagnostics", "read", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "get_diagnostics"),
+	}, true, "get_diagnostics", false),
 	op("orchestrators.list", "orchestrators", "read", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "list_orchestrators"),
+	}, true, "list_orchestrators", false),
 	op("orgs.list", "orgs", "read", {
 		http: true,
 		cli: true,
 		mcp: true,
 		ui: true
-	}, true, "list_orgs")
+	}, true, "list_orgs", false)
 ];
 /** All ops a given entrypoint should expose. */
 function developerOpsForEntrypoint(ep) {

package/dist/diagnostics/infra-alert.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Infrastructure alert vocabulary — the single definition of what a diagnostics
+ * infrastructure alert's `type` and `severity` can be.
+ *
+ * Lives beside the other shared vocabularies (`billing/plan-type.ts`,
+ * `context/held-run-status.ts`) rather than in the protocol module, so the
+ * Platform producer, the dashboard, and the `kici` CLI all name one enum
+ * instead of each carrying a copy. Pure Zod with no Node built-ins, so it is
+ * safe on the browser-facing engine barrel.
+ *
+ * This is the *known* vocabulary — the set the Platform mints alerts from and
+ * the set the read-side consumers colour their badges by. It is deliberately
+ * NOT the wire type of the response fields. The hosted Platform always runs the
+ * newest build, while a customer's `kici` CLI is pinned to whatever version
+ * they installed and hard-parses this response
+ * (`packages/compiler/src/remote/dashboard-client.ts`). A strict enum on the
+ * wire would not degrade one alert row — it would fail the whole
+ * `/diagnostics/infrastructure` parse and take `kici diagnostics` down with it
+ * the day a fifth alert type ships. So the response carries `z.string()` and
+ * the producer carries the enum: strict on write, permissive on read.
+ */
+import { z } from 'zod';
+/**
+ * Known infrastructure alert types, matching what the Platform mints from the
+ * state it computes about connected orchestrators.
+ */
+export declare const InfraAlertType: z.ZodEnum<{
+    capacity: "capacity";
+    "label-gaps": "label-gaps";
+    "no-raft-leader": "no-raft-leader";
+    "zero-agents": "zero-agents";
+}>;
+export type InfraAlertType = z.infer<typeof InfraAlertType>;
+/** Every known alert type, in declaration order. */
+export declare const INFRA_ALERT_TYPES: readonly InfraAlertType[];
+/** Known alert severities, in ascending urgency. */
+export declare const InfraAlertSeverity: z.ZodEnum<{
+    critical: "critical";
+    warning: "warning";
+}>;
+export type InfraAlertSeverity = z.infer<typeof InfraAlertSeverity>;
+/**
+ * An alert as the Platform mints it, with both fields narrowed to the known
+ * vocabulary.
+ *
+ * The producer annotates its accumulator with this type, which is what turns a
+ * misspelled or unranked alert type into a `pnpm typecheck` failure at the mint
+ * site rather than a string that validates on the wire and renders as an
+ * unrecognised row.
+ */
+export interface MintedInfraAlert {
+    type: InfraAlertType;
+    message: string;
+    severity: InfraAlertSeverity;
+}
+/**
+ * Resolve an arbitrary severity string read off the wire to a known severity.
+ *
+ * An unrecognised value resolves to `critical`. A client older than the
+ * Platform cannot know whether a severity it has never seen is quieter or
+ * louder than `critical`, and on an operator surface the safe reading of "I
+ * don't know" is the conspicuous one. A plain `severity === 'critical'`
+ * comparison instead reads every unrecognised value as a yellow warning, so a
+ * `critcal` typo silently downgrades a critical alert.
+ *
+ * `safeParse` is a set membership test, so an attacker-supplied
+ * `constructor` / `toString` cannot walk the prototype chain the way a bare
+ * object index would.
+ */
+export declare function normalizeInfraAlertSeverity(severity: string): InfraAlertSeverity;
+//# sourceMappingURL=infra-alert.d.ts.map

package/dist/diagnostics/infra-alert.js

@@ -0,0 +1,60 @@
+import "../rolldown-runtime-ClRpJifh.js";
+import { z } from "zod";
+//#region src/diagnostics/infra-alert.ts
+/**
+* Infrastructure alert vocabulary — the single definition of what a diagnostics
+* infrastructure alert's `type` and `severity` can be.
+*
+* Lives beside the other shared vocabularies (`billing/plan-type.ts`,
+* `context/held-run-status.ts`) rather than in the protocol module, so the
+* Platform producer, the dashboard, and the `kici` CLI all name one enum
+* instead of each carrying a copy. Pure Zod with no Node built-ins, so it is
+* safe on the browser-facing engine barrel.
+*
+* This is the *known* vocabulary — the set the Platform mints alerts from and
+* the set the read-side consumers colour their badges by. It is deliberately
+* NOT the wire type of the response fields. The hosted Platform always runs the
+* newest build, while a customer's `kici` CLI is pinned to whatever version
+* they installed and hard-parses this response
+* (`packages/compiler/src/remote/dashboard-client.ts`). A strict enum on the
+* wire would not degrade one alert row — it would fail the whole
+* `/diagnostics/infrastructure` parse and take `kici diagnostics` down with it
+* the day a fifth alert type ships. So the response carries `z.string()` and
+* the producer carries the enum: strict on write, permissive on read.
+*/
+/**
+* Known infrastructure alert types, matching what the Platform mints from the
+* state it computes about connected orchestrators.
+*/
+const InfraAlertType = z.enum([
+	"zero-agents",
+	"capacity",
+	"label-gaps",
+	"no-raft-leader"
+]);
+/** Every known alert type, in declaration order. */
+const INFRA_ALERT_TYPES = InfraAlertType.options;
+/** Known alert severities, in ascending urgency. */
+const InfraAlertSeverity = z.enum(["warning", "critical"]);
+/**
+* Resolve an arbitrary severity string read off the wire to a known severity.
+*
+* An unrecognised value resolves to `critical`. A client older than the
+* Platform cannot know whether a severity it has never seen is quieter or
+* louder than `critical`, and on an operator surface the safe reading of "I
+* don't know" is the conspicuous one. A plain `severity === 'critical'`
+* comparison instead reads every unrecognised value as a yellow warning, so a
+* `critcal` typo silently downgrades a critical alert.
+*
+* `safeParse` is a set membership test, so an attacker-supplied
+* `constructor` / `toString` cannot walk the prototype chain the way a bare
+* object index would.
+*/
+function normalizeInfraAlertSeverity(severity) {
+	const parsed = InfraAlertSeverity.safeParse(severity);
+	return parsed.success ? parsed.data : InfraAlertSeverity.enum.critical;
+}
+//#endregion
+export { INFRA_ALERT_TYPES, InfraAlertSeverity, InfraAlertType, normalizeInfraAlertSeverity };
+
+//# sourceMappingURL=infra-alert.js.map