@kici-dev/engine 0.4.0 → 0.6.0

package/dist/protocol/messages/orchestrator-agent.js

@@ -27,11 +27,21 @@ const CacheRefScope = z.enum(["shared", "isolated"]);
 * - `groups` maps a dynamic group name to its ordered member job names.
 * - `statuses` maps an upstream job name to its terminal status, so the
 *   generator's `ctx.needs.<job>.status` reflects the frozen upstream outcome.
+* - `invokeResults` maps an invoke-gate job name to its ordered per-run results,
+*   so the generator's `ctx.needs.<gate>.result` reflects each summoned run.
 */
+const invokeResultSchema = z.object({
+	repo: z.string(),
+	workflow: z.string(),
+	runId: z.string(),
+	status: z.string(),
+	outputs: z.record(z.string(), z.unknown())
+});
 const upstreamSnapshotSchema = z.object({
 	jobs: z.record(z.string(), z.record(z.string(), z.unknown())),
 	groups: z.record(z.string(), z.array(z.string())),
-	statuses: z.record(z.string(), ExecutionJobStatus).optional()
+	statuses: z.record(z.string(), ExecutionJobStatus).optional(),
+	invokeResults: z.record(z.string(), z.array(invokeResultSchema)).optional()
 });
 /**
 * Structured git-clone auth material. Carries everything the agent needs to
@@ -108,6 +118,15 @@ const jobDispatchSchema = z.object({
 	/** Terminal status of each upstream job (keyed by job name; per-child for fan-out). Powers `ctx.needs.<job>.status`. */
 	upstreamJobStatuses: z.record(z.string(), ExecutionJobStatus).optional(),
 	/**
+	* Per-invoke-gate results for any upstream gate this job `needs`, keyed by
+	* gate job name. One {@link invokeResultSchema} entry per run the gate
+	* triggered, carrying the invoked run's non-secret declared outputs. Powers
+	* a standard downstream job's `ctx.needs['<gate>'].result`. Additive and
+	* optional — older orchestrators omit it and the agent resolves the gate
+	* need through the fan-out group shape instead.
+	*/
+	upstreamInvokeResults: z.record(z.string(), z.array(invokeResultSchema)).optional(),
+	/**
 	* Structured clone auth for the source repo. Preferred over `token` (which
 	* remains as a backward-compat field for same-provider GitHub App flows
 	* during the transition to universal-git / cross-provider global workflows).
@@ -143,6 +162,20 @@ const jobDispatchSchema = z.object({
 		token: z.string().min(1)
 	})).optional(),
 	/**
+	* Registry credentials for pulling this job's container image, already
+	* resolved by the orchestrator (the lock carries secret NAMES; the agent
+	* never resolves them itself).
+	*
+	* Optional for backward compatibility with older orchestrators, which do
+	* not send it — an agent that receives no auth pulls anonymously, exactly
+	* as it did before.
+	*/
+	containerRegistryAuth: z.object({
+		username: z.string().min(1),
+		password: z.string().min(1),
+		serveraddress: z.string().min(1)
+	}).optional(),
+	/**
 	* Extra resolved secrets to project as env vars on the install
 	* subprocess. Keyed by the bare secret name (the qualified env: prefix
 	* is stripped at resolution time). For use with a customer-committed
@@ -204,6 +237,23 @@ const registerAckSchema = z.object({
 	*/
 	pendingDispatch: z.boolean().optional(),
 	/**
+	* Set when this agent was pre-spawned to wait for work (a warm pool) rather
+	* than for a specific queued job. Such an agent MUST NOT arm any
+	* idle-shutdown timer on register: it is meant to sit ready until the
+	* orchestrator either dispatches a job to it or destroys it.
+	*
+	* The orchestrator's warm-pool reaper is the sole authority on its lifetime.
+	* An agent that also ran its own idle timer would self-terminate behind the
+	* reaper's back, re-creating the spawn/reap churn that reaping only surplus
+	* agents exists to prevent.
+	*
+	* Absent on orchestrators that predate warm pools. An agent that does not
+	* understand this field arms the short KICI_SCALER_IDLE_TIMEOUT timer exactly
+	* as before — so warm pools do not work against it, which is today's
+	* behaviour rather than a regression.
+	*/
+	warmPool: z.boolean().optional(),
+	/**
 	* Optional agent-facing capabilities this orchestrator supports (absent on
 	* pre-capability orchestrators). The agent reads it to decide whether to
 	* await optional acks like `artifacts.upload.complete.ack`.
@@ -288,6 +338,39 @@ const jobStatusSchema = z.object({
 		encrypted: z.string()
 	})).optional()
 });
+/**
+* One candidate workflow's verdict from the pre-run global eval round — the
+* job the agent runs once per (event × workflow repo) before any run row
+* exists, evaluating each candidate's `filter` and then its `DynamicJobFn`s on
+* a single dual checkout.
+*
+* `jobs` carries `LockJob[]` as an unvalidated pass-through, the same shape and
+* for the same reason as `jobDispatchSchema.jobConfig`: the lock-file job shape
+* has no Zod mirror anywhere in this package, its single source of truth is the
+* `LockJob` interface in `trigger/types.ts`, and a hand-written Zod copy would
+* drift and start rejecting legitimate generated jobs.
+*
+* Every field beyond the verdict itself is `.optional()` so an older peer
+* tolerates the message unchanged.
+*/
+const globalEvalCandidateResultSchema = z.object({
+	/** The candidate workflow's name, as it appears in the lock file. */
+	workflowName: z.string(),
+	/** Whether this workflow applies to the source repo that triggered the round. */
+	run: z.boolean(),
+	jobs: z.array(z.record(z.string(), z.unknown())).optional().describe("Jobs generated by the workflow DynamicJobFns (LockJob[])"),
+	/**
+	* Set when the verdict could not be established — the filter or a generator
+	* threw, or blew the per-candidate budget. `run` is `false` alongside it, but
+	* that is a "could not decide", not a clean "does not apply": one bad
+	* candidate never fails the round, so its siblings still carry real verdicts.
+	*/
+	indeterminate: z.boolean().optional(),
+	/** Human-readable cause, present when `indeterminate` is set. */
+	reason: z.string().optional()
+});
+/** Every candidate's verdict from one global eval round, in candidate order. */
+const globalEvalRoundResultSchema = z.object({ candidates: z.array(globalEvalCandidateResultSchema) });
 /** Reasons an agent can refuse a job.dispatch. */
 const JobRejectReason = z.enum(["busy", "draining"]);
 /**
@@ -453,7 +536,16 @@ const cacheUploadRequestSchema = z.object({
 	contentHash: z.string().optional(),
 	lockfileHash: z.string().optional(),
 	platform: z.string(),
-	arch: z.string()
+	arch: z.string(),
+	/**
+	* SHA-256 of the dependency tarball about to be uploaded. Deps uploads only.
+	*
+	* The dep tarball is stored under its own content hash, so the orchestrator
+	* needs it to sign the upload URL — the agent has already built the tarball
+	* and hashed it by the time it asks. Optional so an older agent that omits it
+	* still gets a usable (lockfile-keyed) URL during a mixed-version rollout.
+	*/
+	depsHash: z.string().optional()
 });
 /** Orchestrator -> Agent: return the pre-signed upload URL. */
 const cacheUploadResponseSchema = z.object({
@@ -742,6 +834,40 @@ const eventEmitResponseSchema = z.object({
 	/** Error description (present on failure). */
 	error: z.string().optional()
 });
+/**
+* Agent -> Orchestrator: exchanges a single-use claim code (delivered on a
+* `kici.scaler.scale-up` event) for freshly minted ephemeral agent credentials.
+* A provisioned agent normally sends this itself to self-bootstrap — the claim
+* code is the authorization, so it may send it before it authenticates or
+* registers. A provisioning workflow can also send it to obtain the token
+* directly. Additive/negotiated by presence — older peers that never emit it
+* are unaffected, so it needs no `PROTOCOL_VERSION` bump of its own.
+*/
+const scalerClaimCredentialsSchema = z.object({
+	type: z.literal("scaler.claim-credentials"),
+	/** Correlates to the response for this claim. */
+	requestId: z.string(),
+	/** Single-use code from the scale-up event's payload. */
+	claimCode: z.string()
+});
+/**
+* Orchestrator -> Agent: minted ephemeral credentials for a claimed provision,
+* or an error. The token appears only here — never in the persisted event log.
+*/
+const scalerClaimCredentialsResponseSchema = z.object({
+	type: z.literal("scaler.claim-credentials.response"),
+	/** Correlates to the original scaler.claim-credentials requestId. */
+	requestId: z.string(),
+	/** Minted credentials (present on success). */
+	credentials: z.object({
+		agentToken: z.string(),
+		agentId: z.string(),
+		orchestratorUrl: z.string(),
+		labels: z.array(z.string())
+	}).optional(),
+	/** Error description (present on failure). */
+	error: z.string().optional()
+});
 /** Periodic metrics push from agent to orchestrator. */
 const agentMetricsSchema = z.object({
 	type: z.literal("agent.metrics"),
@@ -906,6 +1032,7 @@ const orchestratorToAgentMessageSchema = z.discriminatedUnion("type", [
 	artifactsUploadCompleteAckSchema,
 	artifactsDownloadResponseSchema,
 	eventEmitResponseSchema,
+	scalerClaimCredentialsResponseSchema,
 	agentApiResponseSchema,
 	agentAuthSuccessSchema,
 	agentAuthFailureSchema,
@@ -937,6 +1064,7 @@ const agentToOrchestratorMessageSchema = z.discriminatedUnion("type", [
 	artifactsUploadCompleteSchema,
 	artifactsDownloadRequestSchema,
 	eventEmitSchema,
+	scalerClaimCredentialsSchema,
 	agentApiRequestSchema,
 	agentMetricsSchema,
 	agentAuthRequestSchema,
@@ -945,6 +1073,6 @@ const agentToOrchestratorMessageSchema = z.discriminatedUnion("type", [
 	stepApprovalRequestSchema
 ]);
 //#endregion
-export { ArtifactCompleteAckOutcome, ArtifactDownloadOutcome, ArtifactRejectReason, ArtifactUploadOutcome, CacheRefScope, JobRejectReason, StepApprovalOutcome, agentApiRequestSchema, agentApiResponseSchema, agentAuthFailureSchema, agentAuthRequestSchema, agentAuthSuccessSchema, agentLogChunkSchema, agentMetricsSchema, agentRegisterSchema, agentStatusSchema, agentStepStatusSchema, agentToOrchestratorMessageSchema, artifactsDownloadRequestSchema, artifactsDownloadResponseSchema, artifactsUploadCompleteAckSchema, artifactsUploadCompleteSchema, artifactsUploadRequestSchema, artifactsUploadResponseSchema, cacheUserRestoreRequestSchema, cacheUserRestoreResponseSchema, cacheUserSaveCompleteSchema, cacheUserSaveRequestSchema, cacheUserSaveResponseSchema, configAckSchema, eventEmitResponseSchema, eventEmitSchema, fleetBundleChunkSchema, fleetBundleErrorSchema, fleetLogsRequestSchema, gitAuthSchema, jobAckSchema, jobCancelSchema, jobConcurrencyAckSchema, jobConcurrencyReportSchema, jobDispatchSchema, jobRejectSchema, jobStatusSchema, orchestratorToAgentMessageSchema, provenanceUploadCompleteSchema, provenanceUploadDeferSchema, provenanceUploadRequestSchema, provenanceUploadResponseSchema, registerAckSchema, stepApprovalPayloadSchema, stepApprovalRequestSchema, stepApprovalResolvedSchema, upstreamSnapshotSchema };
+export { ArtifactCompleteAckOutcome, ArtifactDownloadOutcome, ArtifactRejectReason, ArtifactUploadOutcome, CacheRefScope, JobRejectReason, StepApprovalOutcome, agentApiRequestSchema, agentApiResponseSchema, agentAuthFailureSchema, agentAuthRequestSchema, agentAuthSuccessSchema, agentLogChunkSchema, agentMetricsSchema, agentRegisterSchema, agentStatusSchema, agentStepStatusSchema, agentToOrchestratorMessageSchema, artifactsDownloadRequestSchema, artifactsDownloadResponseSchema, artifactsUploadCompleteAckSchema, artifactsUploadCompleteSchema, artifactsUploadRequestSchema, artifactsUploadResponseSchema, cacheUserRestoreRequestSchema, cacheUserRestoreResponseSchema, cacheUserSaveCompleteSchema, cacheUserSaveRequestSchema, cacheUserSaveResponseSchema, configAckSchema, eventEmitResponseSchema, eventEmitSchema, fleetBundleChunkSchema, fleetBundleErrorSchema, fleetLogsRequestSchema, gitAuthSchema, globalEvalCandidateResultSchema, globalEvalRoundResultSchema, invokeResultSchema, jobAckSchema, jobCancelSchema, jobConcurrencyAckSchema, jobConcurrencyReportSchema, jobDispatchSchema, jobRejectSchema, jobStatusSchema, orchestratorToAgentMessageSchema, provenanceUploadCompleteSchema, provenanceUploadDeferSchema, provenanceUploadRequestSchema, provenanceUploadResponseSchema, registerAckSchema, scalerClaimCredentialsResponseSchema, scalerClaimCredentialsSchema, stepApprovalPayloadSchema, stepApprovalRequestSchema, stepApprovalResolvedSchema, upstreamSnapshotSchema };
 
 //# sourceMappingURL=orchestrator-agent.js.map

package/dist/protocol/messages/peer.d.ts

@@ -16,6 +16,7 @@ declare const scalerCapacitySummarySchema: z.ZodObject<{
     activeCount: z.ZodNumber;
     spawnsOnLocalHost: z.ZodOptional<z.ZodBoolean>;
     mandatoryLabels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    labelSetMandatoryLabels: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>;
 /** Peer hello: initiator sends ephemeral X25519 public key and nonce. */
 export declare const peerHelloSchema: z.ZodObject<{
@@ -68,6 +69,7 @@ export declare const peerAuthResponseSchema: z.ZodObject<{
         activeCount: z.ZodNumber;
         spawnsOnLocalHost: z.ZodOptional<z.ZodBoolean>;
         mandatoryLabels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        labelSetMandatoryLabels: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>>;
     capabilities: z.ZodOptional<z.ZodObject<{
         s3LogAccess: z.ZodBoolean;
@@ -109,6 +111,7 @@ export declare const peerHeartbeatSchema: z.ZodObject<{
         activeCount: z.ZodNumber;
         spawnsOnLocalHost: z.ZodOptional<z.ZodBoolean>;
         mandatoryLabels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        labelSetMandatoryLabels: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>>;
     configVersion: z.ZodOptional<z.ZodNumber>;
     registryVersion: z.ZodOptional<z.ZodNumber>;
@@ -495,6 +498,7 @@ export declare const peerToPeerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         activeCount: z.ZodNumber;
         spawnsOnLocalHost: z.ZodOptional<z.ZodBoolean>;
         mandatoryLabels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        labelSetMandatoryLabels: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>>;
     capabilities: z.ZodOptional<z.ZodObject<{
         s3LogAccess: z.ZodBoolean;
@@ -534,6 +538,7 @@ export declare const peerToPeerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         activeCount: z.ZodNumber;
         spawnsOnLocalHost: z.ZodOptional<z.ZodBoolean>;
         mandatoryLabels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        labelSetMandatoryLabels: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>>;
     configVersion: z.ZodOptional<z.ZodNumber>;
     registryVersion: z.ZodOptional<z.ZodNumber>;
@@ -809,6 +814,7 @@ export declare const peerFromPeerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         activeCount: z.ZodNumber;
         spawnsOnLocalHost: z.ZodOptional<z.ZodBoolean>;
         mandatoryLabels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        labelSetMandatoryLabels: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>>;
     capabilities: z.ZodOptional<z.ZodObject<{
         s3LogAccess: z.ZodBoolean;
@@ -848,6 +854,7 @@ export declare const peerFromPeerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         activeCount: z.ZodNumber;
         spawnsOnLocalHost: z.ZodOptional<z.ZodBoolean>;
         mandatoryLabels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        labelSetMandatoryLabels: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>>;
     configVersion: z.ZodOptional<z.ZodNumber>;
     registryVersion: z.ZodOptional<z.ZodNumber>;

package/dist/protocol/messages/peer.js

@@ -62,8 +62,25 @@ const scalerCapacitySummarySchema = z.object({
 	* empty the backend has no gate. Cross-peer routing applies the same
 	* rule as the local label matcher: a scaler-capacity entry only
 	* matches when every mandatory label appears in the required label set.
+	*
+	* @deprecated Use {@link labelSetMandatoryLabels}, which carries one gate
+	* per label set. This field is the union across every label set, so a
+	* scaler mixing `[linux, gpu]` with `[macos, xcode]` advertises a gate that
+	* makes its linux set unroutable. It stays populated for peers that predate
+	* the per-label-set field and is removed in v1.0.0.
+	*/
+	mandatoryLabels: z.array(z.string()).optional().default([]),
+	/**
+	* Per-label-set taint gate, index-aligned with `labelSets`: entry `i` is the
+	* gate a job must satisfy to route to `labelSets[i]`.
+	*
+	* Deliberately `.optional()` with no default. `undefined` is the only value
+	* that can mean "this peer predates the field — fall back to the scaler-wide
+	* `mandatoryLabels`"; an empty array would read as "every label set is
+	* ungated". A consumer also falls back when the length does not equal
+	* `labelSets.length`, so a malformed advertisement is never indexed into.
 	*/
-	mandatoryLabels: z.array(z.string()).optional().default([])
+	labelSetMandatoryLabels: z.array(z.array(z.string())).optional()
 });
 /** Peer hello: initiator sends ephemeral X25519 public key and nonce. */
 const peerHelloSchema = z.object({

package/dist/protocol/messages/platform-orchestrator.d.ts

@@ -13,10 +13,91 @@ import { z } from 'zod';
  * number cannot drift between the two packages that enforce it.
  */
 export declare const DEFAULT_APPROVAL_EXPIRY_HOURS = 72;
+/** Seconds in an hour — the one conversion between the two expiry spellings. */
+export declare const SECONDS_PER_HOUR = 3600;
+/**
+ * The same documented default as {@link DEFAULT_APPROVAL_EXPIRY_HOURS}, in the
+ * granularity the policy actually stores.
+ */
+export declare const DEFAULT_APPROVAL_EXPIRY_SECONDS: number;
+/**
+ * The shortest expressible security-hold window.
+ *
+ * One second, not a rounder-looking number: the floor exists to stop a zero or
+ * negative value minting an already-expired hold, and any strictly positive
+ * integer discharges that. A larger floor would be an invented usability
+ * opinion that also puts the window back out of reach of a test.
+ */
+export declare const MIN_APPROVAL_EXPIRY_SECONDS = 1;
+/** The longest window the Platform accepts: one year, the bound already applied to hours. */
+export declare const MAX_APPROVAL_EXPIRY_HOURS = 8760;
+/** {@link MAX_APPROVAL_EXPIRY_HOURS} in seconds, so neither spelling outranges the other. */
+export declare const MAX_APPROVAL_EXPIRY_SECONDS: number;
+/**
+ * The window a policy actually means, in seconds.
+ *
+ * `approvalExpirySeconds` is the authority and `approvalExpiryHours` its coarse
+ * spelling, so the more specific field wins whenever both are present — the
+ * only rule that never discards what an operator asked for. A policy carrying
+ * neither (an older peer that sent no window at all) falls back to the
+ * documented default.
+ */
+export declare function approvalExpirySecondsOf(policy: {
+    approvalExpiryHours?: number | null;
+    approvalExpirySeconds?: number | null;
+}): number;
+/**
+ * The coarse `approvalExpiryHours` view of a window stored in seconds.
+ *
+ * Rounds UP, and never below one hour. A sub-hour window has no exact hours
+ * spelling, and the peer reading this field is one that cannot express the real
+ * value anyway — so the choice is which way to be wrong. Rounding up yields a
+ * longer hold than asked for, which stays approvable; rounding down yields zero,
+ * which is the already-expired hold `MIN_APPROVAL_EXPIRY_SECONDS` exists to
+ * prevent.
+ */
+export declare function approvalExpiryHoursOf(seconds: number): number;
+/**
+ * The org-level fork switch: the setting an org's trust policy carries for how
+ * fork pull requests are treated. Each value names what the operator is
+ * choosing; which values the orchestrator's trust-policy gate honours, and the
+ * mechanism it uses, are owned there rather than here.
+ *
+ * - `ignore` — the operator declines fork pull requests.
+ * - `hold` — the operator requires approval first; the policy's approval expiry
+ *   bounds how long that approval stays open.
+ * - `allow` — the operator permits fork pull requests to run with reduced
+ *   privilege.
+ * - `reject` — deprecated in favour of `ignore`; removed at v1.0.0.
+ */
+export declare const ForkPolicy: z.ZodEnum<{
+    allow: "allow";
+    hold: "hold";
+    ignore: "ignore";
+    reject: "reject";
+}>;
+export type ForkPolicy = z.infer<typeof ForkPolicy>;
+/**
+ * How much CI authority one org member holds.
+ *
+ * The level the `/kici approve` comment path reads once it has resolved a
+ * commenter to a KiCI user id: `write` or `admin` may release a security hold,
+ * `read` and `none` may not. Named here rather than spelled inline so the wire
+ * schema, the orchestrator's admin route, and `kici-admin` all offer exactly
+ * the same four values.
+ */
+export declare const CiTrustLevel: z.ZodEnum<{
+    admin: "admin";
+    none: "none";
+    read: "read";
+    write: "write";
+}>;
+export type CiTrustLevel = z.infer<typeof CiTrustLevel>;
 export declare const trustPolicySchema: z.ZodObject<{
     forkPolicy: z.ZodEnum<{
         allow: "allow";
         hold: "hold";
+        ignore: "ignore";
         reject: "reject";
     }>;
     unknownContributorPolicy: z.ZodEnum<{
@@ -29,6 +110,7 @@ export declare const trustPolicySchema: z.ZodObject<{
         reject: "reject";
     }>;
     approvalExpiryHours: z.ZodNumber;
+    approvalExpirySeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type TrustPolicy = z.infer<typeof trustPolicySchema>;
 /** Trust policy update pushed from Platform to orchestrator when policy or identity links change. */
@@ -39,6 +121,7 @@ export declare const trustPolicyUpdateSchema: z.ZodObject<{
         forkPolicy: z.ZodEnum<{
             allow: "allow";
             hold: "hold";
+            ignore: "ignore";
             reject: "reject";
         }>;
         unknownContributorPolicy: z.ZodEnum<{
@@ -51,6 +134,7 @@ export declare const trustPolicyUpdateSchema: z.ZodObject<{
             reject: "reject";
         }>;
         approvalExpiryHours: z.ZodNumber;
+        approvalExpirySeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     identityLinks: z.ZodArray<z.ZodObject<{
         userId: z.ZodString;
@@ -215,6 +299,7 @@ export declare const staleCheckrunCleanupSchema: z.ZodObject<{
         repoIdentifier: z.ZodString;
         sha: z.ZodString;
         workflowName: z.ZodString;
+        workflowRepoIdentifier: z.ZodOptional<z.ZodString>;
         jobNames: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -274,6 +359,50 @@ export declare const orchMetricsSchema: z.ZodObject<{
     timestamp: z.ZodNumber;
 }, z.core.$strip>;
 export type OrchMetrics = z.infer<typeof orchMetricsSchema>;
+/** Largest worker-peer snapshot accepted on one frame. */
+export declare const CLUSTER_MEMBERSHIP_MAX_WORKERS = 512;
+/**
+ * Worker-peer membership snapshot, sent by a coordinator to the Platform.
+ *
+ * A snapshot rather than a delta: a dropped or reordered frame self-heals on
+ * the next send instead of corrupting a running tally. The Platform stores the
+ * reported size on `platform_connections` and aggregates it into the org's
+ * combined orchestrator count.
+ *
+ * The array bound is the first line of defence, for the same reason
+ * `orchMetricsSchema` bounds its own arrays: a malformed or hostile push must
+ * fail Zod parse at the WS edge and never reach the aggregate.
+ */
+export declare const clusterMembershipSchema: z.ZodObject<{
+    type: z.ZodLiteral<"cluster.membership">;
+    workers: z.ZodArray<z.ZodObject<{
+        instanceId: z.ZodString;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type ClusterMembership = z.infer<typeof clusterMembershipSchema>;
+/**
+ * Per-coordinator orchestrator ceiling, pushed by the Platform.
+ *
+ * `maxWorkerPeers` is an ABSOLUTE ceiling on this coordinator's connected
+ * worker peers, not a remaining allowance. The Platform computes it by
+ * excluding this connection's own workers from the org total, so it does not
+ * move when a local worker joins or leaves — the coordinator can enforce
+ * against its live peer count with no round trip and no staleness window.
+ *
+ * `orgLimit` and `orgTotal` are informational: they let the coordinator's
+ * rejection reason say why, rather than closing opaquely. `evictExcess` is set
+ * once the org has been over its limit for longer than the grace window, and
+ * asks the coordinator to drain its newest workers down to the ceiling.
+ */
+export declare const planHeadroomSchema: z.ZodObject<{
+    type: z.ZodLiteral<"plan.headroom">;
+    maxWorkerPeers: z.ZodNumber;
+    orgLimit: z.ZodNumber;
+    orgTotal: z.ZodNumber;
+    evictExcess: z.ZodBoolean;
+}, z.core.$strip>;
+export type PlanHeadroom = z.infer<typeof planHeadroomSchema>;
 /**
  * Acknowledgment that a webhook was received and processing started.
  *
@@ -474,6 +603,7 @@ export declare const platformToOrchestratorMessageSchema: z.ZodDiscriminatedUnio
         forkPolicy: z.ZodEnum<{
             allow: "allow";
             hold: "hold";
+            ignore: "ignore";
             reject: "reject";
         }>;
         unknownContributorPolicy: z.ZodEnum<{
@@ -486,6 +616,7 @@ export declare const platformToOrchestratorMessageSchema: z.ZodDiscriminatedUnio
             reject: "reject";
         }>;
         approvalExpiryHours: z.ZodNumber;
+        approvalExpirySeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     identityLinks: z.ZodArray<z.ZodObject<{
         userId: z.ZodString;
@@ -562,6 +693,7 @@ export declare const platformToOrchestratorMessageSchema: z.ZodDiscriminatedUnio
         repoIdentifier: z.ZodString;
         sha: z.ZodString;
         workflowName: z.ZodString;
+        workflowRepoIdentifier: z.ZodOptional<z.ZodString>;
         jobNames: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
@@ -586,6 +718,12 @@ export declare const platformToOrchestratorMessageSchema: z.ZodDiscriminatedUnio
         orchMetrics: z.ZodOptional<z.ZodBoolean>;
         oidcMint: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$loose>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"plan.headroom">;
+    maxWorkerPeers: z.ZodNumber;
+    orgLimit: z.ZodNumber;
+    orgTotal: z.ZodNumber;
+    evictExcess: z.ZodBoolean;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"nack">;
     messageId: z.ZodOptional<z.ZodString>;
@@ -2762,7 +2900,6 @@ export declare const platformToOrchestratorMessageSchema: z.ZodDiscriminatedUnio
         type: z.ZodLiteral<"system">;
         component: z.ZodString;
     }, z.core.$strip>], "type">;
-    enabled: z.ZodOptional<z.ZodBoolean>;
     allowedRepos: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
         routingKey: z.ZodOptional<z.ZodString>;
         pattern: z.ZodString;
@@ -2775,7 +2912,7 @@ export declare const platformToOrchestratorMessageSchema: z.ZodDiscriminatedUnio
         routingKey: z.ZodOptional<z.ZodString>;
         pattern: z.ZodString;
     }, z.core.$strip>>>>;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"dashboard.access-log.list">;
     requestId: z.ZodString;
     actor: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -2892,6 +3029,7 @@ export declare const platformToOrchestratorMessageSchema: z.ZodDiscriminatedUnio
         "source_override.set": "source_override.set";
         "sources.list.read": "sources.list.read";
         "step.logs.read": "step.logs.read";
+        "trust_directory.updated": "trust_directory.updated";
         "trust_policy.updated": "trust_policy.updated";
     }>>;
     source: z.ZodOptional<z.ZodEnum<{
@@ -3207,6 +3345,8 @@ export declare const orchestratorToPlatformMessageSchema: z.ZodDiscriminatedUnio
     }>;
     routingKey: z.ZodOptional<z.ZodString>;
     repoIdentifier: z.ZodOptional<z.ZodString>;
+    workflowRepoIdentifier: z.ZodOptional<z.ZodString>;
+    isGlobalEvalRound: z.ZodOptional<z.ZodBoolean>;
     repoProvider: z.ZodOptional<z.ZodString>;
     localWorkingTree: z.ZodOptional<z.ZodBoolean>;
     sha: z.ZodOptional<z.ZodString>;
@@ -3332,6 +3472,12 @@ export declare const orchestratorToPlatformMessageSchema: z.ZodDiscriminatedUnio
         message: z.ZodString;
         jobName: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    jobKind: z.ZodOptional<z.ZodEnum<{
+        gate: "gate";
+        proxy: "proxy";
+        standard: "standard";
+    }>>;
+    summonedRunId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"state.replay">;
     messageId: z.ZodString;
@@ -3349,6 +3495,7 @@ export declare const orchestratorToPlatformMessageSchema: z.ZodDiscriminatedUnio
         }>;
         routingKey: z.ZodOptional<z.ZodString>;
         repoIdentifier: z.ZodOptional<z.ZodString>;
+        workflowRepoIdentifier: z.ZodOptional<z.ZodString>;
         sha: z.ZodOptional<z.ZodString>;
         ref: z.ZodOptional<z.ZodString>;
         triggerEvent: z.ZodOptional<z.ZodString>;
@@ -3633,6 +3780,12 @@ export declare const orchestratorToPlatformMessageSchema: z.ZodDiscriminatedUnio
         deferred: "deferred";
         "offline-backfill": "offline-backfill";
     }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"cluster.membership">;
+    workers: z.ZodArray<z.ZodObject<{
+        instanceId: z.ZodString;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"nack">;
     messageId: z.ZodOptional<z.ZodString>;