@kici-dev/engine 0.1.27 → 0.2.0

package/dist/approval/types.d.ts

@@ -21,9 +21,9 @@ export declare const approverClauseSchema: z.ZodUnion<readonly [z.ZodObject<{
 export type ApproverClause = z.infer<typeof approverClauseSchema>;
 /** Granularity of a held element. */
 export declare const HoldScope: z.ZodEnum<{
-    workflow: "workflow";
     job: "job";
     step: "step";
+    workflow: "workflow";
 }>;
 export type HoldScope = z.infer<typeof HoldScope>;
 /** What triggered the hold: a context policy (mandatory) or SDK code (explicit). */
@@ -32,6 +32,13 @@ export declare const TriggerSource: z.ZodEnum<{
     explicit: "explicit";
 }>;
 export type TriggerSource = z.infer<typeof TriggerSource>;
+/**
+ * A valid manual-approval timeout: a positive integer number of seconds. The
+ * single source of truth for the positivity invariant — referenced by the
+ * `step.approval-request` wire schema, the SDK compile-time check, and the
+ * orchestrator's pre-dispatch approval-timeout guard.
+ */
+export declare const approvalTimeoutSecondsSchema: z.ZodNumber;
 /**
  * The normalized requirement attached to a held element. `clauses` is a flat
  * AND list; an empty list means "any approval-capable org member". `expiresAt`

package/dist/approval/types.js

@@ -25,6 +25,13 @@ const HoldScope = z.enum([
 /** What triggered the hold: a context policy (mandatory) or SDK code (explicit). */
 const TriggerSource = z.enum(["context", "explicit"]);
 /**
+* A valid manual-approval timeout: a positive integer number of seconds. The
+* single source of truth for the positivity invariant — referenced by the
+* `step.approval-request` wire schema, the SDK compile-time check, and the
+* orchestrator's pre-dispatch approval-timeout guard.
+*/
+const approvalTimeoutSecondsSchema = z.number().int().positive();
+/**
 * The normalized requirement attached to a held element. `clauses` is a flat
 * AND list; an empty list means "any approval-capable org member". `expiresAt`
 * is an ISO timestamp; on expiry the element is rejected.
@@ -37,6 +44,6 @@ const approvalRequirementSchema = z.object({
 /** An individual approve/reject decision recorded against a held element. */
 const ApprovalDecision = z.enum(["approve", "reject"]);
 //#endregion
-export { ApprovalDecision, HoldScope, TriggerSource, approvalRequirementSchema, approverClauseSchema };
+export { ApprovalDecision, HoldScope, TriggerSource, approvalRequirementSchema, approvalTimeoutSecondsSchema, approverClauseSchema };
 
 //# sourceMappingURL=types.js.map

package/dist/artifacts/name.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Artifact name contract, shared by every tier that handles a name.
+ *
+ * An artifact name is the user-facing key an artifact is uploaded under and
+ * downloaded by, and it becomes a path segment of the storage object key. It is
+ * therefore restricted to a conservative, filesystem/URL-safe character set
+ * (letters, digits, `.`, `_`, `-`) with a bounded length, so names stay portable
+ * across storage backends and can never escape their per-run prefix.
+ *
+ * The schema lives in the engine — not the SDK — because it is a trust-boundary
+ * contract, not just an SDK ergonomic. The orchestrator validates every inbound
+ * name against it before minting a presigned PUT, the agent sandbox validates it
+ * at the call site, and `@kici-dev/sdk` re-exports it so workflow authors keep
+ * the same public symbol. One definition, three consumers: a name the SDK
+ * accepts is exactly a name the orchestrator accepts.
+ *
+ * The rejection **message** lives here too, for the same reason: a workflow
+ * author must read one sentence whichever tier refused the name.
+ *
+ * Pure Zod, no `node:*` imports — safe for the browser-facing engine barrel.
+ */
+import { z } from 'zod';
+/** Maximum length of an artifact name, in characters. */
+export declare const ARTIFACT_NAME_MAX_LENGTH = 128;
+/**
+ * Zod schema validating an artifact name.
+ *
+ * The character set and the all-dots exclusion together make the mapping from a
+ * name to its storage segment the identity, and therefore injective: two
+ * distinct accepted names can never produce the same key. A name outside the
+ * character set would be sanitized onto some other name's segment (`a/b` and
+ * `a_b` both become `a_b`), and an all-dots name has to be escaped away from a
+ * path-canonicalizable segment (`.` and `_.` would both become `_.`). Either
+ * collision lets a second upload silently overwrite the first object while both
+ * records keep their own hash, so both are rejected outright.
+ */
+export declare const ArtifactNameSchema: z.ZodString;
+/** Prefix every artifact-name rejection carries, so callers can match on it. */
+export declare const ARTIFACT_INVALID_NAME_PREFIX = "invalid artifact name";
+/**
+ * Message for a name that fails the {@link ArtifactNameSchema} contract.
+ *
+ * Lives beside the schema, not in either consumer, because the rejection wording
+ * is part of the contract: the agent sandbox validates at the call site and the
+ * orchestrator validates at the trust boundary, and a workflow author must read
+ * the same sentence whichever tier refused the name. `detail` is one of the
+ * schema's own fixed messages (via {@link checkArtifactName}), never caller
+ * input.
+ */
+export declare function artifactInvalidNameError(detail: string): string;
+/**
+ * Validate a name against the shared contract, returning the schema's own
+ * message on failure and `null` when the name conforms.
+ *
+ * Only the first issue is reported. The schema's checks are ordered and each
+ * carries a single fixed message, so one detail fully describes the violation —
+ * and rendering exactly one keeps every tier's message identical.
+ */
+export declare function checkArtifactName(name: string): string | null;
+//# sourceMappingURL=name.d.ts.map

package/dist/artifacts/name.js

@@ -0,0 +1,71 @@
+import "../rolldown-runtime-ClRpJifh.js";
+import { z } from "zod";
+//#region src/artifacts/name.ts
+/**
+* Artifact name contract, shared by every tier that handles a name.
+*
+* An artifact name is the user-facing key an artifact is uploaded under and
+* downloaded by, and it becomes a path segment of the storage object key. It is
+* therefore restricted to a conservative, filesystem/URL-safe character set
+* (letters, digits, `.`, `_`, `-`) with a bounded length, so names stay portable
+* across storage backends and can never escape their per-run prefix.
+*
+* The schema lives in the engine — not the SDK — because it is a trust-boundary
+* contract, not just an SDK ergonomic. The orchestrator validates every inbound
+* name against it before minting a presigned PUT, the agent sandbox validates it
+* at the call site, and `@kici-dev/sdk` re-exports it so workflow authors keep
+* the same public symbol. One definition, three consumers: a name the SDK
+* accepts is exactly a name the orchestrator accepts.
+*
+* The rejection **message** lives here too, for the same reason: a workflow
+* author must read one sentence whichever tier refused the name.
+*
+* Pure Zod, no `node:*` imports — safe for the browser-facing engine barrel.
+*/
+/** Maximum length of an artifact name, in characters. */
+const ARTIFACT_NAME_MAX_LENGTH = 128;
+/**
+* Zod schema validating an artifact name.
+*
+* The character set and the all-dots exclusion together make the mapping from a
+* name to its storage segment the identity, and therefore injective: two
+* distinct accepted names can never produce the same key. A name outside the
+* character set would be sanitized onto some other name's segment (`a/b` and
+* `a_b` both become `a_b`), and an all-dots name has to be escaped away from a
+* path-canonicalizable segment (`.` and `_.` would both become `_.`). Either
+* collision lets a second upload silently overwrite the first object while both
+* records keep their own hash, so both are rejected outright.
+*/
+const ArtifactNameSchema = z.string().min(1, "artifact name must be non-empty").max(128, `artifact name must be <= 128 chars`).regex(/^[A-Za-z0-9._-]+$/, "artifact name may only contain letters, digits, \".\", \"_\", and \"-\"").refine((n) => !/^\.+$/.test(n), "artifact name must contain more than dots");
+/** Prefix every artifact-name rejection carries, so callers can match on it. */
+const ARTIFACT_INVALID_NAME_PREFIX = "invalid artifact name";
+/**
+* Message for a name that fails the {@link ArtifactNameSchema} contract.
+*
+* Lives beside the schema, not in either consumer, because the rejection wording
+* is part of the contract: the agent sandbox validates at the call site and the
+* orchestrator validates at the trust boundary, and a workflow author must read
+* the same sentence whichever tier refused the name. `detail` is one of the
+* schema's own fixed messages (via {@link checkArtifactName}), never caller
+* input.
+*/
+function artifactInvalidNameError(detail) {
+	return `${ARTIFACT_INVALID_NAME_PREFIX}: ${detail}`;
+}
+/**
+* Validate a name against the shared contract, returning the schema's own
+* message on failure and `null` when the name conforms.
+*
+* Only the first issue is reported. The schema's checks are ordered and each
+* carries a single fixed message, so one detail fully describes the violation —
+* and rendering exactly one keeps every tier's message identical.
+*/
+function checkArtifactName(name) {
+	const parsed = ArtifactNameSchema.safeParse(name);
+	if (parsed.success) return null;
+	return parsed.error.issues[0]?.message ?? "artifact name is not permitted";
+}
+//#endregion
+export { ARTIFACT_INVALID_NAME_PREFIX, ARTIFACT_NAME_MAX_LENGTH, ArtifactNameSchema, artifactInvalidNameError, checkArtifactName };
+
+//# sourceMappingURL=name.js.map

package/dist/audit/access-log-policy.d.ts

@@ -27,8 +27,8 @@ import { type ActorPrincipal } from '../protocol/messages/actor.js';
 /** Discriminator for the per-action policy entry. */
 export declare const AccessLogPolicyKind: z.ZodEnum<{
     always: "always";
-    sample: "sample";
     rate_limit: "rate_limit";
+    sample: "sample";
 }>;
 export type AccessLogPolicyKind = z.infer<typeof AccessLogPolicyKind>;
 export type AccessLogPolicy = {

package/dist/audit/access-log-policy.js

@@ -67,6 +67,7 @@ const POLICY_BY_ACTION = {
 		allowedRate: .1
 	},
 	"attestations.read": { kind: "always" },
+	"artifacts.read": { kind: "always" },
 	"event_log.list.read": {
 		kind: "sample",
 		allowedRate: .05
@@ -164,8 +165,15 @@ const POLICY_BY_ACTION = {
 	"fleet.pre_boot.send": { kind: "always" },
 	"global_workflows.update": { kind: "always" },
 	"org_settings.dashboard_write_policy.update": { kind: "always" },
+	"trust_policy.updated": { kind: "always" },
 	"cluster_name.update": { kind: "always" },
 	"attestation.retry": { kind: "always" },
+	"db.fresh": { kind: "always" },
+	"db.ensure": { kind: "always" },
+	"db.create_role": { kind: "always" },
+	"db.create_readonly_user": { kind: "always" },
+	"db.reindex": { kind: "always" },
+	"db.refresh_collation_version": { kind: "always" },
 	"access_log.list.read": { kind: "always" },
 	"event_dlq.list.read": {
 		kind: "sample",

package/dist/audit/activity.d.ts

@@ -31,8 +31,8 @@ export type ActivityRowSource = z.infer<typeof ActivityRowSource>;
  */
 export declare const ActivityFilterSource: z.ZodEnum<{
     access_log: "access_log";
-    audit_log: "audit_log";
     all: "all";
+    audit_log: "audit_log";
 }>;
 export type ActivityFilterSource = z.infer<typeof ActivityFilterSource>;
 /**
@@ -51,11 +51,11 @@ export declare const activityRowSchema: z.ZodObject<{
     }>;
     createdAt: z.ZodString;
     actorType: z.ZodEnum<{
-        user: "user";
         api_key: "api_key";
-        service_account: "service_account";
         platform_operator: "platform_operator";
+        service_account: "service_account";
         system: "system";
+        user: "user";
     }>;
     actorId: z.ZodString;
     actorMeta: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -65,18 +65,18 @@ export declare const activityRowSchema: z.ZodObject<{
     targetType: z.ZodNullable<z.ZodString>;
     targetId: z.ZodNullable<z.ZodString>;
     outcome: z.ZodNullable<z.ZodEnum<{
-        error: "error";
         allowed: "allowed";
         denied: "denied";
+        error: "error";
     }>>;
     errorMessage: z.ZodNullable<z.ZodString>;
     details: z.ZodNullable<z.ZodUnknown>;
     requestId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     origin: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        admin_cli: "admin_cli";
+        admin_http: "admin_http";
         agent: "agent";
         platform_proxy: "platform_proxy";
-        admin_http: "admin_http";
-        admin_cli: "admin_cli";
     }>>>;
 }, z.core.$strip>;
 export type ActivityRow = z.infer<typeof activityRowSchema>;
@@ -88,28 +88,28 @@ export type ActivityRow = z.infer<typeof activityRowSchema>;
 export declare const activityFilterSchema: z.ZodObject<{
     source: z.ZodDefault<z.ZodEnum<{
         access_log: "access_log";
-        audit_log: "audit_log";
         all: "all";
+        audit_log: "audit_log";
     }>>;
     actorType: z.ZodOptional<z.ZodEnum<{
-        user: "user";
         api_key: "api_key";
-        service_account: "service_account";
         platform_operator: "platform_operator";
+        service_account: "service_account";
         system: "system";
+        user: "user";
     }>>;
     actorId: z.ZodOptional<z.ZodString>;
     action: z.ZodOptional<z.ZodString>;
     outcome: z.ZodOptional<z.ZodEnum<{
-        error: "error";
         allowed: "allowed";
         denied: "denied";
+        error: "error";
     }>>;
     origin: z.ZodOptional<z.ZodEnum<{
+        admin_cli: "admin_cli";
+        admin_http: "admin_http";
         agent: "agent";
         platform_proxy: "platform_proxy";
-        admin_http: "admin_http";
-        admin_cli: "admin_cli";
     }>>;
     targetType: z.ZodOptional<z.ZodString>;
     targetId: z.ZodOptional<z.ZodString>;

package/dist/audit/retention-policy.js

@@ -20,6 +20,7 @@ const ACCESS_LOG_WARM_DAYS = {
 	"run.orch_logs.read": 30,
 	"step.logs.read": 30,
 	"attestations.read": 30,
+	"artifacts.read": 30,
 	"event_log.list.read": 30,
 	"context.list.read": 30,
 	"context.get.read": 30,
@@ -70,8 +71,15 @@ const ACCESS_LOG_WARM_DAYS = {
 	"fleet.pre_boot.send": 180,
 	"global_workflows.update": 180,
 	"org_settings.dashboard_write_policy.update": 180,
+	"trust_policy.updated": 180,
 	"cluster_name.update": 180,
 	"attestation.retry": 180,
+	"db.fresh": 180,
+	"db.ensure": 180,
+	"db.create_role": 180,
+	"db.create_readonly_user": 180,
+	"db.reindex": 180,
+	"db.refresh_collation_version": 180,
 	"event_dlq.list.read": 30,
 	"event_dlq.retry": 180,
 	"event_dlq.discard": 180,
@@ -266,6 +274,7 @@ const ACCESS_LOG_COLD_DAYS = {
 	"run.orch_logs.read": 180,
 	"step.logs.read": 180,
 	"attestations.read": 180,
+	"artifacts.read": 180,
 	"event_log.list.read": 180,
 	"context.list.read": 180,
 	"context.get.read": 180,
@@ -316,8 +325,15 @@ const ACCESS_LOG_COLD_DAYS = {
 	"fleet.pre_boot.send": 730,
 	"global_workflows.update": 730,
 	"org_settings.dashboard_write_policy.update": 730,
+	"trust_policy.updated": 730,
 	"cluster_name.update": 730,
 	"attestation.retry": 730,
+	"db.fresh": 730,
+	"db.ensure": 730,
+	"db.create_role": 730,
+	"db.create_readonly_user": 730,
+	"db.reindex": 730,
+	"db.refresh_collation_version": 730,
 	"event_dlq.list.read": 180,
 	"event_dlq.retry": 730,
 	"event_dlq.discard": 730,

package/dist/billing/plan-type.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+/**
+ * Plan tier discriminator. Single source of truth for the four hosted tiers
+ * (`free`, `pro`, `team`, `business`); Enterprise is `pro` / `team` /
+ * `business` with a custom `plan_config` override, not a tier of its own.
+ *
+ * Lives in the engine rather than the Platform package because the browser
+ * dashboard needs the same vocabulary and cannot import a private package.
+ * Pure Zod with no Node built-ins, so it is safe on the engine barrel.
+ *
+ * Use `PlanType` (the Zod schema) inside other schemas; use `PlanType.enum.X`
+ * to reference a specific value in code; use `type PlanType` for the derived
+ * TypeScript type.
+ */
+export declare const PlanType: z.ZodEnum<{
+    business: "business";
+    free: "free";
+    pro: "pro";
+    team: "team";
+}>;
+export type PlanType = z.infer<typeof PlanType>;
+/**
+ * The purchasable subset of `PlanType`. `free` is the default state an org
+ * lands in, never something checkout can be started for, so every checkout /
+ * upgrade / subscription-metadata surface takes this narrower enum instead of
+ * re-spelling the three paid tiers by hand.
+ */
+export declare const PaidPlanType: z.ZodEnum<{
+    business: "business";
+    pro: "pro";
+    team: "team";
+}>;
+export type PaidPlanType = z.infer<typeof PaidPlanType>;
+/** Every hosted tier, in ascending rank order. */
+export declare const PLAN_TYPES: readonly PlanType[];
+/**
+ * Narrow a tier to the purchasable subset (everything except `free`). Derived
+ * from `PaidPlanType`, so a new paid tier needs no edit here and no edit at any
+ * call site that used to spell the paid set out as a boolean chain.
+ */
+export declare function isPaidTier(tier: PlanType): tier is PaidPlanType;
+/**
+ * Rank a plan tier for up/down direction comparisons.
+ *
+ * The `Object.hasOwn` guard is not defensive padding: a bare index into an
+ * object literal inherits `Object.prototype`, so `planRank('toString')` would
+ * return a *function* rather than a number, and any `??`-style fallback a
+ * caller wrapped it in would never fire. Every current caller passes a
+ * `safeParse`d tier, so the throw is unreachable in practice — but a loud
+ * error beats silently ranking a forged string above `business`.
+ */
+export declare function planRank(p: PlanType): number;
+//# sourceMappingURL=plan-type.d.ts.map

package/dist/billing/plan-type.js

@@ -0,0 +1,70 @@
+import "../rolldown-runtime-ClRpJifh.js";
+import { z } from "zod";
+//#region src/billing/plan-type.ts
+/**
+* Plan tier discriminator. Single source of truth for the four hosted tiers
+* (`free`, `pro`, `team`, `business`); Enterprise is `pro` / `team` /
+* `business` with a custom `plan_config` override, not a tier of its own.
+*
+* Lives in the engine rather than the Platform package because the browser
+* dashboard needs the same vocabulary and cannot import a private package.
+* Pure Zod with no Node built-ins, so it is safe on the engine barrel.
+*
+* Use `PlanType` (the Zod schema) inside other schemas; use `PlanType.enum.X`
+* to reference a specific value in code; use `type PlanType` for the derived
+* TypeScript type.
+*/
+const PlanType = z.enum([
+	"free",
+	"pro",
+	"team",
+	"business"
+]);
+/**
+* The purchasable subset of `PlanType`. `free` is the default state an org
+* lands in, never something checkout can be started for, so every checkout /
+* upgrade / subscription-metadata surface takes this narrower enum instead of
+* re-spelling the three paid tiers by hand.
+*/
+const PaidPlanType = PlanType.exclude(["free"]);
+/** Every hosted tier, in ascending rank order. */
+const PLAN_TYPES = PlanType.options;
+/**
+* Narrow a tier to the purchasable subset (everything except `free`). Derived
+* from `PaidPlanType`, so a new paid tier needs no edit here and no edit at any
+* call site that used to spell the paid set out as a boolean chain.
+*/
+function isPaidTier(tier) {
+	return PaidPlanType.safeParse(tier).success;
+}
+/**
+* Monotonic tier rank for up/down comparison. free < pro < team < business.
+*
+* Typed `Record<PlanType, number>` on purpose: adding a tier to the enum
+* without ranking it fails `pnpm typecheck` instead of silently yielding
+* `undefined` at runtime.
+*/
+const PLAN_RANK = {
+	[PlanType.enum.free]: 0,
+	[PlanType.enum.pro]: 1,
+	[PlanType.enum.team]: 2,
+	[PlanType.enum.business]: 3
+};
+/**
+* Rank a plan tier for up/down direction comparisons.
+*
+* The `Object.hasOwn` guard is not defensive padding: a bare index into an
+* object literal inherits `Object.prototype`, so `planRank('toString')` would
+* return a *function* rather than a number, and any `??`-style fallback a
+* caller wrapped it in would never fire. Every current caller passes a
+* `safeParse`d tier, so the throw is unreachable in practice — but a loud
+* error beats silently ranking a forged string above `business`.
+*/
+function planRank(p) {
+	if (!Object.hasOwn(PLAN_RANK, p)) throw new Error(`planRank: '${String(p)}' is not a plan tier`);
+	return PLAN_RANK[p];
+}
+//#endregion
+export { PLAN_TYPES, PaidPlanType, PlanType, isPaidTier, planRank };
+
+//# sourceMappingURL=plan-type.js.map

package/dist/bundler/rolldown-config.d.ts

@@ -22,7 +22,7 @@ export interface WorkflowBundleOptions {
  */
 export declare function createWorkflowBundleConfig(options: WorkflowBundleOptions): {
     input: string;
-    platform: "node";
+    platform: 'node';
     external: string[];
     treeshake: boolean;
     cwd: string | undefined;
@@ -33,8 +33,8 @@ export declare function createWorkflowBundleConfig(options: WorkflowBundleOption
     };
     output: {
         file: string | undefined;
-        format: "es";
-        sourcemap: boolean | "inline";
+        format: 'es';
+        sourcemap: "inline" | boolean;
         inlineDynamicImports: boolean;
     };
 };

package/dist/check-mode.d.ts

@@ -23,11 +23,11 @@ export type CheckMode = z.infer<typeof CheckMode>;
  * dry-run -> "would change", no_check -> "no check".
  */
 export declare const CheckStepOutcome: z.ZodEnum<{
-    skipped: "skipped";
     applied: "applied";
     declined: "declined";
     "dry-run": "dry-run";
     no_check: "no_check";
+    skipped: "skipped";
 }>;
 export type CheckStepOutcome = z.infer<typeof CheckStepOutcome>;
 //# sourceMappingURL=check-mode.d.ts.map

package/dist/context/concurrency-strategy.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+/**
+ * What a context does with a run that arrives while its concurrency limit is
+ * saturated. Single source of truth shared by the dashboard protection form, the
+ * context domain type, the orchestrator's context store and protection
+ * aggregate, and the concurrency gate.
+ *
+ * - `queue` — hold the run until a slot frees. The strategy applied when a
+ *   context sets a limit but no explicit strategy.
+ * - `cancel-pending` — drop the already-waiting run in favour of the new one.
+ *
+ * Not to be confused with the protection gates' `action` vocabulary
+ * (`'hold' | 'wait' | 'queue'` on `ProtectionGateResult`), which shares the
+ * `queue` spelling and means something else entirely.
+ *
+ * The orchestrator's `contexts.concurrency_strategy` column stays typed as
+ * `string` so a row written by a different orchestrator version never fails to
+ * map; this enum is the vocabulary every writer validates against.
+ *
+ * Pure Zod, no `node:*` imports — safe for the browser-facing engine barrel.
+ */
+export declare const ConcurrencyStrategy: z.ZodEnum<{
+    "cancel-pending": "cancel-pending";
+    queue: "queue";
+}>;
+export type ConcurrencyStrategy = z.infer<typeof ConcurrencyStrategy>;
+/**
+ * The strategy applied when a context carries an effective concurrency limit but
+ * no explicit strategy. Lives beside the enum so the dashboard form and the
+ * orchestrator aggregate cannot pick different defaults — a mismatch reads as a
+ * permanently dirty protection form.
+ */
+export declare const DEFAULT_CONCURRENCY_STRATEGY: ConcurrencyStrategy;
+//# sourceMappingURL=concurrency-strategy.d.ts.map

package/dist/context/concurrency-strategy.js

@@ -0,0 +1,35 @@
+import "../rolldown-runtime-ClRpJifh.js";
+import { z } from "zod";
+//#region src/context/concurrency-strategy.ts
+/**
+* What a context does with a run that arrives while its concurrency limit is
+* saturated. Single source of truth shared by the dashboard protection form, the
+* context domain type, the orchestrator's context store and protection
+* aggregate, and the concurrency gate.
+*
+* - `queue` — hold the run until a slot frees. The strategy applied when a
+*   context sets a limit but no explicit strategy.
+* - `cancel-pending` — drop the already-waiting run in favour of the new one.
+*
+* Not to be confused with the protection gates' `action` vocabulary
+* (`'hold' | 'wait' | 'queue'` on `ProtectionGateResult`), which shares the
+* `queue` spelling and means something else entirely.
+*
+* The orchestrator's `contexts.concurrency_strategy` column stays typed as
+* `string` so a row written by a different orchestrator version never fails to
+* map; this enum is the vocabulary every writer validates against.
+*
+* Pure Zod, no `node:*` imports — safe for the browser-facing engine barrel.
+*/
+const ConcurrencyStrategy = z.enum(["queue", "cancel-pending"]);
+/**
+* The strategy applied when a context carries an effective concurrency limit but
+* no explicit strategy. Lives beside the enum so the dashboard form and the
+* orchestrator aggregate cannot pick different defaults — a mismatch reads as a
+* permanently dirty protection form.
+*/
+const DEFAULT_CONCURRENCY_STRATEGY = ConcurrencyStrategy.enum.queue;
+//#endregion
+export { ConcurrencyStrategy, DEFAULT_CONCURRENCY_STRATEGY };
+
+//# sourceMappingURL=concurrency-strategy.js.map

package/dist/context/held-run-job-id.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Run-wide sentinel values for `held_runs.job_id`.
+ *
+ * The column normally carries the held job's expanded name (a matrix child
+ * keeps its own `build (18)` form), which is what the dashboard approval queue
+ * renders and what `kici approve --job <name>` resolves. Some holds are not
+ * scoped to a single job and use a sentinel instead: the workflow install gate,
+ * and the PR-wide security holds the org trust policy raises.
+ *
+ * The orchestrator writes these values and the dashboard reads them back to
+ * render a human-meaningful row label, so they live here rather than as a
+ * literal on each side — a rename on the writer must not silently stop the
+ * reader from recognising the sentinel.
+ */
+/** Sentinel `job_id` for the PR-wide workflow-modification security hold. */
+export declare const WORKFLOW_MODIFICATION_JOB_ID = "__workflow_modification__";
+/**
+ * Sentinel `job_id` per PR-wide security-hold reason, written when the org
+ * trust policy holds a run.
+ *
+ * `workflow_modification` keeps its historical value so holds created before
+ * the policy was enforced still resolve by job id.
+ *
+ * Covers the org trust policy's own three arms ONLY. `context_trust` is
+ * deliberately absent: that hold comes from the per-context minimum-trust gate,
+ * which writes the real expanded job name (a matrix child keeps its `build (18)`
+ * form) so the operator can approve that job specifically. A sentinel for it
+ * would be a value nothing ever writes.
+ *
+ * Keyed by the orchestrator's `TrustPolicyHoldReason`; the key set is asserted
+ * against that type in the orchestrator's own test rather than importing it
+ * here (the engine must not depend on the orchestrator).
+ */
+export declare const SECURITY_HOLD_JOB_IDS: {
+    readonly workflow_modification: "__workflow_modification__";
+    readonly fork_pr: '__fork_pr__';
+    readonly unknown_contributor: '__unknown_contributor__';
+};
+/** Human-meaningful label per security-hold sentinel, rendered by the dashboard. */
+export declare const SECURITY_HOLD_JOB_LABELS: Record<string, string>;
+/** Sentinel `job_id` prefix for the workflow install gate, suffixed by the workflow name. */
+export declare const INSTALL_JOB_ID_PREFIX = "__install__";
+/** The install-gate sentinel `job_id` for a workflow. */
+export declare function installGateJobId(workflowName: string): string;
+//# sourceMappingURL=held-run-job-id.d.ts.map