@kici-dev/orchestrator 0.5.0 → 0.6.1

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

@@ -26,8 +26,9 @@ export declare function evaluateMultiContextGates(envs: ReadonlyArray<{
 }>, 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
+ * restrictive wins: trust = strictest declared floor (see `TRUST_RANK` — a
+ * wording choice, not a verdict), 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;

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

@@ -1,5 +1,20 @@
 import type { Context, ProtectionGateResult } from '@kici-dev/engine';
 import type { JobDispatchContext } from './pipeline.js';
+/**
+ * The reason phrase for a branch-restricted context bound by an
+ * internally-triggered run that carries NO branch. Shared with the multi-context
+ * aggregator so the two reject paths cannot describe the same cause
+ * differently, and context-free because each caller names the context itself.
+ *
+ * An internally-triggered run usually does have a branch: a scheduled run
+ * presents its registration's default branch, and every other internal trigger
+ * inherits the branch of the run that emitted its event. Those runs are matched
+ * against the restriction patterns like any other. This phrase covers only the
+ * runs where neither source produced one — a registration whose default branch
+ * has never been captured, or an emitting run that is gone — so it names the
+ * remedy for that case rather than telling an operator to drop the restriction.
+ */
+export declare const INTERNAL_TRIGGER_NO_BRANCH_DETAIL: string;
 /** 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

@@ -1,4 +1,10 @@
 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;
+/**
+ * Evaluate concurrency limits for the context.
+ *
+ * Takes only the two fields it reads rather than a whole `Context`, so the
+ * ready-dispatch re-gate can call it with the limit and strategy it resolved
+ * from a run's bound context row. Every full `Context` still satisfies it.
+ */
+export declare function evaluateConcurrencyGate(env: Pick<Context, 'concurrencyLimit' | 'concurrencyStrategy'>, currentRunningCount: number, _concurrencyGroup: string): ProtectionGateResult;
 //# sourceMappingURL=concurrency-gate.d.ts.map

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

@@ -12,6 +12,24 @@ export interface JobDispatchContext {
     repository: string;
     runId: string;
     jobId: string;
+    /**
+     * True when the run was triggered by the orchestrator itself (a schedule
+     * fire, a workflow/job completion, a failure batch, a `kiciEvent()`, an
+     * invoke-gate summon) rather than by a provider webhook.
+     *
+     * Such a run usually DOES carry a branch, and `branch` is then matched
+     * against the restriction patterns like any other run's: a schedule fire
+     * presents its registration's default branch, and every other internal
+     * trigger inherits the branch of the run that emitted its event.
+     *
+     * The flag matters only when `branch` is EMPTY — a failure batch or a scaler
+     * event (many runs behind it, or none), a registration whose default branch
+     * has never been captured, an emitting run that is gone. The branch gate then
+     * rejects naming that cause, instead of quoting the empty value as a branch
+     * name an operator could add to the restriction list. It never weakens the
+     * gate: a run with no branch cannot satisfy a restriction, `*` included.
+     */
+    internallyTriggered?: boolean;
 }
 /** Evaluate all protection rules for a context. */
 export declare function evaluateProtectionRules(env: Context, ctx: JobDispatchContext, currentRunningCount: number, concurrencyGroup: string, trustTier?: TrustTier): Promise<ProtectionGateResult>;

package/dist/contexts/release-queued-holds.d.ts

@@ -0,0 +1,35 @@
+import type { Kysely } from 'kysely';
+import type { Database } from '../db/types.js';
+import type { HeldRunStore, ReleaseSignal } from './held-runs.js';
+export interface ReleaseQueuedHoldsArgs {
+    db: Kysely<Database>;
+    heldRunStore: Pick<HeldRunStore, 'listQueuedHoldsForContext' | 'release'>;
+    orgId: string;
+    /** The context's concurrency group — `execution_runs.context`. */
+    concurrencyGroup: string;
+    /** The context's configured limit; `null`/`undefined` means unlimited. */
+    concurrencyLimit: number | null | undefined;
+    /** Resume a released hold by re-dispatching its job. */
+    onJobRelease: (signal: ReleaseSignal) => Promise<void>;
+}
+/**
+ * Count the jobs OCCUPYING a slot in a concurrency group, scoped to one org.
+ *
+ * A job occupies its slot from the moment it is dispatched until it reaches a
+ * terminal status — not merely while its status is `running`. Counting only
+ * `running` missed every job that had been dispatched but had not yet reported
+ * back, so the sweep read a full group as empty and released queued holds while
+ * their slots were still taken. That is a real over-admission, not a cosmetic
+ * one: the release path re-checks the limit precisely so the bound holds
+ * whenever the sweep happens to run, and an undercount defeats that re-check.
+ *
+ * The `customer_id` predicate is not optional: a context name shared across
+ * tenants would otherwise leak concurrency between them.
+ */
+export declare function countOccupyingJobs(db: Kysely<Database>, orgId: string, concurrencyGroup: string): Promise<number>;
+/**
+ * Release up to `limit - running` queued holds for a group, oldest first.
+ * Returns how many actually resumed.
+ */
+export declare function releaseQueuedHolds(args: ReleaseQueuedHoldsArgs): Promise<number>;
+//# sourceMappingURL=release-queued-holds.d.ts.map

package/dist/dashboard/attestation-filters.d.ts

@@ -50,7 +50,9 @@ export declare function baseAttestationsQuery(db: Kysely<Database>): import("kys
     join_tokens: import("../db/types.js").JoinTokenTable;
     kici_events: import("../db/types.js").KiciEventTable;
     orchestrator_signing_keys: import("../db/types.js").OrchestratorSigningKeysTable;
+    org_plan_headroom: import("../db/types.js").OrgPlanHeadroomTable;
     org_settings: import("../db/types.js").OrgSettingsTable;
+    org_trust_directory: import("../db/types.js").OrgTrustDirectoryTable;
     org_trust_policy: import("../db/types.js").OrgTrustPolicyTable;
     pending_attestations: import("../db/types.js").PendingAttestationsTable;
     pending_job_contexts: import("../db/types.js").PendingJobContextsTable;
@@ -62,6 +64,8 @@ export declare function baseAttestationsQuery(db: Kysely<Database>): import("kys
     run_ephemeral_keys: import("../db/types.js").RunEphemeralKeysTable;
     run_secret_outputs: import("../db/types.js").RunSecretOutputsTable;
     scaler_agent_jobs: import("../db/types.js").ScalerAgentJobsTable;
+    scaler_pending_claims: import("../db/types.js").ScalerPendingClaimsTable;
+    scaler_provision_outcomes: import("../db/types.js").ScalerProvisionOutcomesTable;
     scaler_reservations: import("../db/types.js").ScalerReservationsTable;
     scaler_spawning_agents: import("../db/types.js").ScalerSpawningAgentsTable;
     scoped_secrets: import("../db/types.js").ScopedSecretsTable;
@@ -121,7 +125,9 @@ export declare function basePendingAttestationsQuery(db: Kysely<Database>): impo
     join_tokens: import("../db/types.js").JoinTokenTable;
     kici_events: import("../db/types.js").KiciEventTable;
     orchestrator_signing_keys: import("../db/types.js").OrchestratorSigningKeysTable;
+    org_plan_headroom: import("../db/types.js").OrgPlanHeadroomTable;
     org_settings: import("../db/types.js").OrgSettingsTable;
+    org_trust_directory: import("../db/types.js").OrgTrustDirectoryTable;
     org_trust_policy: import("../db/types.js").OrgTrustPolicyTable;
     pending_attestations: import("../db/types.js").PendingAttestationsTable;
     pending_job_contexts: import("../db/types.js").PendingJobContextsTable;
@@ -133,6 +139,8 @@ export declare function basePendingAttestationsQuery(db: Kysely<Database>): impo
     run_ephemeral_keys: import("../db/types.js").RunEphemeralKeysTable;
     run_secret_outputs: import("../db/types.js").RunSecretOutputsTable;
     scaler_agent_jobs: import("../db/types.js").ScalerAgentJobsTable;
+    scaler_pending_claims: import("../db/types.js").ScalerPendingClaimsTable;
+    scaler_provision_outcomes: import("../db/types.js").ScalerProvisionOutcomesTable;
     scaler_reservations: import("../db/types.js").ScalerReservationsTable;
     scaler_spawning_agents: import("../db/types.js").ScalerSpawningAgentsTable;
     scoped_secrets: import("../db/types.js").ScopedSecretsTable;

package/dist/dashboard/handler.d.ts

@@ -1,16 +1,3 @@
-/**
- * Dashboard handler for the orchestrator.
- *
- * Responds to dashboard.* and run.* WS messages from Platform by querying the local
- * execution_jobs and execution_steps tables and reading logs from LogStorage.
- *
- * Supported messages:
- * - dashboard.run.detail: returns jobs with nested steps for a run
- * - dashboard.step.logs: returns log lines for a specific step
- * - dashboard.payload: returns the original webhook payload for a run
- * - run.rerun.request: re-runs a completed workflow run
- * - run.cancel.request: cancels a running workflow run
- */
 import { type Kysely } from 'kysely';
 import { type ColdStore } from '@kici-dev/shared';
 import type { DashboardRunDetailRequest, DashboardRunsListRequest, DashboardRunsListResponse, DashboardRunsFiltersRequest, DashboardRunsFiltersResponse, DashboardSourcesListRequest, DashboardSourcesListResponse, DashboardStepLogsRequest, DashboardAttestationsListRequest, DashboardAttestationsListAllRequest, DashboardAttestationGetRequest, DashboardAttestationRetryRequest, DashboardPayloadRequest, DashboardOrchLogsRequest, DashboardEventLogListRequest, DashboardEventLogActivityRequest, DashboardEventLogDetailRequest, DashboardEventLogPayloadStreamRequest, DashboardAccessLogListRequest, DashboardEventDlqListRequest, DashboardEventDlqCountRequest, DashboardEventDlqRetryRequest, DashboardEventDlqDiscardRequest, RunRerunRequest, RunCancelRequest, ManualScheduleRequest, DashboardRunStructuredRequest, DashboardArtifactsListRequest } from '@kici-dev/engine';
@@ -125,16 +112,12 @@ interface DashboardHandlerDeps {
      */
     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.
+     * **Test-only fault injection**, supplied only by the build-time test double:
+     * `handleRerunRequest` awaits this hook before invoking `onRerun`, so an HA
+     * E2E can force a slow first coordinator and trigger a relay failover.
+     * Undefined (the shipped default) means no delay.
      */
-    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;
+    beforeRerun?: () => Promise<void>;
 }
 export declare class DashboardHandler {
     private readonly db;
@@ -153,8 +136,7 @@ export declare class DashboardHandler {
     private readonly eventStore;
     private readonly retryAttestations;
     private readonly provenanceSigningIssuer;
-    private readonly testMode;
-    private readonly testRerunDelayMs;
+    private readonly beforeRerun;
     constructor(deps: DashboardHandlerDeps);
     /**
      * Update the bound orgId + routingKey. Called from server.ts after resolving

package/dist/db/migrations/116_org_plan_headroom.d.ts

@@ -0,0 +1,4 @@
+import { type Kysely } from 'kysely';
+export declare function up(db: Kysely<any>): Promise<void>;
+export declare function down(db: Kysely<any>): Promise<void>;
+//# sourceMappingURL=116_org_plan_headroom.d.ts.map

package/dist/db/migrations/117_invoke_gate_proxy_jobs.d.ts

@@ -0,0 +1,4 @@
+import { type Kysely } from 'kysely';
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=117_invoke_gate_proxy_jobs.d.ts.map

package/dist/db/migrations/118_invoke_gate_scheduling.d.ts

@@ -0,0 +1,4 @@
+import { type Kysely } from 'kysely';
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=118_invoke_gate_scheduling.d.ts.map

package/dist/db/migrations/119_scaler_ha_ownership.d.ts

@@ -0,0 +1,4 @@
+import { type Kysely } from 'kysely';
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=119_scaler_ha_ownership.d.ts.map

package/dist/db/migrations/120_cluster_settings_scaler_reaper.d.ts

@@ -0,0 +1,4 @@
+import { type Kysely } from 'kysely';
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=120_cluster_settings_scaler_reaper.d.ts.map

package/dist/db/migrations/121_org_settings_allow_untrusted_dockerfile_builds.d.ts

@@ -0,0 +1,19 @@
+import { type Kysely } from 'kysely';
+/**
+ * Add `org_settings.allow_untrusted_dockerfile_builds boolean NOT NULL DEFAULT false`.
+ *
+ * A job may build its container image from a Dockerfile in the repository. That
+ * build runs arbitrary `RUN` commands on the agent host's daemon, OUTSIDE the
+ * hardened posture the job's own steps get (`CapDrop: ALL`, no-new-privileges,
+ * pids/memory/CPU caps) — a build cannot be capability-restricted the way a
+ * container run can.
+ *
+ * So the default is deny for an untrusted ref (a fork PR, an unresolved
+ * contributor — the same classification the cache write scope uses). An operator
+ * who wants fork PRs building their own images turns it on per org, deliberately.
+ *
+ * Idempotent: a re-run on a DB that already has the column is a no-op.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=121_org_settings_allow_untrusted_dockerfile_builds.d.ts.map

package/dist/db/migrations/122_host_roster_scaler_managed.d.ts

@@ -0,0 +1,25 @@
+import { type Kysely } from 'kysely';
+/**
+ * Add `host_roster.scaler_managed boolean NOT NULL DEFAULT false`.
+ *
+ * `runsOnAll` fans a job out across the declared fleet. Every registering agent
+ * upserts a roster row, auto-scaler-spawned ones included, so a pre-spawned
+ * warm agent was a valid fan-out target — and a child pinned to it runs at the
+ * pool's fixed shape rather than its own. This column records the one fact that
+ * separates the two populations: whether a scaler backend spawned the agent.
+ *
+ * It is written from the scaler manager's registration lookup (a spawn record
+ * exists for the agent id), NOT from `lifecycle_class`. `lifecycle_class`
+ * snapshots the auth TOKEN's type and is `ephemeral` for every agent when the
+ * auth mode is `none`, so it cannot distinguish a fleet host from a scaler
+ * agent in that mode.
+ *
+ * DEFAULT false is load-bearing: a row written before this migration must read
+ * as not-scaler-managed so an existing fleet host stays a fan-out target
+ * immediately, without waiting to re-register.
+ *
+ * Idempotent: a re-run on a DB that already has the column is a no-op.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=122_host_roster_scaler_managed.d.ts.map

package/dist/db/migrations/123_workflow_registrations_default_branch.d.ts

@@ -0,0 +1,24 @@
+import { type Kysely } from 'kysely';
+/**
+ * Add `workflow_registrations.default_branch text` (nullable).
+ *
+ * A `__schedule_fire` run executes the default branch's lock file, so the
+ * default branch IS that run's branch — which is what a branch-restricted
+ * context needs in order to accept it. The value is already computed at
+ * registration time from the webhook payload (the default-branch-push check),
+ * it was simply never persisted, so a scheduled run had no branch to present.
+ *
+ * NULLABLE with no default, deliberately. The default branch is knowable only
+ * from a webhook payload, so there is nothing to backfill a pre-existing row
+ * with: a registration written before this migration reads NULL until its
+ * repo's next default-branch push re-registers it. The dispatch path reads NULL
+ * as "no branch" and the context branch gate then rejects with its honest
+ * named-cause verdict — a DEFAULT would instead invent a branch the
+ * registration never proved, which is exactly the confusion this whole column
+ * exists to end.
+ *
+ * Idempotent: a re-run on a DB that already has the column is a no-op.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=123_workflow_registrations_default_branch.d.ts.map

package/dist/db/migrations/124_cluster_settings_provision_backoff.d.ts

@@ -0,0 +1,4 @@
+import { type Kysely } from 'kysely';
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=124_cluster_settings_provision_backoff.d.ts.map

package/dist/db/migrations/125_org_trust_directory.d.ts

@@ -0,0 +1,30 @@
+import { type Kysely } from 'kysely';
+/**
+ * Create `org_trust_directory` — the orchestrator's cache of the Platform-owned
+ * approval directory pushed alongside the policy on `trust_policy.update`:
+ * identity links, per-member CI trust levels, and team memberships.
+ *
+ * A sibling of `org_trust_policy` rather than more columns on it: the policy is
+ * four scalar switches, while these three are structured documents the Platform
+ * replaces wholesale on every push — `identity_links` and `team_memberships`
+ * are arrays, `member_ci_trust` is a user-id-keyed map — so they are stored as
+ * JSONB.
+ *
+ * Persisting rather than holding them only in memory is what lets
+ * `/kici approve` authorize a commenter after a restart. Without a cached
+ * directory the orchestrator cannot map a comment author onto a KiCI user at
+ * all until the Platform's next push lands, so every approval is refused in the
+ * meantime.
+ *
+ * Wherever a Platform is attached it is the only writer of this row. An
+ * independent orchestrator has no Platform, so there the operator writes it
+ * through `kici-admin trust-policy directory-set`. The two are mutually
+ * exclusive — the admin route refuses the local write on any Platform-attached
+ * orchestrator — so a deployment still only ever has one writer, and there is
+ * no counterpart to `org_trust_policy.source` to record which it was.
+ *
+ * Idempotent: guarded by IF NOT EXISTS, so a re-run is a no-op.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=125_org_trust_directory.d.ts.map

package/dist/db/migrations/126_held_runs_posted_pending_check.d.ts

@@ -0,0 +1,28 @@
+import { type Kysely } from 'kysely';
+/**
+ * Add `held_runs.posted_pending_check boolean` — whether this hold's pending
+ * `KiCI Security` check actually reached the provider.
+ *
+ * `postCheckStatus` CREATES the named check run when it finds none, so
+ * terminalizing a check the hold never posted does not close anything: it puts
+ * a completed `KiCI Security` run on a commit that had none. Whether a hold
+ * posted one was derived from the row's SHAPE, which answers what the code
+ * INTENDED — a post that the provider refused, or that no check poster was in
+ * reach to attempt, leaves a shape that says "posted" and a commit that has
+ * nothing. The column records what happened instead of what was meant.
+ *
+ * Nullable, with no default, and the three values are distinct:
+ *
+ * - `true` — the post returned successfully. The hold owns the check.
+ * - `false` — no post was attempted, or one was attempted and failed. Nothing
+ *   to terminalize; a settle would fabricate.
+ * - `null` — the row predates this column, so nothing recorded either way. The
+ *   shape derivation still answers for it. A `false` DEFAULT would instead
+ *   declare every hold pending at deploy time un-posted and strand the checks
+ *   they really do have.
+ *
+ * Idempotent: a re-run on a DB that already has the column is a no-op.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=126_held_runs_posted_pending_check.d.ts.map

package/dist/db/migrations/127_org_trust_policy_approval_expiry_seconds.d.ts

@@ -0,0 +1,26 @@
+import { type Kysely } from 'kysely';
+/**
+ * Add `org_trust_policy.approval_expiry_seconds` (nullable INTEGER).
+ *
+ * The authoritative security-hold window, at the granularity the existing
+ * `approval_expiry_hours` cannot express. Nullable rather than NOT NULL with a
+ * default, and deliberately NOT backfilled: NULL means "no seconds value was
+ * ever written", and every reader falls back to `approval_expiry_hours * 3600`
+ * for such a row. A backfill would have to guess, and a NOT NULL default would
+ * make a row written by an older build — which does not know the column —
+ * silently claim the default window instead of the hours the operator set.
+ *
+ * The same shape `contexts.hold_expiry_seconds` already uses for the same
+ * reason: "null = unset, the default window applies".
+ *
+ * `approval_expiry_hours` is kept. It is not dead — it is still the only window
+ * an older peer can read, and it is still what a partial write supplies — so
+ * dropping it would be a destructive schema change against a protected surface
+ * and would break a rollback outright (the column is NOT NULL with no default).
+ *
+ * Idempotent: guarded on column existence; a re-run on a DB that already has
+ * the column is a no-op.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=127_org_trust_policy_approval_expiry_seconds.d.ts.map

package/dist/db/migrations/128_execution_runs_global_eval_round.d.ts

@@ -0,0 +1,23 @@
+import { type Kysely } from 'kysely';
+/**
+ * Add `execution_runs.is_global_eval_round boolean NOT NULL DEFAULT false` —
+ * the structural marker for a run row that records a global evaluation round
+ * rather than a workflow.
+ *
+ * The re-run path must recognise such a run: re-running it re-executes the
+ * evaluation, not a workflow. The only discriminator available to it otherwise
+ * is the round job's `__globaleval__` name prefix, which a customer workflow
+ * may carry — a name a customer chooses cannot decide which code path a re-run
+ * takes. A column stamped where the round failure is recorded is
+ * collision-proof.
+ *
+ * `NOT NULL DEFAULT false` because the question has exactly two answers: every
+ * pre-existing row is an ordinary run, and there is no third "unknown" reading
+ * a null would carry.
+ *
+ * Idempotent: the add is guarded on existence and the drop uses IF EXISTS, so a
+ * re-run is a no-op.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=128_execution_runs_global_eval_round.d.ts.map

package/dist/db/migrations/129_execution_runs_dispatch_routing_key.d.ts

@@ -0,0 +1,24 @@
+import { type Kysely } from 'kysely';
+/**
+ * Add `execution_runs.dispatch_routing_key TEXT NULL` — the source whose
+ * credentials a run's `provider_context` actually holds.
+ *
+ * `routing_key` records the source the event ARRIVED on. For a cross-provider
+ * global workflow those are two different sources: the lock file resolves
+ * through another source's bundle, and `provider_context` is written from that
+ * source's credentials. Anything that pairs the inbound routing key with the
+ * stored context therefore hands one source's credentials to another source's
+ * API client — the re-run of a failed evaluation round did exactly that, and
+ * the resulting fetch either fails or reads the wrong tree.
+ *
+ * Nullable, with no default: NULL means "the same source the event arrived on",
+ * which is true of every run except a cross-provider dispatch and of every row
+ * written before this column existed. A default would have to name a routing
+ * key, and there is no cluster-wide one to name.
+ *
+ * Idempotent: the add is guarded on existence and the drop uses IF EXISTS, so a
+ * re-run is a no-op.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=129_execution_runs_dispatch_routing_key.d.ts.map

package/dist/db/migrations/130_scaler_provision_outcomes.d.ts

@@ -0,0 +1,32 @@
+import { type Kysely } from 'kysely';
+/**
+ * Durable per-provision outcome, keyed by agent id.
+ *
+ * `scaler_spawning_agents` is deleted the moment a provision is torn down, so
+ * its absence cannot tell "this provision was never adopted" from "this
+ * provision was adopted and has since been torn down". The stale-spawn prune
+ * has to separate exactly those two, because the first is a real external
+ * provisioning failure every coordinator must back off on, and the second is a
+ * healthy provision that must not be reported at all.
+ *
+ * This table carries the positive signal the spawn row cannot: the adoption is
+ * written in the same transaction that stamps `adopted_by`, and it outlives the
+ * spawn row's delete. Deliberately a separate table rather than a column on
+ * `scaler_spawning_agents`: that row's delete is what the per-coordinator
+ * provisioning backoff depends on, so it is left exactly as it is.
+ *
+ * `adopted_*` and `condemned_*` are independent. A provision that was adopted
+ * and later condemned by the reaper carries BOTH, and the condemn write never
+ * touches the adoption columns — losing the adoption fact would restore the
+ * misattribution this table exists to remove.
+ *
+ * Rows are purged by the leader-gated reaper once the spawn row is gone and the
+ * retention floor has passed; see `ScalerStateStore.purgeProvisionOutcomes`.
+ *
+ * Idempotent: both statements are guarded by IF NOT EXISTS, so a re-run is a
+ * no-op — including a re-run over a database that has the table but not the
+ * index, which an existence probe over the table alone would skip.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=130_scaler_provision_outcomes.d.ts.map