@kici-dev/orchestrator 0.20.0 → 0.20.1

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 (a
+     * fixture run with no `--workflow`), 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/pipeline/dispatch-matched-workflow.d.ts

@@ -198,6 +198,12 @@ export interface WorkflowDispatchContext {
      * explicitly rather than leave it `pending` forever.
      */
     runRegisteredBeforeDispatch?: boolean;
+    /**
+     * Called each time this dispatch registers the run with the tracker. A
+     * 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

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

@@ -38,6 +38,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}). */

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/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. A fixture run with no `--workflow` runs
+     * every matched workflow under one run id, 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;
@@ -1089,7 +1105,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 +1185,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.
+ *
+ * A fixture run with no `--workflow` runs every matched workflow under one run
+ * id. `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