@kici-dev/orchestrator 0.20.0 → 0.21.0

package/dist/db/migrations/160_execution_jobs_workflow_name.d.ts

@@ -0,0 +1,16 @@
+import { type Kysely } from 'kysely';
+/**
+ * `execution_jobs.workflow_name`: the workflow that defines the job. A fixture
+ * run with no `--workflow` runs every matched workflow under one run id, so
+ * `execution_runs.workflow_name` (the first matched workflow) does not say
+ * which workflow a job belongs to.
+ *
+ * Nullable, with no backfill: a row written before this column reads as
+ * unknown, and the readers fall back to the run's workflow for a run that can
+ * span only one.
+ *
+ * Idempotent.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;
+//# sourceMappingURL=160_execution_jobs_workflow_name.d.ts.map

package/dist/db/types.d.ts

@@ -651,6 +651,12 @@ export interface ExecutionJobTable {
     job_id: string;
     /** Job name (e.g. "test", "test[node-18]") */
     job_name: string;
+    /**
+     * The workflow that defines the job. A run can span several workflows (an older `kici`'s shared
+     * fixture run), so the run's own
+     * `workflow_name` does not name it. NULL on a row written before the column existed.
+     */
+    workflow_name: ColumnType<string | null, string | null | undefined, string | null>;
     /** Job status: an `ExecutionJobStatus` value (engine). */
     status: Generated<string>;
     /**

package/dist/index.js

@@ -2793,6 +2793,7 @@ var AdminApiClient = class {
 			workflowName: opts?.workflowName,
 			repo: opts?.repo,
 			since: opts?.since,
+			runIdPrefix: opts?.runIdPrefix,
 			limit: opts?.limit || void 0,
 			offset: opts?.offset || void 0
 		});

package/dist/pipeline/dispatch-matched-workflow.d.ts

@@ -198,6 +198,13 @@ export interface WorkflowDispatchContext {
      * explicitly rather than leave it `pending` forever.
      */
     runRegisteredBeforeDispatch?: boolean;
+    /**
+     * Called each time this dispatch registers the run with the tracker. An older `kici`'s shared
+     * fixture run dispatches several
+     * workflows under one run id, and holds the run open from the first
+     * registration until every workflow has registered.
+     */
+    onRunRegistered?: () => void;
     /**
      * Set once `setupDispatchContext` posted the queued `kici/<workflow>` check
      * and one `kici/<workflow>/job/<name>` per static job. They go up BEFORE the
@@ -427,7 +434,8 @@ interface JobEnvEvalResult {
  * Synthetic job-id prefix every needs-gate site stamps on a held-back job. The
  * release path (`dispatchReadyJob` → `findSyntheticJobId` → `addJobsToRun`)
  * keys on it, so it soundly recovers the gated set without threading a parallel
- * list through both the single-orch and cluster paths. Owned by `db/synthetic-job-ids.ts` so the `contexts/`
+ * list through both the single-orch and cluster paths. Owned by `db/synthetic-job-ids.ts` so the
+ * `contexts/`
  * concurrency sweep need not import this module.
  */
 export { NEEDS_PENDING_JOB_ID_PREFIX };

package/dist/pipeline/invoke-gate.d.ts

@@ -20,7 +20,7 @@ import { ExecutionJobStatus } from '@kici-dev/engine';
 import type { LockInvoke, LockJob } from '@kici-dev/engine';
 import type { Kysely } from 'kysely';
 import type { Database } from '../db/types.js';
-import type { ExecutionTracker } from '../reporting/execution-tracker.js';
+import { type ExecutionTracker } from '../reporting/execution-tracker.js';
 /**
  * The invoke parameters carried from a gate's lock job to its (possibly deferred)
  * execution. Persisted on the pending job context so a gate released later — or

package/dist/pipeline/route-or-dispatch-jobs.d.ts

@@ -9,7 +9,7 @@ import type { LockJob, MaterializedJob } from '@kici-dev/engine';
 import type { JobKind } from '../db/types.js';
 import type { RunContext, RunCoordinator } from '../cluster/coordinator.js';
 import type { Dispatcher } from '../agent/dispatcher.js';
-import type { ExecutionTracker } from '../reporting/execution-tracker.js';
+import { type ExecutionTracker } from '../reporting/execution-tracker.js';
 export interface DispatchedJobEntry {
     jobId: string;
     jobName: string;
@@ -73,6 +73,8 @@ export declare function routeOrDispatchJobs(opts: RouteOrDispatchOptions): Promi
 }>;
 export interface RegisterDispatchedJobsOptions {
     newRunId: string;
+    /** The workflow the jobs belong to, recorded on each job row. */
+    workflowName: string;
     dispatchedJobs: DispatchedJobEntry[];
     rejectedJobs: RejectedJobEntry[];
     executionTracker: ExecutionTracker;

package/dist/pipeline/test-pipeline.d.ts

@@ -20,6 +20,10 @@
  *   decorating secret resolver), and the fixture's `secrets` context mapping
  *   resolves into namespaced secrets;
  * - direct workflow execution (bypass trigger matching) is supported.
+ *
+ * Like a webhook, it creates one run per matched workflow. A caller that
+ * follows a single run (no `acceptsMultipleRuns`) gets one shared run instead,
+ * and only when the workflows' job names cannot collide in it.
  */
 import { type ProcessingDeps } from './processor.js';
 import { type ActorPrincipal } from '@kici-dev/engine';
@@ -38,6 +42,8 @@ export interface TestTriggerInput {
     routingKey: string;
     /** Uploaded tarball reference. */
     uploadId?: string;
+    /** The commit the uploaded overlay was built from, as its upload recorded it. */
+    uploadSha?: string;
     /** Fixture secret context mappings `{ contextName: envName }`. */
     secrets?: Record<string, string>;
     /** Base64 X25519+AES-GCM blob of the developer's local secrets ({flat, contexts}). */
@@ -77,9 +83,18 @@ export interface TestTriggerInput {
      * here against the matched workflow's lock dispatch descriptor.
      */
     dispatchInputs?: Record<string, string>;
+    /**
+     * The caller follows every run in the result's `runs`. Without it, several
+     * matched workflows share one run, or the trigger is refused when their job
+     * names collide.
+     */
+    acceptsMultipleRuns?: boolean;
 }
 interface TestTriggerResult {
+    /** The first run's id: the only run when the caller follows one. */
     runId: string;
+    /** One entry per run, each executing one matched workflow. Absent for a shared run. */
+    runs?: TestTriggeredRun[];
     status: 'accepted' | 'rejected';
     reason?: string;
     jobIds: string[];
@@ -98,9 +113,16 @@ export declare function repoIdentityFromInlineInput(input: TestTriggerInput): {
     repoIdentifier: string;
     provider: string;
 };
+/** One run the trigger created, with the matched workflow it executes. */
+export interface TestTriggeredRun {
+    runId: string;
+    workflowName: string;
+    jobIds: string[];
+}
 /**
  * Process a test trigger through the shared dispatch core: one
- * `WorkflowDispatchContext` per matched workflow, into `dispatchMatchedWorkflow`.
+ * `WorkflowDispatchContext` per matched workflow, into `dispatchMatchedWorkflow`,
+ * each under its own run id.
  */
 export declare function processTestTrigger(input: TestTriggerInput, deps: ProcessingDeps): Promise<TestTriggerResult>;
 export {};

package/dist/provenance/backfill-run.d.ts

@@ -31,6 +31,8 @@ export interface BackfillJobRow {
     run_id: string;
     job_id: string;
     job_name: string;
+    /** Optional: a loader that does not select it forwards no workflow. */
+    workflow_name?: string | null;
     status: string;
     started_at: Date | null;
     completed_at: Date | null;

package/dist/reporting/check-run-reporter.d.ts

@@ -192,6 +192,8 @@ interface UpdateStepProgressOptions {
     jobName: string;
     stepIndex: number;
     stepName: string;
+    /** The step's `step_type`, when the agent sent one. */
+    stepType?: string;
     state: 'running' | 'success' | 'failed' | 'skipped' | 'cancelled';
     durationMs?: number;
     installationId?: number;

package/dist/reporting/check-run-summary.d.ts

@@ -42,7 +42,19 @@ export interface StepProgressEntry {
     name: string;
     status: 'pending' | 'running' | 'success' | 'failed' | 'skipped' | 'cancelled';
     durationMs?: number;
+    /** The step's stored index. An entry without one is read by its position (defensive). */
+    stepIndex?: number;
+    /** The step's `step_type`; places setup and init pseudo-steps first. */
+    stepType?: string;
 }
+/**
+ * Record one step's progress: replace the entry for its index, or add it in display
+ * order. Pseudo-steps have high indices (init at 1_000_000 + n), so the list is keyed
+ * by index rather than position; a positional list would pad every gap up to it.
+ */
+export declare function applyStepProgress(steps: StepProgressEntry[], entry: StepProgressEntry & {
+    stepIndex: number;
+}): StepProgressEntry[];
 interface BuildCheckRunSummaryOptions {
     jobName: string;
     stepResults: StepResultData[];

package/dist/reporting/execution-tracker.d.ts

@@ -206,7 +206,9 @@ export interface ExecutionTrackerDeps {
      */
     initFailure?: InitFailure, 
     /** Ordered bound deployment-context names for this job (multi-env jobs). */
-    contexts?: string[]) => void;
+    contexts?: string[], 
+    /** The workflow that defines the job, when recorded. */
+    workflowName?: string) => void;
     /**
      * Optional callback to emit run.event messages to Platform.
      * Fires at orchestrator lifecycle points (dispatch, agent assignment, job start/complete).
@@ -282,6 +284,13 @@ export interface ExecutionTrackerDeps {
 export interface TrackedJobRow {
     jobId: string;
     jobName: string;
+    /**
+     * The workflow that defines the job. An older `kici`'s shared fixture run holds every matched
+     * workflow, so the run's own workflow
+     * does not name it. `onExecutionStarted` stamps its own workflow on a job without one;
+     * `addJobsToRun` inherits it from the placeholder the job replaces.
+     */
+    workflowName?: string;
     matrixValues?: Record<string, unknown>;
     runsOnLabels?: string[];
     baseJobName?: string;
@@ -307,6 +316,8 @@ export interface TrackedJobRow {
     /** For a gate job, its wall-clock timeout in ms (orchestrator-swept). */
     timeoutMs?: number;
 }
+/** Stamp each job with `workflowName`, keeping a workflow a job already names. */
+export declare function jobsOfWorkflow<T extends TrackedJobRow>(workflowName: string, jobs: T[]): T[];
 export declare class ExecutionTracker {
     private readonly db;
     private readonly observerRegistry?;
@@ -538,6 +549,11 @@ export declare class ExecutionTracker {
     /** Synthetic job ID to replace (e.g. needs-pending-deploy-{uuid}). */
     replaceSyntheticId?: string): Promise<void>;
     private addJobsToRunImpl;
+    /**
+     * The workflow of the placeholder a job replaces: from memory, or from its
+     * row when another peer registered it.
+     */
+    private placeholderWorkflowName;
     /** Mark a run as a test run for observer broadcasting (called by the test pipeline). */
     markTestRun(runId: string): void;
     isTestRun(runId: string): boolean;
@@ -814,6 +830,13 @@ export declare class ExecutionTracker {
         dispatchedByFailureLifecycle?: boolean;
         /** Re-run lineage, when this run re-runs another. */
         rerunLineage?: RerunLineage;
+        /**
+         * Set for a `kici run` test run, so its init failure stays readable on the
+         * test-run status and log routes, which serve only test runs.
+         */
+        testRun?: {
+            fixtureId: string;
+        };
     }): Promise<void>;
     /**
      * Write one `failed` execution_runs row for a global eval round that never
@@ -930,6 +953,10 @@ export declare class ExecutionTracker {
          * {@link ExecutionTracker.recordGlobalEvalRoundFailureRun}).
          */
         dispatchRoutingKey?: string;
+        /** Set for a `kici run` test run, as on {@link ExecutionTracker.recordInitFailureRun}. */
+        testRun?: {
+            fixtureId: string;
+        };
     }): Promise<void>;
     /**
      * Claim a held global evaluation round for release (`held` → `pending`).
@@ -1089,7 +1116,7 @@ export declare class ExecutionTracker {
      * worker's first status update creates the `execution_jobs` row. An existing
      * entry is never clobbered, so a later terminal status survives.
      */
-    registerJobName(runId: string, jobId: string, jobName: string): void;
+    registerJobName(runId: string, jobId: string, jobName: string, workflowName?: string): void;
     /**
      * The in-memory run owning a dispatched jobId, so `getExecutionContext`
      * resolves for a job-scoped agent `event.emit`. In-memory only, like
@@ -1169,6 +1196,7 @@ export declare class ExecutionTracker {
         jobs: Array<{
             jobId: string;
             jobName: string;
+            workflowName?: string;
             status: string;
             startedAt?: number;
             completedAt?: number;

package/dist/reporting/run-aggregator.d.ts

@@ -39,6 +39,8 @@ export declare function mapRunDetailStep(step: RunDetailStepRow): {
 export interface RunDetailJobRow {
     job_id: string;
     job_name: string;
+    /** Absent from an archived row written before the column existed. */
+    workflow_name?: string | null;
     status: string;
     matrix_values: unknown;
     base_job_name: string | null;
@@ -67,6 +69,11 @@ export interface RunDetailJobLookups {
         upstreamName: string;
         runOn: ExecutionJobStatus[];
     }>>;
+    /** The run's own workflow, naming a job row that records none; see {@link jobWorkflowName}. */
+    runWorkflow?: {
+        workflow_name: string;
+        is_test_run: boolean;
+    };
 }
 /**
  * The routing reason as a reader should see it: only while the job is `pending`/`queued`.
@@ -82,6 +89,7 @@ export declare function visibleRoutingReason(status: string, routingReason: stri
 export declare function buildRunDetailJobs(jobs: RunDetailJobRow[], lookups: RunDetailJobLookups): {
     jobId: string;
     jobName: string;
+    workflowName: string | null;
     status: string;
     matrixValues: Record<string, unknown> | null;
     baseJobName: string | null;

package/dist/reporting/run-workflow-names.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The workflows a run spans, read from its job rows.
+ *
+ * An older `kici`'s shared fixture run holds every
+ * matched workflow. `execution_runs.workflow_name` holds the first of them; each job row
+ * records its own in `execution_jobs.workflow_name`.
+ */
+import type { Kysely } from 'kysely';
+import type { Database } from '../db/types.js';
+/** The run fields the readers below need. */
+export interface RunWorkflowRef {
+    run_id: string;
+    workflow_name: string;
+}
+/**
+ * Every workflow each run spans, the run's own workflow first and the rest in
+ * the order their first job registered. A run whose job rows name no workflow
+ * (written before the column existed) lists its own workflow alone.
+ */
+export declare function loadRunWorkflowNames(db: Kysely<Database>, runs: readonly RunWorkflowRef[]): Promise<Map<string, string[]>>;
+/**
+ * The workflow a job row belongs to. A row written before the column existed
+ * records none: a run that is not a fixture run spans one workflow, so the
+ * run's own names it; a fixture run may span several, so it stays unknown.
+ */
+export declare function jobWorkflowName(jobWorkflow: string | null, run: {
+    workflow_name: string;
+    is_test_run: boolean;
+}): string | null;
+//# sourceMappingURL=run-workflow-names.d.ts.map

package/dist/reporting/step-display-order.d.ts

@@ -3,26 +3,28 @@
  *
  * Sorting `execution_steps` by `step_index` alone puts a pseudo-step where its index landed,
  * not where it ran. That suits the cache pseudo-steps (indices above the real steps, mostly
- * bracketing the work), but a job's image build runs strictly FIRST.
+ * bracketing the work), but a job's image build and its init commands run strictly FIRST.
  *
  * The index cannot express this: `step.status` rejects a negative index (an agent sending one
  * to an older orchestrator is disconnected mid-job), and the check-run reporter
  * (`steps[stepIndex]`) and the dashboard (log fetching gated on `stepIndex >= 0`) treat a
- * negative index as absent. So the ordering is expressed by TYPE, here, once.
+ * negative index as absent. So the ordering is expressed by TYPE, as the engine's
+ * `StepPhase`, here, once.
  */
 import { type Expression } from 'kysely';
 /**
- * Sort key placing setup pseudo-steps (run before the job's real steps) first. Apply BEFORE
- * the `step_index` sort:
+ * Sort key placing steps by `StepPhase`: setup pseudo-steps, then init commands, then the
+ * job's steps. Apply BEFORE the `step_index` sort:
  *
  * ```ts
  * qb.orderBy(setupStepsFirst()).orderBy('step_index', 'asc')
  * ```
  *
  * Untyped steps and every real step share one key, so `step_index` alone orders each group.
+ * The init pattern matches `initStepIndex`: the prefix followed by digits only.
  */
 export declare function setupStepsFirst(): Expression<number>;
-/** In-memory equivalent, kept beside the SQL so the two agree on what "setup" means. */
+/** In-memory equivalent over DB rows, kept beside the SQL so the two agree on the phases. */
 export declare function compareStepsForDisplay(a: {
     step_type?: string | null;
     step_index: number;
@@ -30,4 +32,6 @@ export declare function compareStepsForDisplay(a: {
     step_type?: string | null;
     step_index: number;
 }): number;
+/** {@link compareStepsForDisplay} over untyped rows, such as cold-store rows read back from S3. */
+export declare function compareStepRowsForDisplay(a: Record<string, unknown>, b: Record<string, unknown>): number;
 //# sourceMappingURL=step-display-order.d.ts.map