@kici-dev/orchestrator 0.1.26 → 0.2.0

package/dist/contexts/context-store.d.ts

@@ -0,0 +1,100 @@
+import { type Kysely } from 'kysely';
+import type { ConcurrencyStrategy, Context as EngineContext } from '@kici-dev/engine';
+import type { Database, Context } from '../db/types.js';
+/** Thrown by `delete` when pending held runs reference the context. */
+export declare class ContextDeleteBlockedError extends Error {
+    readonly pendingCount: number;
+    constructor(pendingCount: number);
+}
+/**
+ * Map a DB context row (snake_case) to the engine Context type (camelCase).
+ *
+ * Kysely returns JSONB columns as strings; this function parses them into arrays.
+ */
+export declare function toContext(row: Context): EngineContext;
+/** Fields accepted when creating a context. */
+export interface ContextCreateInput {
+    name: string;
+    type?: 'fixed' | 'glob';
+    globPattern?: string | null;
+    branchRestrictions?: string[];
+    triggerTypeFilters?: string[];
+    repoPatterns?: string[];
+    concurrencyLimit?: number | null;
+    concurrencyStrategy?: ConcurrencyStrategy;
+    concurrencyTimeoutMs?: number;
+    requiredReviewers?: string[] | null;
+    waitTimerSeconds?: number | null;
+    holdExpirySeconds?: number;
+    minimumTrust?: 'known' | 'trusted' | null;
+    allowLocalExecution?: boolean;
+    enabled?: boolean;
+    createdBy?: string | null;
+}
+/**
+ * Fields accepted when updating a context.
+ *
+ * Convention for every nullable column: `undefined` means "the caller did not
+ * mention this field, leave the column alone"; `null` means "clear it". The two
+ * are distinct on the wire (`contextUpdateRequestSchema` declares these fields
+ * `.nullable().optional()`), so the handler forwards both verbatim and `update`
+ * below writes the column's cleared state for an explicit `null` — SQL NULL for
+ * the nullable columns, and the empty array for `branchRestrictions`, whose
+ * column is `jsonb NOT NULL DEFAULT '[]'`.
+ */
+export interface ContextUpdateInput {
+    name?: string;
+    type?: 'fixed' | 'glob';
+    globPattern?: string | null;
+    branchRestrictions?: string[] | null;
+    triggerTypeFilters?: string[];
+    repoPatterns?: string[];
+    concurrencyLimit?: number | null;
+    concurrencyStrategy?: ConcurrencyStrategy | null;
+    concurrencyTimeoutMs?: number;
+    requiredReviewers?: string[] | null;
+    waitTimerSeconds?: number | null;
+    holdExpirySeconds?: number | null;
+    minimumTrust?: 'known' | 'trusted' | null;
+    allowLocalExecution?: boolean;
+    enabled?: boolean;
+}
+/**
+ * Data access layer for contexts.
+ */
+export declare class ContextStore {
+    private readonly db;
+    constructor(db: Kysely<Database>);
+    /** List all contexts for an org, ordered by name. */
+    list(orgId: string): Promise<Context[]>;
+    /** Get a single context by org + id. Returns null if not found. */
+    get(orgId: string, id: string): Promise<Context | null>;
+    /** Get a single context by org + name. Returns null if not found. */
+    getByName(orgId: string, name: string): Promise<Context | null>;
+    /** Create a new context. Returns the created row. */
+    create(orgId: string, data: ContextCreateInput): Promise<Context>;
+    /** Update a context. Returns the updated row, or null if not found. */
+    update(orgId: string, id: string, updates: ContextUpdateInput): Promise<Context | null>;
+    /**
+     * Delete a context.
+     *
+     * Bindings, variables, and source overrides cascade away via their FK.
+     * Terminal held-run history survives with a null `context_id` (the FK
+     * uses ON DELETE SET NULL). Pending held runs still reference the
+     * context, so deletion is blocked with `ContextDeleteBlockedError`
+     * until they are approved or rejected.
+     */
+    delete(orgId: string, id: string): Promise<boolean>;
+    /**
+     * Match a context name against org contexts.
+     *
+     * First tries exact name match (for fixed contexts).
+     * If no exact match, scans glob-type contexts and uses picomatch. When the
+     * name matches more than one glob pattern, the most-specific pattern wins
+     * (most literal characters; ties break toward fewer wildcards, then name
+     * ascending) so the winning context — and its protection rules — is
+     * deterministic across dispatches. Returns the matching context or null.
+     */
+    matchContext(orgId: string, name: string): Promise<Context | null>;
+}
+//# sourceMappingURL=context-store.d.ts.map

package/dist/contexts/glob-specificity.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Specificity scoring for glob environment patterns.
+ *
+ * Used to resolve which glob context governs a run when an environment name
+ * matches more than one pattern. The most-specific pattern (most literal
+ * characters) wins; ties break toward fewer wildcards, then name ascending —
+ * a total, deterministic order.
+ */
+export interface GlobSpecificity {
+    /** Count of characters that are NOT glob metacharacters. Higher = more specific. */
+    literals: number;
+    /** Count of characters that ARE glob metacharacters. Lower = more specific. */
+    wildcards: number;
+}
+export declare function globSpecificityScore(pattern: string): GlobSpecificity;
+/**
+ * Compares two glob contexts, ranking the more specific first.
+ * Returns <0 when `a` is more specific than `b`, >0 when less, 0 only when
+ * pattern-score and name are identical.
+ *
+ * Order: literals desc, then wildcards asc, then name asc.
+ */
+export declare function compareGlobSpecificity(a: {
+    pattern: string;
+    name: string;
+}, b: {
+    pattern: string;
+    name: string;
+}): number;
+//# sourceMappingURL=glob-specificity.d.ts.map

package/dist/{environments → contexts}/held-runs.d.ts

@@ -3,7 +3,8 @@
  *
  * Manages the lifecycle: pending -> approved/rejected/expired.
  */
-import { type Kysely } from 'kysely';
+import { Kysely } from 'kysely';
+import { z } from 'zod';
 import { type ApprovalRequirement, type ApproverClause, type StepApprovalPayload, ApprovalDecision, HoldScope, TriggerSource } from '@kici-dev/engine';
 import type { Database, HeldRun, HeldRunApproval } from '../db/types.js';
 /** Status values for held runs (held_runs table). */
@@ -14,20 +15,32 @@ export declare enum HeldRunStatus {
     Expired = "expired",
     Released = "released"
 }
+/**
+ * Reason a run was held in the security queue. Persisted verbatim in
+ * `held_runs.reason` and switched on by `buildSecurityHoldSummary`.
+ */
+export declare const SecurityHoldReason: z.ZodEnum<{
+    context_trust: "context_trust";
+    fork_pr: "fork_pr";
+    unknown_contributor: "unknown_contributor";
+    workflow_modification: "workflow_modification";
+}>;
+export type SecurityHoldReason = z.infer<typeof SecurityHoldReason>;
 /** Data required to create a held run. */
 export interface CreateHeldRunData {
     runId: string;
     jobId: string;
-    environmentId: string;
+    /** Bound context id, or null for context-free holds (e.g. workflow_modification). */
+    contextId: string | null;
     holdType: string;
     reason: string;
     expiresAt: Date;
-    /** Queue type: 'environment' (default) or 'security'. */
-    queueType?: 'environment' | 'security';
+    /** Queue type: 'context' (default) or 'security'. */
+    queueType?: 'context' | 'security';
 }
 /**
  * Data required to create a generalized approval hold. Unlike the legacy
- * environment-only `create()`, this carries the hold scope, trigger source,
+ * context-only `create()`, this carries the hold scope, trigger source,
  * optional step index, and the normalized approval requirement.
  */
 export interface CreateHoldData {
@@ -37,17 +50,17 @@ export interface CreateHoldData {
     scope: HoldScope;
     /** Step index within the job for step-scoped holds; omit otherwise. */
     stepIndex?: number;
-    /** What triggered the hold (environment policy vs SDK requireApproval). */
+    /** What triggered the hold (context policy vs SDK requireApproval). */
     triggerSource: TriggerSource;
     /** The normalized requirement the hold must satisfy. */
     requirement: ApprovalRequirement;
-    /** Environment id, when the hold originates from an environment policy. */
-    environmentId?: string | null;
-    /** Queue type: 'environment' (default) or 'security'. */
-    queueType?: 'environment' | 'security';
+    /** Context id, when the hold originates from a context policy. */
+    contextId?: string | null;
+    /** Queue type: 'context' (default) or 'security'. */
+    queueType?: 'context' | 'security';
     /**
-     * Held-run `hold_type` discriminator. Defaults to `'approval'` (reviewer
-     * holds). The workflow install gate sets `'wait_timer'` / `'concurrency'` so
+     * Held-run `hold_type` discriminator — an engine `HoldType` member. Defaults
+     * to `reviewer`. The workflow install gate sets `timer` / `concurrency` so
      * the automated release sweeps can find their rows.
      */
     holdType?: string;
@@ -79,7 +92,7 @@ export interface ReleaseSignal {
     stepIndex: number | null;
     /**
      * What kind of gate created the hold. `explicit` (SDK `requireApproval`) holds
-     * a real root job and resumes by re-dispatching it; `environment` covers the
+     * a real root job and resumes by re-dispatching it; `context` covers the
      * workflow install-gate (wait-timer / concurrency / env approval) which resumes
      * by rebuilding the workflow dispatch context. The resume router keys off this
      * so a workflow-scoped explicit hold goes through the job re-dispatch path
@@ -100,7 +113,7 @@ export declare class HeldRunStore {
     create(orgId: string, data: CreateHeldRunData): Promise<HeldRun>;
     /**
      * Create a generalized approval hold (workflow/job/step scope, explicit or
-     * environment trigger) carrying a normalized `ApprovalRequirement`. Returns
+     * context trigger) carrying a normalized `ApprovalRequirement`. Returns
      * the created row.
      */
     createHold(orgId: string, data: CreateHoldData): Promise<HeldRun>;
@@ -151,13 +164,23 @@ export declare class HeldRunStore {
     /** List held runs for an org with optional filters. */
     listAll(orgId: string, options?: ListHeldRunsOptions): Promise<HeldRun[]>;
     /** List held runs for an org filtered by queue type with optional filters. */
-    listByQueueType(orgId: string, queueType: 'environment' | 'security', options?: ListHeldRunsOptions): Promise<HeldRun[]>;
+    listByQueueType(orgId: string, queueType: 'context' | 'security', options?: ListHeldRunsOptions): Promise<HeldRun[]>;
+    /**
+     * List pending `security` holds whose run belongs to a specific PR (and repo).
+     *
+     * Joins `execution_runs` on `run_id` and filters by `repo_identifier` +
+     * `pr_number` so `/kici approve|reject` only affects the commented PR's holds
+     * rather than every pending security hold in the org. A run with a NULL
+     * `pr_number` (non-PR run, or a legacy run predating the column) never matches
+     * the equality predicate, so such holds are never released here — fail-closed.
+     */
+    listPendingSecurityHoldsForPr(orgId: string, repoIdentifier: string, prNumber: number): Promise<HeldRun[]>;
     /**
      * Approve a pending held run, enforcing queue_type boundary.
-     * Prevents environment approvals from approving security holds and vice versa.
+     * Prevents context approvals from approving security holds and vice versa.
      * Throws if not found, not pending, or queue_type mismatch.
      */
-    approveByQueueType(orgId: string, heldRunId: string, approvedBy: string, queueType: 'environment' | 'security'): Promise<HeldRun>;
+    approveByQueueType(orgId: string, heldRunId: string, approvedBy: string, queueType: 'context' | 'security'): Promise<HeldRun>;
     /** Get a held run by run ID and job ID. Returns null if not found. */
     getByRunAndJob(orgId: string, runId: string, jobId: string): Promise<HeldRun | null>;
     /**
@@ -167,23 +190,20 @@ export declare class HeldRunStore {
      */
     listOverdue(): Promise<HeldRun[]>;
     /**
-     * Release overdue workflow `wait_timer` holds. The install-gate wait action
-     * pauses the workflow as a held run; on timer expiry it must RESUME (not
-     * fail like a reviewer-hold expiry). Flips each overdue pending
-     * `hold_type='wait_timer'`, `hold_scope='workflow'` row to `released` and
-     * returns a `ReleaseSignal` per row so the caller can resume the workflow.
-     * Runs BEFORE `expireOverdue()` so these rows leave the pending pool before
-     * the expire-and-fail sweep sees them.
+     * Release overdue workflow timer holds. The install-gate wait action pauses
+     * the workflow as a held run; on timer expiry it must RESUME (not fail like
+     * a reviewer-hold expiry). Flips each overdue pending `hold_type` timer,
+     * `hold_scope='workflow'` row to `released` and returns a `ReleaseSignal`
+     * per row so the caller can resume the workflow. Runs BEFORE
+     * `expireOverdue()` so these rows leave the pending pool before the
+     * expire-and-fail sweep sees them.
+     *
+     * The filter matches every persisted spelling of the timer hold type, so a
+     * row an un-upgraded orchestrator wrote as `wait_timer` still resumes rather
+     * than falling through to the expire-and-fail sweep. `hold_scope` is what
+     * keeps job-scoped dispatch-gate timer holds out of this sweep.
      */
     releaseDueWaitHolds(): Promise<ReleaseSignal[]>;
-    /**
-     * Release the oldest pending workflow `concurrency` hold for a group. Called
-     * when a concurrency slot frees on run completion. Flips the oldest matching
-     * pending row to `released` and returns its `ReleaseSignal`, or null when no
-     * concurrency hold is queued for the group. `group` matches the held row's
-     * `environment_id` (workflow-level install concurrency keys on the env id).
-     */
-    releaseConcurrencyHold(orgId: string, group: string): Promise<ReleaseSignal | null>;
     /**
      * Expire overdue pending runs. Called by the stale detector.
      * Sets status to 'expired' and resolved_at to now() for all
@@ -192,4 +212,16 @@ export declare class HeldRunStore {
      */
     expireOverdue(): Promise<number>;
 }
+/**
+ * Build a HeldRunStore backed by its own connection pool to the given
+ * orchestrator database URL. Mirrors `createPeerCredentialStoreFromUrl` /
+ * `createJoinTokenManagerFromUrl`; consumed by E2E tests that exercise the
+ * PR-scoped hold selection against the real deployed orchestrator DB.
+ */
+export declare function createHeldRunStoreFromUrl(databaseUrl: string, opts?: {
+    maxConnections?: number;
+}): {
+    store: HeldRunStore;
+    dispose: () => Promise<void>;
+};
 //# sourceMappingURL=held-runs.d.ts.map

package/dist/{environments → contexts}/index.d.ts

@@ -1,4 +1,4 @@
-export { EnvironmentStore, type EnvironmentCreateInput, type EnvironmentUpdateInput, } from './environment-store.js';
+export { ContextStore, type ContextCreateInput, type ContextUpdateInput } from './context-store.js';
 export { BindingStore } from './binding-store.js';
 export { VariableStore } from './variable-store.js';
 export { HeldRunStore, type CreateHeldRunData, type ListHeldRunsOptions } from './held-runs.js';

package/dist/contexts/protection/aggregate.d.ts

@@ -0,0 +1,43 @@
+import { ContextGateRejectReason, type ConcurrencyStrategy, type Context } from '@kici-dev/engine';
+import type { JobDispatchContext } from './pipeline.js';
+/** A single context's rejection under all-must-pass aggregation. */
+export interface ContextGateRejection {
+    context: string;
+    reason: ContextGateRejectReason;
+    detail: string;
+}
+/** Effective protection parameters after most-restrictive aggregation. */
+export interface EffectiveProtection {
+    minimumTrust?: 'known' | 'trusted';
+    requiredReviewers: string[];
+    waitTimerSeconds: number | null;
+    holdExpirySeconds: number;
+    concurrencyLimit: number | null;
+    concurrencyStrategy: ConcurrencyStrategy;
+}
+/**
+ * Evaluate each context's hard reject gates against the run context. A name
+ * with no `Context` record yields a `context_not_found` rejection. Returns all
+ * rejections (empty = every context passed the reject gates).
+ */
+export declare function evaluateMultiContextGates(envs: ReadonlyArray<{
+    name: string;
+    env: Context | undefined;
+}>, ctx: JobDispatchContext): ContextGateRejection[];
+/**
+ * Aggregate hold/wait/queue parameters across all bound contexts, most
+ * restrictive wins: trust = max tier, reviewers = sorted dedup union, wait timer
+ * = max, hold expiry = min, concurrency limit = min (tightest). The concurrency
+ * strategy follows the primary (first) context.
+ */
+export declare function aggregateProtectionParams(envs: ReadonlyArray<Context>): EffectiveProtection;
+/**
+ * Build a synthetic `Context` carrying the aggregated protection parameters,
+ * so the existing per-rule gate functions (trust/concurrency/reviewer/wait) can
+ * evaluate the all-must-pass holds in one pass. Branch/trigger/repo/enabled are
+ * already handled by `evaluateMultiContextGates`, so they are neutralized here.
+ */
+export declare function buildEffectiveContext(primary: Context, eff: EffectiveProtection): Context;
+/** Format a human-readable rejection reason naming the env(s) and rule(s). */
+export declare function formatMultiContextRejection(rejections: ReadonlyArray<ContextGateRejection>): string;
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/contexts/protection/branch-gate.d.ts

@@ -0,0 +1,5 @@
+import type { Context, ProtectionGateResult } from '@kici-dev/engine';
+import type { JobDispatchContext } from './pipeline.js';
+/** Evaluate branch restrictions, trigger type filters, and repo patterns. */
+export declare function evaluateBranchGate(env: Context, ctx: JobDispatchContext): ProtectionGateResult;
+//# sourceMappingURL=branch-gate.d.ts.map

package/dist/contexts/protection/concurrency-gate.d.ts

@@ -0,0 +1,4 @@
+import type { Context, ProtectionGateResult } from '@kici-dev/engine';
+/** Evaluate concurrency limits for the context. */
+export declare function evaluateConcurrencyGate(env: Context, currentRunningCount: number, _concurrencyGroup: string): ProtectionGateResult;
+//# sourceMappingURL=concurrency-gate.d.ts.map

package/dist/{environments → contexts}/protection/pipeline.d.ts

@@ -4,7 +4,7 @@
  * Gates evaluated in order: branch -> trust -> concurrency -> reviewer -> timer.
  * First non-pass result stops evaluation.
  */
-import type { Environment, ProtectionGateResult, TrustTier } from '@kici-dev/engine';
+import type { Context, ProtectionGateResult, TrustTier } from '@kici-dev/engine';
 /** Context needed for protection gate evaluation. */
 export interface JobDispatchContext {
     branch: string;
@@ -13,6 +13,6 @@ export interface JobDispatchContext {
     runId: string;
     jobId: string;
 }
-/** Evaluate all protection rules for an environment. */
-export declare function evaluateProtectionRules(env: Environment, ctx: JobDispatchContext, currentRunningCount: number, concurrencyGroup: string, trustTier?: TrustTier): Promise<ProtectionGateResult>;
+/** Evaluate all protection rules for a context. */
+export declare function evaluateProtectionRules(env: Context, ctx: JobDispatchContext, currentRunningCount: number, concurrencyGroup: string, trustTier?: TrustTier): Promise<ProtectionGateResult>;
 //# sourceMappingURL=pipeline.d.ts.map

package/dist/contexts/protection/reviewer-gate.d.ts

@@ -0,0 +1,4 @@
+import type { Context, ProtectionGateResult } from '@kici-dev/engine';
+/** Evaluate reviewer requirements for the context. */
+export declare function evaluateReviewerGate(env: Context): ProtectionGateResult;
+//# sourceMappingURL=reviewer-gate.d.ts.map

package/dist/{environments → contexts}/protection/satisfiability.d.ts

@@ -1,69 +1,69 @@
 /**
- * Registration-time satisfiability check for multi-environment job bindings.
+ * Registration-time satisfiability check for multi-context job bindings.
  *
- * When a job binds several environments (`environments: [...]`), every
- * environment's protection gates must pass for the job to ever dispatch
+ * When a job binds several contexts (`contexts: [...]`), every
+ * context's protection gates must pass for the job to ever dispatch
  * (all-must-pass aggregation — see `aggregate.ts`). Some of those gates are
- * decidable statically: if two bound environments restrict to disjoint fixed
+ * decidable statically: if two bound contexts restrict to disjoint fixed
  * branch sets, no run can ever satisfy both, so the binding is provably
  * unsatisfiable and should be rejected at registration rather than failing
  * silently at every future dispatch.
  *
  * This module intersects the statically-decidable set rules (branch, trigger
  * type, repository — only when every pattern is a literal, never a glob) plus
- * the `enabled` gate across the **resolved** bound environments, and reports the
- * first provably-empty intersection. Bound names that resolve to no environment
+ * the `enabled` gate across the **resolved** bound contexts, and reports the
+ * first provably-empty intersection. Bound names that resolve to no context
  * record are lenient — skipped, never rejected — matching the dispatch-time
  * behavior in `dispatch-matched-workflow.ts`. Any glob in a rule makes that rule
  * undecidable, so it is skipped here and left to the dispatch-time catch-all
- * (`evaluateMultiEnvGates`).
+ * (`evaluateMultiContextGates`).
  */
 import { z } from 'zod';
-import type { Environment } from '@kici-dev/engine';
+import type { Context } from '@kici-dev/engine';
 /** Which decidable rule made a binding unsatisfiable. */
 export declare const UnsatisfiableRule: z.ZodEnum<{
+    branch: "branch";
     enabled: "enabled";
     repo: "repo";
-    branch: "branch";
     trigger: "trigger";
 }>;
 export type UnsatisfiableRule = z.infer<typeof UnsatisfiableRule>;
-/** A provably-unsatisfiable multi-environment binding, naming the rule + reason. */
+/** A provably-unsatisfiable multi-context binding, naming the rule + reason. */
 export interface UnsatisfiableBinding {
     jobName: string;
-    environments: string[];
+    contexts: string[];
     rule: UnsatisfiableRule;
     message: string;
 }
 /**
- * Returns a precise problem when the bound environments can NEVER be jointly
- * satisfied (a disabled environment, or mutually-exclusive fixed restrictions
- * among the resolved environments), else `null`. Missing (unresolved) names are
- * skipped — a bound name with no environment record contributes no protection
+ * Returns a precise problem when the bound contexts can NEVER be jointly
+ * satisfied (a disabled context, or mutually-exclusive fixed restrictions
+ * among the resolved contexts), else `null`. Missing (unresolved) names are
+ * skipped — a bound name with no context record contributes no protection
  * rules and is lenient at dispatch, so it is not rejected here. Glob /
  * undecidable cases also return `null` and are caught at dispatch by
- * `evaluateMultiEnvGates`.
+ * `evaluateMultiContextGates`.
  *
- * `envs[i]` is the resolved `Environment` for `envNames[i]` (undefined when the
- * name has no environment record). Only the statically-known (non-dynamic) bound
+ * `envs[i]` is the resolved `Context` for `envNames[i]` (undefined when the
+ * name has no context record). Only the statically-known (non-dynamic) bound
  * names should be passed — dynamic elements are unknown at registration and the
  * all-must-pass semantics make the static subset's exclusivity still sound.
  */
-export declare function checkBindingSatisfiable(jobName: string, envs: ReadonlyArray<Environment | undefined>, envNames: readonly string[]): UnsatisfiableBinding | null;
+export declare function checkBindingSatisfiable(jobName: string, envs: ReadonlyArray<Context | undefined>, envNames: readonly string[]): UnsatisfiableBinding | null;
 /** Minimal lock-workflow shape needed to walk its jobs for satisfiability. */
 interface SatisfiabilityLockWorkflow {
     jobs?: readonly unknown[];
 }
 /**
  * Walk every workflow's static jobs and reject the registration when a bound
- * environment list is provably unsatisfiable (a disabled environment, or
+ * context list is provably unsatisfiable (a disabled context, or
  * mutually-exclusive fixed branch/trigger/repo restrictions among the resolved
- * environments — missing names are lenient, never rejected). Dynamic elements
+ * contexts — missing names are lenient, never rejected). Dynamic elements
  * are skipped (unresolvable at registration); the all-must-pass semantics keep
  * the static subset's exclusivity sound. Throws the first
  * `UnsatisfiableBinding.message` so the registration route / direct helper
  * surfaces it to the caller.
  */
-export declare function assertWorkflowsSatisfiable(workflows: ReadonlyArray<SatisfiabilityLockWorkflow>, resolveEnv: (name: string) => Promise<Environment | null>): Promise<void>;
+export declare function assertWorkflowsSatisfiable(workflows: ReadonlyArray<SatisfiabilityLockWorkflow>, resolveEnv: (name: string) => Promise<Context | null>): Promise<void>;
 export {};
 //# sourceMappingURL=satisfiability.d.ts.map

package/dist/contexts/protection/trust-gate.d.ts

@@ -0,0 +1,4 @@
+import type { Context, ProtectionGateResult, TrustTier } from '@kici-dev/engine';
+/** Evaluate minimumTrust requirements for the context. */
+export declare function evaluateTrustGate(env: Context, trustTier: TrustTier | undefined): ProtectionGateResult;
+//# sourceMappingURL=trust-gate.d.ts.map

package/dist/contexts/protection/wait-timer-gate.d.ts

@@ -0,0 +1,4 @@
+import type { Context, ProtectionGateResult } from '@kici-dev/engine';
+/** Evaluate wait timer for the context. */
+export declare function evaluateWaitTimerGate(env: Context): ProtectionGateResult;
+//# sourceMappingURL=wait-timer-gate.d.ts.map

package/dist/contexts/variable-store.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Variable store -- context variable CRUD with lock enforcement.
+ *
+ * Manages org-level context variables and per-source overrides.
+ * Lock enforcement: locked org vars cannot be overridden by source overrides.
+ */
+import { type Kysely } from 'kysely';
+import type { Database, ContextVariable, ContextSourceOverride } from '../db/types.js';
+/**
+ * Data access layer for context variables and source overrides.
+ */
+export declare class VariableStore {
+    private readonly db;
+    constructor(db: Kysely<Database>);
+    /** List all org-level variables for a context. */
+    listVars(orgId: string, contextId: string): Promise<ContextVariable[]>;
+    /** Upsert an org-level variable. */
+    setVar(orgId: string, contextId: string, key: string, value: string, locked?: boolean): Promise<void>;
+    /** Delete an org-level variable. */
+    deleteVar(orgId: string, contextId: string, key: string): Promise<void>;
+    /** List source overrides for a specific source (routing key). */
+    listSourceOverrides(orgId: string, contextId: string, routingKey: string): Promise<ContextSourceOverride[]>;
+    /** Upsert a source override. */
+    setSourceOverride(orgId: string, contextId: string, routingKey: string, key: string, value: string): Promise<void>;
+    /** Delete a source override. */
+    deleteSourceOverride(orgId: string, contextId: string, routingKey: string, key: string): Promise<void>;
+    /**
+     * Get resolved variables for a context, optionally merged with source overrides.
+     *
+     * Merge rules:
+     * - Org-level vars form the base
+     * - Source overrides can add new keys and override unlocked org vars
+     * - Locked org vars are NOT overridden by source overrides
+     *
+     * @param routingKey - If provided, source overrides are merged in
+     */
+    getResolvedVars(orgId: string, contextId: string, routingKey?: string): Promise<Record<string, string>>;
+}
+//# sourceMappingURL=variable-store.d.ts.map

package/dist/cron/cron-scheduler.d.ts

@@ -2,7 +2,7 @@ import type { Kysely } from 'kysely';
 import type { Database } from '../db/types.js';
 import type { RegistrationIndex } from '../registration/registration-index.js';
 import type { EventRouter } from '../events/event-router.js';
-import type { CronStore } from './cron-store.js';
+import { type CronStore } from './cron-store.js';
 interface CronSchedulerOptions {
     db: Kysely<Database>;
     registrationIndex: RegistrationIndex;
@@ -32,9 +32,14 @@ export declare class CronScheduler {
     private readonly cronStore;
     private readonly eventRouter;
     private readonly evaluationIntervalMs;
-    private timer;
-    private isLeader;
+    private readonly scheduler;
     private lastFiredCache;
+    /**
+     * Set when the leader-election cache load fails. While true, each evaluation
+     * tick re-attempts the load (see reloadCacheAfterFailure) so a transient DB
+     * error at leader election does not leave the cache cold for the whole tenure.
+     */
+    private cacheLoadPending;
     constructor(options: CronSchedulerOptions);
     /**
      * Called when this orchestrator becomes the Raft leader.
@@ -64,15 +69,30 @@ export declare class CronScheduler {
      * fires the schedule.
      */
     evaluate(): Promise<void>;
+    /**
+     * Re-attempt the last-fired cache load after an earlier failure at leader
+     * election. On success, clears the pending flag; on repeated failure, leaves
+     * it set so the next tick tries again. Evaluation continues either way — the
+     * DB-side tryClaimFire guard prevents double-fires with a stale or cold cache.
+     */
+    private reloadCacheAfterFailure;
     /**
      * Recover missed schedules after becoming leader.
      * Same logic as evaluate() but logs recovery context.
      */
     private recoverMissedSchedules;
     /**
-     * Evaluate a single registration and fire if due.
+     * Evaluate a single registration and fire every due schedule trigger.
+     *
+     * A workflow may declare multiple `schedule()` triggers; each is tracked and
+     * fired independently (keyed per (registration, schedule)), so a second or
+     * third schedule is never silently skipped.
      */
     private evaluateRegistration;
+    /**
+     * Evaluate one schedule trigger of a registration and fire if due.
+     */
+    private evaluateScheduleTrigger;
 }
 export {};
 //# sourceMappingURL=cron-scheduler.d.ts.map

package/dist/cron/cron-store.d.ts

@@ -1,10 +1,21 @@
 import type { Kysely, Transaction } from 'kysely';
 import type { Database } from '../db/types.js';
 type DbExecutor = Kysely<Database> | Transaction<Database>;
+/**
+ * In-memory cache key uniting a registration and one of its schedules.
+ *
+ * A workflow may declare several `schedule()` triggers, each tracked
+ * independently in `cron_last_fired` keyed by (registration_id, schedule_key).
+ * The space separator is unambiguous: a registration id is a UUID and a
+ * schedule key is `${cronExpression}\n${timezone}` — neither contains a space
+ * at the boundary that could collide.
+ */
+export declare function cronCacheKey(registrationId: string, scheduleKey: string): string;
 /**
  * DB persistence for cron last-fired tracking.
  *
- * Tracks the last time each cron-triggered workflow registration was fired.
+ * Tracks the last time each (registration, schedule) was fired — a workflow
+ * with multiple `schedule()` triggers has one row per distinct schedule.
  * Used by CronScheduler for fire-once-on-recovery after leader transitions.
  * Uses upsert (INSERT ON CONFLICT UPDATE) for atomic idempotent writes.
  */
@@ -12,11 +23,14 @@ export declare class CronStore {
     private readonly db;
     constructor(db: Kysely<Database>);
     /**
-     * Atomically claim a cron fire: only succeeds if no other orchestrator has
-     * already fired this registration at a time >= firedAt.
+     * Atomically claim a cron fire for one schedule of a registration: only
+     * succeeds if no other orchestrator has already fired this (registration,
+     * schedule) at a time >= firedAt.
      *
      * Uses INSERT ... ON CONFLICT with a WHERE guard so the upsert only writes
-     * when `last_fired_at < firedAt` (or the row doesn't exist yet).
+     * when `last_fired_at < firedAt` (or the row doesn't exist yet). The conflict
+     * target is the composite key (registration_id, schedule_key) so two distinct
+     * schedules of the same registration claim independently.
      *
      * Accepts an optional executor (Kysely DB handle or Transaction). The cron
      * fire path passes a Transaction so the claim and the subsequent
@@ -27,10 +41,10 @@ export declare class CronStore {
      * Returns true if this call won the race (the fire should proceed).
      * Returns false if another node already recorded a fire >= firedAt.
      */
-    tryClaimFire(registrationId: string, firedAt: Date, executor?: DbExecutor): Promise<boolean>;
+    tryClaimFire(registrationId: string, scheduleKey: string, firedAt: Date, executor?: DbExecutor): Promise<boolean>;
     /**
-     * Get all last-fired records as a Map<registrationId, lastFiredAt>.
-     * Used for bulk loading during leader recovery.
+     * Get all last-fired records as a Map keyed by `cronCacheKey(registrationId,
+     * scheduleKey)`. Used for bulk loading during leader recovery.
      */
     getAll(): Promise<Map<string, Date>>;
 }