@kici-dev/engine 0.1.27 → 0.2.0

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

@@ -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),
+	}, 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

package/dist/env/environment-allowlist.d.ts

@@ -15,7 +15,7 @@
  * This is an explicit allowlist -- anything NOT listed here is stripped.
  * Adding new variables to the host process will NOT leak them downstream.
  */
-export declare const ALLOWED_SYSTEM_VARS: readonly ["PATH", "HOME", "USER", "SHELL", "LANG", "LC_ALL", "TERM", "TMPDIR", "NODE_PATH", "TZ", "PATHEXT", "SystemRoot", "windir", "COMSPEC", "TEMP", "TMP", "USERPROFILE", "LOCALAPPDATA", "APPDATA", "PROCESSOR_ARCHITECTURE", "NUMBER_OF_PROCESSORS"];
+export declare const ALLOWED_SYSTEM_VARS: readonly ['PATH', 'HOME', 'USER', 'SHELL', 'LANG', 'LC_ALL', 'TERM', 'TMPDIR', 'NODE_PATH', 'TZ', 'PATHEXT', 'SystemRoot', 'windir', 'COMSPEC', 'TEMP', 'TMP', 'USERPROFILE', 'LOCALAPPDATA', 'APPDATA', 'PROCESSOR_ARCHITECTURE', 'NUMBER_OF_PROCESSORS'];
 /**
  * Default environment variables injected into every sandbox execution.
  *
@@ -31,7 +31,7 @@ export declare const SANDBOX_DEFAULT_VARS: Record<string, string>;
  * These are set explicitly by the scaler (not copied from orchestrator process.env)
  * to ensure the agent receives only the values it needs with correct content.
  */
-export declare const AGENT_REQUIRED_KICI_VARS: readonly ["KICI_ORCHESTRATOR_URL", "KICI_AGENT_ID", "KICI_LABELS", "KICI_MAX_CONCURRENT_JOBS", "KICI_SCALER_MANAGED", "KICI_EXECUTION_MODE", "KICI_PORT"];
+export declare const AGENT_REQUIRED_KICI_VARS: readonly ['KICI_ORCHESTRATOR_URL', 'KICI_AGENT_ID', 'KICI_LABELS', 'KICI_MAX_CONCURRENT_JOBS', 'KICI_SCALER_MANAGED', 'KICI_EXECUTION_MODE', 'KICI_PORT'];
 /**
  * Prefix for operator-defined environment variables that should be forwarded
  * from the orchestrator process to spawned agent processes.
@@ -41,14 +41,14 @@ export declare const AGENT_REQUIRED_KICI_VARS: readonly ["KICI_ORCHESTRATOR_URL"
  *   KICI_AGENT_ENV_HTTP_PROXY=http://proxy:3128
  *   -> HTTP_PROXY=http://proxy:3128 in the agent process
  */
-export declare const KICI_AGENT_ENV_PREFIX: "KICI_AGENT_ENV_";
+export declare const KICI_AGENT_ENV_PREFIX: 'KICI_AGENT_ENV_';
 /**
  * Non-`KICI_`-prefixed environment variables that are the agent's / orchestrator's
  * own infrastructure secrets. These are scrubbed from a trusted-env passthrough
  * in addition to the whole `KICI_*` namespace, so even a trusted fleet agent
  * never leaks its control-plane credentials into a workflow step.
  */
-export declare const TRUSTED_ENV_SCRUB_EXACT: readonly ["DATABASE_URL", "PLATFORM_TOKEN", "WEBHOOK_SECRET", "GITHUB_PRIVATE_KEY"];
+export declare const TRUSTED_ENV_SCRUB_EXACT: readonly ['DATABASE_URL', 'PLATFORM_TOKEN', 'WEBHOOK_SECRET', 'GITHUB_PRIVATE_KEY'];
 /**
  * A variable that must NEVER reach a workflow step even under the trusted-env
  * profile. The agent's entire `KICI_*` namespace (its orchestrator URL, agent

package/dist/fanout/materialize.d.ts

@@ -2,6 +2,18 @@ import { type MatrixValues } from '../matrix/expand.js';
 import type { LockJob } from '../trigger/types.js';
 /** Hard cap on children per fanned job — mirrors the compiler's MAX_STATIC_MATRIX_JOBS. */
 export declare const MAX_FANOUT_JOBS = 256;
+/**
+ * Hard ceiling on the raw combination product a matrix may materialize.
+ *
+ * Distinct from {@link MAX_FANOUT_JOBS} on purpose. `MAX_FANOUT_JOBS` bounds
+ * the FINAL children after include/exclude and is checked after expansion;
+ * this bounds what may be allocated in the first place, and is checked before.
+ * They cannot be collapsed into one check: excludes only ever reduce the count,
+ * so a matrix whose raw product is 300 but which excludes down to 200 is legal
+ * and must keep working. The ceiling is deliberately far above any realistic
+ * matrix — its only job is to turn an out-of-memory kill into a typed error.
+ */
+export declare const MAX_MATRIX_MATERIALIZATION = 100000;
 /**
  * The kind of fan-out a materialized child belongs to. `matrix` children come
  * from a matrix expansion (one per combination); `host` children come from a
@@ -139,6 +151,10 @@ export declare function fanoutEnvelopeFields(mat: MaterializedJob): {
  * (produced by the agent eval flow). Mirrors the static-matrix branch of
  * {@link materializeFanout} but takes the already-resolved combinations and
  * enforces the same cap / zero-combination guards.
+ *
+ * Duplicate combinations are refused here rather than on the agent, so the
+ * failure surfaces beside the zero-combination and cap errors for the same
+ * path.
  */
 export declare function materializeResolvedMatrix(lockJob: LockJob, combos: readonly MatrixValues[]): FanoutResult;
 /**

package/dist/fanout/materialize.js

@@ -1,10 +1,22 @@
 import "../rolldown-runtime-ClRpJifh.js";
-import { applyIncludeExclude, expandMatrix } from "../matrix/expand.js";
+import { MatrixShapeError, applyIncludeExclude, expandMatrix, findDuplicateCombination, matrixCombinationCount } from "../matrix/expand.js";
 import { formatExpandedJobName } from "../matrix/format.js";
 //#region src/fanout/materialize.ts
 /** Hard cap on children per fanned job — mirrors the compiler's MAX_STATIC_MATRIX_JOBS. */
 const MAX_FANOUT_JOBS = 256;
 /**
+* Hard ceiling on the raw combination product a matrix may materialize.
+*
+* Distinct from {@link MAX_FANOUT_JOBS} on purpose. `MAX_FANOUT_JOBS` bounds
+* the FINAL children after include/exclude and is checked after expansion;
+* this bounds what may be allocated in the first place, and is checked before.
+* They cannot be collapsed into one check: excludes only ever reduce the count,
+* so a matrix whose raw product is 300 but which excludes down to 200 is legal
+* and must keep working. The ceiling is deliberately far above any realistic
+* matrix — its only job is to turn an out-of-memory kill into a typed error.
+*/
+const MAX_MATRIX_MATERIALIZATION = 1e5;
+/**
 * The kind of fan-out a materialized child belongs to. `matrix` children come
 * from a matrix expansion (one per combination); `host` children come from a
 * `runsOnAll` fan-out (one pinned execution per roster host).
@@ -103,10 +115,16 @@ function fanoutEnvelopeFields(mat) {
 * (produced by the agent eval flow). Mirrors the static-matrix branch of
 * {@link materializeFanout} but takes the already-resolved combinations and
 * enforces the same cap / zero-combination guards.
+*
+* Duplicate combinations are refused here rather than on the agent, so the
+* failure surfaces beside the zero-combination and cap errors for the same
+* path.
 */
 function materializeResolvedMatrix(lockJob, combos) {
 	if (combos.length === 0) throw new FanoutError(lockJob.name, `dynamic matrix for job '${lockJob.name}' resolved to zero combinations`);
 	if (combos.length > 256) throw new FanoutError(lockJob.name, `dynamic matrix for job '${lockJob.name}' resolved to ${combos.length} combinations (max 256)`);
+	const duplicate = findDuplicateCombination(combos, (c) => formatExpandedJobName(lockJob.name, c));
+	if (duplicate) throw new FanoutError(lockJob.name, `dynamic matrix for job '${lockJob.name}' produced duplicate combination ${JSON.stringify(duplicate)} — two children would share the expanded name '${formatExpandedJobName(lockJob.name, duplicate)}'; de-duplicate the values your matrix function returns`);
 	const jobs = [];
 	for (const variantValues of combos) jobs.push({
 		lockJob,
@@ -197,9 +215,20 @@ function materializeFanout(staticJobs) {
 		}
 		const values = matrix.values;
 		if (!values) throw new FanoutError(lockJob.name, `static matrix for job '${lockJob.name}' has no values`);
-		const combos = applyIncludeExclude(expandMatrix(values), lockJob.include, lockJob.exclude);
+		let expanded;
+		try {
+			const rawCount = matrixCombinationCount(values);
+			if (rawCount > 1e5) throw new FanoutError(lockJob.name, `matrix for job '${lockJob.name}' is too large to expand: ${rawCount} raw combinations (max ${MAX_MATRIX_MATERIALIZATION})`);
+			expanded = expandMatrix(values);
+		} catch (err) {
+			if (err instanceof MatrixShapeError) throw new FanoutError(lockJob.name, `job '${lockJob.name}': ${err.message}`);
+			throw err;
+		}
+		const combos = applyIncludeExclude(expanded, lockJob.include, lockJob.exclude);
 		if (combos.length === 0) throw new FanoutError(lockJob.name, `matrix for job '${lockJob.name}' expands to zero combinations`);
 		if (combos.length > 256) throw new FanoutError(lockJob.name, `matrix for job '${lockJob.name}' expands to ${combos.length} combinations (max 256)`);
+		const duplicate = findDuplicateCombination(combos, (c) => formatExpandedJobName(lockJob.name, c));
+		if (duplicate) throw new FanoutError(lockJob.name, `matrix for job '${lockJob.name}' produced duplicate combination ${JSON.stringify(duplicate)} — two children would share the expanded name '${formatExpandedJobName(lockJob.name, duplicate)}'; de-duplicate the matrix values`);
 		const children = combos.map((variantValues) => ({
 			lockJob,
 			baseName: lockJob.name,
@@ -217,6 +246,6 @@ function materializeFanout(staticJobs) {
 	};
 }
 //#endregion
-export { FanoutCause, FanoutError, MAX_FANOUT_JOBS, VariantKind, fanoutEnvelopeFields, hostEnvelopeFields, materializeFanout, materializeResolvedHosts, materializeResolvedMatrix, matrixEnvelopeFields };
+export { FanoutCause, FanoutError, MAX_FANOUT_JOBS, MAX_MATRIX_MATERIALIZATION, VariantKind, fanoutEnvelopeFields, hostEnvelopeFields, materializeFanout, materializeResolvedHosts, materializeResolvedMatrix, matrixEnvelopeFields };
 
 //# sourceMappingURL=materialize.js.map

package/dist/index.d.ts

@@ -4,7 +4,6 @@
  * Single source of truth for shared logic used across tiers:
  * - Protocol message schemas (Zod-based, direction-specific unions)
  * - Trigger matching engine (branch, path, event evaluation)
- * - Execution state machine (pure function transitions)
  * - Webhook signature verification (HMAC-SHA256)
  * - WebSocket close codes (unified across all tiers)
  */
@@ -19,10 +18,12 @@ export * from './mcp/held-run-resolve.js';
 export * from './mcp/fence.js';
 export * from './protocol/messages/auth.js';
 export * from './protocol/messages/capabilities.js';
-export { webhookRelaySchema, webhookRelayStartSchema, webhookRelayChunkSchema, webhookAckSchema, WebhookRelayResult, WEBHOOK_RELAY_MAX_BODY_BYTES, WEBHOOK_RELAY_CHUNK_SIZE, executionEventSchema, logChunkSchema, peerDiscoverSchema, peerUpdateSchema, cacheStatsSchema, orchMetricsSchema, platformToOrchestratorMessageSchema, orchestratorToPlatformMessageSchema, type WebhookRelay, type WebhookRelayStart, type WebhookRelayChunk, type WebhookAck, type LogChunk, type PeerDiscover, type PeerUpdate, type CacheStats, type OrchMetrics, trustPolicyUpdateSchema, type TrustPolicyUpdate, staleCheckrunCleanupSchema, type StaleCheckrunCleanup, type PlatformToOrchestratorMessage, type OrchestratorToPlatformMessage, } from './protocol/messages/platform-orchestrator.js';
+export { webhookRelaySchema, webhookRelayStartSchema, webhookRelayChunkSchema, webhookAckSchema, WebhookRelayResult, WEBHOOK_RELAY_MAX_BODY_BYTES, WEBHOOK_RELAY_CHUNK_SIZE, executionEventSchema, logChunkSchema, orchLogChunkSchema, OrchLogPhase, peerDiscoverSchema, peerUpdateSchema, cacheStatsSchema, orchMetricsSchema, platformToOrchestratorMessageSchema, orchestratorToPlatformMessageSchema, collectDiscriminatorTypes, ORCH_TO_PLATFORM_RECOGNIZED_TYPES, PLATFORM_TO_ORCH_RECOGNIZED_TYPES, type WebhookRelay, type WebhookRelayStart, type WebhookRelayChunk, type WebhookAck, type LogChunk, type OrchLogChunk, type PeerDiscover, type PeerUpdate, type CacheStats, type OrchMetrics, DEFAULT_APPROVAL_EXPIRY_HOURS, trustPolicySchema, type TrustPolicy, trustPolicyUpdateSchema, type TrustPolicyUpdate, staleCheckrunCleanupSchema, type StaleCheckrunCleanup, platformCapabilitiesMessageSchema, type PlatformCapabilitiesMessage, type PlatformToOrchestratorMessage, type OrchestratorToPlatformMessage, } from './protocol/messages/platform-orchestrator.js';
 export * from './protocol/messages/execution-status.js';
+export * from './status/presentation.js';
 export * from './protocol/messages/agent-run-result.js';
 export * from './protocol/messages/agent-dev-ops.js';
+export * from './protocol/messages/heartbeat-health.js';
 export * from './dev-ops/operations.js';
 export * from './protocol/messages/deployment-identity.js';
 export * from './protocol/messages/scaler-event.js';
@@ -37,18 +38,22 @@ export * from './protocol/messages/dashboard.js';
 export * from './protocol/event-log-payload.js';
 export * from './protocol/messages/browser.js';
 export * from './protocol/messages/run-events.js';
-export { sourceRegistrationSchema, sourceRegistrationAckSchema, sourceDeregisterSchema, sourceDeregisterAckSchema, SourceSubtype, SourceProvider, type SourceRegistration, type SourceRegistrationAck, type SourceDeregister, type SourceDeregisterAck, } from './protocol/messages/source-registration.js';
+export { sourceRegistrationSchema, sourceRegistrationAckSchema, sourceDeregisterSchema, sourceDeregisterAckSchema, SourceSubtype, SourceProvider, OrchestratorMode, PLATFORM_CONNECTED_MODES, RELAY_INGRESS_MODES, OWN_INGRESS_MODES, type SourceRegistration, type SourceRegistrationAck, type SourceDeregister, type SourceDeregisterAck, } from './protocol/messages/source-registration.js';
 export * from './protocol/messages/join.js';
 export * from './protocol/messages/peer.js';
+export * from './protocol/messages/log-stream.js';
 export * from './protocol/messages/orchestrator-agent.js';
+export * from './sandbox/capabilities.js';
 export * from './trigger/types.js';
 export * from './trigger/trigger-event-type.js';
 export * from './trigger/decision-trace.js';
 export * from './trigger/matcher.js';
+export * from './trigger/event-buckets.js';
+export { scheduleTriggerKey } from './trigger/schedule-key.js';
 export * from './inputs/index.js';
-export * from './state-machine/index.js';
 export * from './provider/index.js';
 export { githubWebhookPath, githubIngressPath } from './webhook/webhook-url-format.js';
+export { PING_EVENT_TYPE, SUBSCRIBABLE_WEBHOOK_EVENT_TYPES, SubscribableWebhookEventType, WebhookEventType, } from './webhook/event-types.js';
 export type { WsLike } from './ws/ws-like.js';
 export * from './ws/close-codes.js';
 export { WsRateLimiter } from './ws/rate-limiter.js';
@@ -56,17 +61,21 @@ export type { RateLimiterConfig, RateLimitResult } from './ws/rate-limiter.js';
 export * from './env/environment-allowlist.js';
 export * from './secrets/index.js';
 export * from './context/index.js';
-export { deriveOsArchLabels, hostLabel, parseHostLabel, HOST_LABEL_PREFIX, agentTypeLabel, scalerLabel, mergeAutoLabels, normalizeRunsOn, KNOWN_ROLES, resolveRoleLabels, validateNoReservedLabels, scalerAgentLabels, isSelfReportedLabel, SELF_REPORTED_LABEL_PREFIXES, CAPABILITY_LABEL_PREFIX, capabilityLabel, SSH_TRANSPORT_CAPABILITY, INIT_LABEL, PRIVILEGED_ROOT_LABEL, } from './labels.js';
+export { deriveOsArchLabels, derivePlatformTaints, PLATFORM_TAINT_LABELS, ScalerOs, ScalerArch, scalerPlatformSchema, platformToOsArchLabels, platformToTaints, nodePlatformToScalerOs, nodeArchToScalerArch, hostToScalerPlatform, hostLabel, parseHostLabel, HOST_LABEL_PREFIX, agentTypeLabel, scalerLabel, mergeAutoLabels, normalizeRunsOn, KNOWN_ROLES, resolveRoleLabels, validateNoReservedLabels, scalerAgentLabels, isSelfReportedLabel, SELF_REPORTED_LABEL_PREFIXES, CAPABILITY_LABEL_PREFIX, capabilityLabel, SSH_TRANSPORT_CAPABILITY, INIT_LABEL, PRIVILEGED_ROOT_LABEL, } from './labels.js';
 export type { NormalizedRunsOn } from './labels.js';
 export type { AgentRole } from './labels.js';
+export type { ScalerPlatform } from './labels.js';
 export { LabelMatcher, matcherMatches, matcherSatisfiedBy, partitionMatchers, compileRegexMatcher, HostTargetValue, HostTargetSelector, hostSatisfiesTarget, } from './labels-match.js';
 export * from './inventory.js';
 export * from './scaler/scaler-backend-type.js';
 export * from './scaler/resource-types.js';
 export * from './registration/registerable-trigger-type.js';
 export * from './bundler/index.js';
-export { expandSingleDimension, expandMultiDimension, expandMatrix, applyIncludeExclude, type StaticMatrixArray, type StaticMatrixObject, type MatrixInclude, type MatrixExclude, type MatrixValues, } from './matrix/expand.js';
+export { expandSingleDimension, expandMultiDimension, expandMatrix, applyIncludeExclude, normalizeMatrixInput, matrixCombinationCount, findDuplicateCombination, MatrixShapeError, type NormalizedMatrix, type StaticMatrixArray, type StaticMatrixObject, type MatrixInclude, type MatrixExclude, type MatrixValues, } from './matrix/expand.js';
 export { formatMatrixSuffix, formatExpandedJobName } from './matrix/format.js';
 export * from './fanout/materialize.js';
 export * from './check-mode.js';
+export * from './artifacts/name.js';
+export * from './billing/plan-type.js';
+export * from './diagnostics/infra-alert.js';
 //# sourceMappingURL=index.d.ts.map