@kici-dev/orchestrator 0.1.26 → 0.1.27

package/dist/config.d.ts

@@ -75,6 +75,15 @@ declare const configSchema: z.ZodObject<{
     secretKeyOld: z.ZodOptional<z.ZodString>;
     secretKeyFileOld: z.ZodOptional<z.ZodString>;
     bootstrapAdminToken: z.ZodOptional<z.ZodString>;
+    independentSecrets: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "true" | "false">>;
+    independentIdentity: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "true" | "false">>;
+    devIdentityKeyFile: z.ZodOptional<z.ZodString>;
     pgCustomerSecrets: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
         true: "true";
         false: "false";
@@ -101,6 +110,8 @@ declare const configSchema: z.ZodObject<{
     testMode: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<boolean, string>>;
     testEventFailFirstN: z.ZodOptional<z.ZodString>;
     testMintDeferAudience: z.ZodOptional<z.ZodString>;
+    testMintRejectAudience: z.ZodOptional<z.ZodString>;
+    testRerunDelayMs: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     eventLogMaxPayloadBytes: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     logLevel: z.ZodDefault<z.ZodEnum<{
         error: "error";
@@ -203,6 +214,8 @@ export declare const envDef: import("@kici-dev/shared/env").DefineEnvResult<{
     staleDetectorThresholdMultiplier: number;
     jobHeartbeatIntervalMs: number;
     githubAppNameRefreshIntervalMs: number;
+    independentSecrets: boolean;
+    independentIdentity: boolean;
     pgCustomerSecrets: boolean;
     agentAuth: "token" | "none";
     agentTokenTtlMs: number;
@@ -273,9 +286,12 @@ export declare const envDef: import("@kici-dev/shared/env").DefineEnvResult<{
     secretKeyOld?: string | undefined;
     secretKeyFileOld?: string | undefined;
     bootstrapAdminToken?: string | undefined;
+    devIdentityKeyFile?: string | undefined;
     orchestratorHostAgentId?: string | undefined;
     testEventFailFirstN?: string | undefined;
     testMintDeferAudience?: string | undefined;
+    testMintRejectAudience?: string | undefined;
+    testRerunDelayMs?: number | undefined;
     otelExporterOtlpEndpoint?: string | undefined;
     clusterName?: string | undefined;
 }>;

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

@@ -0,0 +1,36 @@
+/**
+ * Binding store -- scope-to-context binding CRUD.
+ *
+ * Bindings map scope patterns (e.g. 'aws/prod/**') to contexts,
+ * controlling which scoped secrets are available in each context.
+ */
+import type { Kysely } from 'kysely';
+import type { Database, ContextBinding } from '../db/types.js';
+/**
+ * A scope→context binding with its host selector. `hostPattern` defaults to
+ * `'**'` (all hosts) when omitted.
+ */
+export interface BindingInput {
+    scopePattern: string;
+    hostPattern?: string;
+}
+/**
+ * Data access layer for context bindings.
+ */
+export declare class BindingStore {
+    private readonly db;
+    constructor(db: Kysely<Database>);
+    /** List all bindings for an context. */
+    list(orgId: string, contextId: string): Promise<ContextBinding[]>;
+    /**
+     * Replace all bindings for an context in a transaction.
+     *
+     * Deletes existing bindings and inserts the new set atomically. Each binding
+     * carries a `scopePattern` and an optional `hostPattern` (defaulting to
+     * `'**'`). Pass an empty array to clear all bindings.
+     */
+    set(orgId: string, contextId: string, bindings: BindingInput[]): Promise<void>;
+    /** Find bindings for an context (alias for list, used by secret resolver). */
+    findBindingsForContext(orgId: string, contextId: string): Promise<ContextBinding[]>;
+}
+//# sourceMappingURL=binding-store.d.ts.map

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

@@ -0,0 +1,87 @@
+import { type Kysely } from 'kysely';
+import type { 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?: 'queue' | 'cancel-pending';
+    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. */
+export interface ContextUpdateInput {
+    name?: string;
+    type?: 'fixed' | 'glob';
+    globPattern?: string | null;
+    branchRestrictions?: string[];
+    triggerTypeFilters?: string[];
+    repoPatterns?: string[];
+    concurrencyLimit?: number | null;
+    concurrencyStrategy?: 'queue' | 'cancel-pending';
+    concurrencyTimeoutMs?: number;
+    requiredReviewers?: string[] | null;
+    waitTimerSeconds?: number | null;
+    holdExpirySeconds?: number;
+    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.
+     * Returns the first matching context or null.
+     */
+    matchContext(orgId: string, name: string): Promise<Context | null>;
+}
+//# sourceMappingURL=context-store.d.ts.map

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

@@ -18,16 +18,16 @@ export declare enum HeldRunStatus {
 export interface CreateHeldRunData {
     runId: string;
     jobId: string;
-    environmentId: string;
+    contextId: string;
     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,14 +37,14 @@ 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
@@ -79,7 +79,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 +100,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 +151,13 @@ 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[]>;
     /**
      * 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>;
     /**
@@ -181,7 +181,7 @@ export declare class HeldRunStore {
      * 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).
+     * `context_id` (workflow-level install concurrency keys on the env id).
      */
     releaseConcurrencyHold(orgId: string, group: string): Promise<ReleaseSignal | null>;
     /**

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 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: 'queue' | 'cancel-pending';
+}
+/**
+ * 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,7 @@
+/**
+ * Concurrency gate -- checks concurrency limits.
+ */
+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,7 @@
+/**
+ * Reviewer gate -- checks required reviewers.
+ */
+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,25 +1,25 @@
 /**
- * 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<{
     enabled: "enabled";
@@ -28,42 +28,42 @@ export declare const UnsatisfiableRule: z.ZodEnum<{
     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,7 @@
+/**
+ * Trust gate -- checks contributor trust tier against context minimumTrust.
+ */
+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,7 @@
+/**
+ * Wait timer gate -- checks wait timer configuration.
+ */
+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/dashboard/attestation-filters.d.ts

@@ -13,7 +13,7 @@ import type { Database } from '../db/types.js';
  */
 export declare function baseAttestationsQuery(db: Kysely<Database>): import("kysely").SelectQueryBuilder<{
     cluster_meta: import("../db/types.js").ClusterMetaTable;
-    environments: import("../db/types.js").EnvironmentsTable;
+    contexts: import("../db/types.js").ContextsTable;
     host_roster: import("../db/types.js").HostRosterTable;
     dispatch_queue: import("../db/types.js").DispatchQueueTable;
     dedup_cache: import("../db/types.js").DedupCacheTable;
@@ -24,9 +24,9 @@ export declare function baseAttestationsQuery(db: Kysely<Database>): import("kys
     raft_state: import("../db/types.js").RaftStateTable;
     secret_audit_log: import("../db/types.js").SecretAuditLogTable;
     scoped_secrets: import("../db/types.js").ScopedSecretsTable;
-    environment_bindings: import("../db/types.js").EnvironmentBindingsTable;
-    environment_variables: import("../db/types.js").EnvironmentVariablesTable;
-    environment_source_overrides: import("../db/types.js").EnvironmentSourceOverridesTable;
+    context_bindings: import("../db/types.js").ContextBindingsTable;
+    context_variables: import("../db/types.js").ContextVariablesTable;
+    context_source_overrides: import("../db/types.js").ContextSourceOverridesTable;
     held_runs: import("../db/types.js").HeldRunsTable;
     held_run_approvals: import("../db/types.js").HeldRunApprovalsTable;
     admin_tokens: import("../db/types.js").AdminTokenTable;
@@ -59,6 +59,7 @@ export declare function baseAttestationsQuery(db: Kysely<Database>): import("kys
     attestations: import("../db/types.js").AttestationsTable;
     pending_attestations: import("../db/types.js").PendingAttestationsTable;
     remote_sources: import("../db/types.js").RemoteSourcesTable;
+    request_idempotency: import("../db/types.js").RequestIdempotencyTable;
 }, "execution_runs" | "execution_jobs" | "attestations", {}>;
 export type AttestationsBaseQuery = ReturnType<typeof baseAttestationsQuery>;
 /**
@@ -74,7 +75,7 @@ export type AttestationsBaseQuery = ReturnType<typeof baseAttestationsQuery>;
  */
 export declare function basePendingAttestationsQuery(db: Kysely<Database>): import("kysely").SelectQueryBuilder<{
     cluster_meta: import("../db/types.js").ClusterMetaTable;
-    environments: import("../db/types.js").EnvironmentsTable;
+    contexts: import("../db/types.js").ContextsTable;
     host_roster: import("../db/types.js").HostRosterTable;
     dispatch_queue: import("../db/types.js").DispatchQueueTable;
     dedup_cache: import("../db/types.js").DedupCacheTable;
@@ -85,9 +86,9 @@ export declare function basePendingAttestationsQuery(db: Kysely<Database>): impo
     raft_state: import("../db/types.js").RaftStateTable;
     secret_audit_log: import("../db/types.js").SecretAuditLogTable;
     scoped_secrets: import("../db/types.js").ScopedSecretsTable;
-    environment_bindings: import("../db/types.js").EnvironmentBindingsTable;
-    environment_variables: import("../db/types.js").EnvironmentVariablesTable;
-    environment_source_overrides: import("../db/types.js").EnvironmentSourceOverridesTable;
+    context_bindings: import("../db/types.js").ContextBindingsTable;
+    context_variables: import("../db/types.js").ContextVariablesTable;
+    context_source_overrides: import("../db/types.js").ContextSourceOverridesTable;
     held_runs: import("../db/types.js").HeldRunsTable;
     held_run_approvals: import("../db/types.js").HeldRunApprovalsTable;
     admin_tokens: import("../db/types.js").AdminTokenTable;
@@ -120,6 +121,7 @@ export declare function basePendingAttestationsQuery(db: Kysely<Database>): impo
     attestations: import("../db/types.js").AttestationsTable;
     pending_attestations: import("../db/types.js").PendingAttestationsTable;
     remote_sources: import("../db/types.js").RemoteSourcesTable;
+    request_idempotency: import("../db/types.js").RequestIdempotencyTable;
 }, "execution_runs" | "execution_jobs" | "pending_attestations", {}>;
 /**
  * Apply org-wide attestation filters to the base query. Digest is exact-match;

package/dist/dashboard/handler.d.ts

@@ -70,7 +70,14 @@ interface DashboardHandlerDeps {
      * compat with mixed deploys; absent means the orchestrator falls
      * back to the legacy "no PG row → throw" path.
      */
-    onRerun: (runId: string, triggeredBy: string | null, triggeredByAgentLabel: string | null, routingKey?: string) => Promise<{
+    onRerun: (runId: string, triggeredBy: string | null, triggeredByAgentLabel: string | null, 
+    /**
+     * Platform-minted `requestId` for this rerun. Stable across an HA relay
+     * failover re-send, so the orchestrator uses it as an idempotency key: a
+     * re-sent request returns the first coordinator's run instead of minting a
+     * second one.
+     */
+    requestId: string, routingKey?: string) => Promise<{
         newRunId: string;
     }>;
     /**
@@ -85,7 +92,13 @@ interface DashboardHandlerDeps {
      * Callback for handling manual schedule trigger requests.
      * Returns { newRunId } on success or throws on failure.
      */
-    onManualSchedule: (registrationId: string, triggeredBy: string | null, triggeredByAgentLabel: string | null) => Promise<{
+    onManualSchedule: (registrationId: string, triggeredBy: string | null, triggeredByAgentLabel: string | null, 
+    /**
+     * Platform-minted `requestId` for this manual schedule. Used as an
+     * idempotency key so an HA relay failover re-send returns the first
+     * coordinator's run instead of minting a second one.
+     */
+    requestId: string) => Promise<{
         newRunId: string;
     }>;
     /**
@@ -95,6 +108,17 @@ interface DashboardHandlerDeps {
      * deployments the store is wired by `bootstrapOrchestrator`.
      */
     eventStore?: EventStore | null;
+    /**
+     * **Test-only.** Master switch for fault-injection knobs. When false the
+     * handler ignores every test-only knob below even if it is set.
+     */
+    testMode?: boolean;
+    /**
+     * **Test-only.** When set (and `testMode` is true), `handleRerunRequest`
+     * sleeps this many ms before invoking `onRerun`, so an HA E2E can force a
+     * slow first coordinator and trigger a relay failover. Ignored in production.
+     */
+    testRerunDelayMs?: number;
 }
 export declare class DashboardHandler {
     private readonly db;
@@ -111,6 +135,8 @@ export declare class DashboardHandler {
     private readonly coldStore;
     private readonly eventStore;
     private readonly retryAttestations;
+    private readonly testMode;
+    private readonly testRerunDelayMs;
     constructor(deps: DashboardHandlerDeps);
     /**
      * Update the bound orgId + routingKey. Called from server.ts after resolving