@pikku/kysely 0.13.4 → 0.13.6

package/dist/src/kysely-workflow-service.js

@@ -1,4 +1,5 @@
 import { PikkuWorkflowService, } from '@pikku/core/workflow';
+import { sql } from 'kysely';
 import { KyselyWorkflowRunService } from './kysely-workflow-run-service.js';
 import { parseJson } from './kysely-json.js';
 import { ensurePikkuSchema } from './schema/index.js';
@@ -68,11 +69,12 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             retries: stepOptions?.retries ?? null,
             retryDelay: stepOptions?.retryDelay?.toString() ?? null,
             fromStepName: fromStepName ?? null,
+            currentAttempt: 1,
             createdAt: now,
             updatedAt: now,
         })
             .execute();
-        await this.insertHistoryRecord(stepId, 'pending');
+        await this.insertHistoryRecord(stepId, 'pending', 1);
         return {
             stepId,
             status: 'pending',
@@ -88,25 +90,24 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
     }
     async getStepState(runId, stepName) {
         const row = await this.db
-            .selectFrom('workflowStep as s')
+            .selectFrom('workflowStep')
             .select([
-            's.workflowStepId',
-            's.status',
-            's.result',
-            's.error',
-            's.retries',
-            's.retryDelay',
-            's.fromStepName',
-            's.createdAt',
-            's.updatedAt',
+            'workflowStepId',
+            'status',
+            'result',
+            'error',
+            'retries',
+            'retryDelay',
+            'fromStepName',
+            // `current_attempt` is bumped alongside every history insert, so it is
+            // already the count this used to aggregate — and reading it keeps the
+            // engine's hottest query off a table that grows for the life of the run.
+            'currentAttempt',
+            'createdAt',
+            'updatedAt',
         ])
-            .select((eb) => eb
-            .selectFrom('workflowStepHistory')
-            .select(eb.fn.countAll().as('cnt'))
-            .whereRef('workflowStepHistory.workflowStepId', '=', 's.workflowStepId')
-            .as('attemptCount'))
-            .where('s.workflowRunId', '=', runId)
-            .where('s.stepName', '=', stepName)
+            .where('workflowRunId', '=', runId)
+            .where('stepName', '=', stepName)
             .executeTakeFirst();
         if (!row) {
             throw new Error(`Step not found: runId=${runId}, stepName=${stepName}. Use insertStepState to create it.`);
@@ -116,7 +117,7 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             status: row.status,
             result: parseJson(row.result),
             error: parseJson(row.error),
-            attemptCount: Number(row.attemptCount),
+            attemptCount: Number(row.currentAttempt ?? 1),
             retries: row.retries != null ? Number(row.retries) : undefined,
             retryDelay: row.retryDelay ?? undefined,
             fromStepName: row.fromStepName ?? undefined,
@@ -124,29 +125,45 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             updatedAt: new Date(row.updatedAt),
         };
     }
+    async listStepStates(runId) {
+        const rows = await this.db
+            .selectFrom('workflowStep')
+            .select([
+            'workflowStepId',
+            'stepName',
+            'status',
+            'result',
+            'error',
+            'retries',
+            'retryDelay',
+            'fromStepName',
+            'currentAttempt',
+            'createdAt',
+            'updatedAt',
+        ])
+            .where('workflowRunId', '=', runId)
+            .execute();
+        return rows.map((row) => ({
+            stepId: row.workflowStepId,
+            stepName: row.stepName,
+            status: row.status,
+            result: parseJson(row.result),
+            error: parseJson(row.error),
+            attemptCount: Number(row.currentAttempt ?? 1),
+            retries: row.retries != null ? Number(row.retries) : undefined,
+            retryDelay: row.retryDelay ?? undefined,
+            fromStepName: row.fromStepName ?? undefined,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        }));
+    }
     async getRunHistory(runId) {
         return this.runService.getRunHistory(runId);
     }
     async setStepRunningImpl(stepId) {
-        await this.db
-            .updateTable('workflowStep')
-            .set({ status: 'running', updatedAt: new Date() })
-            .where('workflowStepId', '=', stepId)
-            .execute();
-        const latestHistory = await this.db
-            .selectFrom('workflowStepHistory')
-            .select('historyId')
-            .where('workflowStepId', '=', stepId)
-            .orderBy('createdAt', 'desc')
-            .limit(1)
-            .executeTakeFirst();
-        if (latestHistory) {
-            await this.db
-                .updateTable('workflowStepHistory')
-                .set({ status: 'running', runningAt: new Date() })
-                .where('historyId', '=', latestHistory.historyId)
-                .execute();
-        }
+        await this.writeStepTransition(stepId, 'running', {
+            runningAt: new Date(),
+        });
     }
     async setStepScheduledImpl(stepId) {
         await this.db
@@ -155,12 +172,85 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             .where('workflowStepId', '=', stepId)
             .execute();
     }
-    async insertHistoryRecord(stepId, status, result, error) {
+    /**
+     * Move a step and its current history attempt to the same status in one
+     * transaction.
+     *
+     * Both halves matter: a crash between them used to leave the step row saying
+     * `succeeded` while its history row still said `running`, which silently
+     * corrupts `getRunHistory` and every timeline reconstruction built on it.
+     * The history row is targeted by its `attempt` rather than by a `LIMIT 1`
+     * over `created_at`, so a retry that lands in the same millisecond as the
+     * attempt it replaces still resolves the newer row.
+     */
+    async writeStepTransition(stepId, status, historyValues) {
+        const now = new Date();
+        const stepValues = { status, updatedAt: now };
+        if ('result' in historyValues)
+            stepValues.result = historyValues.result;
+        if ('error' in historyValues)
+            stepValues.error = historyValues.error;
+        // A step carries only its latest outcome, so the other half is cleared.
+        if (status === 'succeeded')
+            stepValues.error = null;
+        if (status === 'failed')
+            stepValues.result = null;
+        await this.db.transaction().execute(async (trx) => {
+            await trx
+                .updateTable('workflowStep')
+                .set({
+                ...stepValues,
+                // A step that somehow reaches a transition without a live attempt
+                // addresses no history row at all, so give it one here. Written as an
+                // expression over the row's own column rather than a subquery, which
+                // MySQL would reject against the table being updated.
+                currentAttempt: sql `coalesce(current_attempt, 1)`,
+            })
+                .where('workflowStepId', '=', stepId)
+                .execute();
+            const written = await trx
+                .updateTable('workflowStepHistory')
+                .set({ status, ...historyValues })
+                .where('workflowStepId', '=', stepId)
+                // Correlate through the step row rather than a MAX() over this table:
+                // MySQL rejects a subquery that reads the table being updated, and a
+                // primary-key lookup is cheaper than an aggregate anyway.
+                .where('attempt', '=', (eb) => eb
+                .selectFrom('workflowStep')
+                .select('currentAttempt')
+                .where('workflowStepId', '=', stepId))
+                .executeTakeFirst();
+            // Matching nothing means the attempt has no history row to move, which
+            // would commit the step's new status with no record of it — precisely
+            // the divergence this transaction exists to prevent. Write the missing
+            // row instead of letting the pair drift apart.
+            if (Number(written?.numUpdatedRows ?? 0n) === 0) {
+                const step = await trx
+                    .selectFrom('workflowStep')
+                    .select('currentAttempt')
+                    .where('workflowStepId', '=', stepId)
+                    .executeTakeFirst();
+                await trx
+                    .insertInto('workflowStepHistory')
+                    .values({
+                    historyId: crypto.randomUUID(),
+                    workflowStepId: stepId,
+                    status,
+                    attempt: step?.currentAttempt ?? 1,
+                    createdAt: now,
+                    ...historyValues,
+                })
+                    .execute();
+            }
+        });
+    }
+    async insertHistoryRecord(stepId, status, attempt, result, error) {
         const now = new Date();
         const values = {
             historyId: crypto.randomUUID(),
             workflowStepId: stepId,
             status,
+            attempt,
             result: result != null ? JSON.stringify(result) : null,
             error: error != null ? JSON.stringify(error) : null,
             createdAt: now,
@@ -199,35 +289,10 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             .execute();
     }
     async setStepResultImpl(stepId, result) {
-        const resultJson = JSON.stringify(result);
-        await this.db
-            .updateTable('workflowStep')
-            .set({
-            status: 'succeeded',
-            result: resultJson,
-            error: null,
-            updatedAt: new Date(),
-        })
-            .where('workflowStepId', '=', stepId)
-            .execute();
-        const latestHistory = await this.db
-            .selectFrom('workflowStepHistory')
-            .select('historyId')
-            .where('workflowStepId', '=', stepId)
-            .orderBy('createdAt', 'desc')
-            .limit(1)
-            .executeTakeFirst();
-        if (latestHistory) {
-            await this.db
-                .updateTable('workflowStepHistory')
-                .set({
-                status: 'succeeded',
-                result: resultJson,
-                succeededAt: new Date(),
-            })
-                .where('historyId', '=', latestHistory.historyId)
-                .execute();
-        }
+        await this.writeStepTransition(stepId, 'succeeded', {
+            result: JSON.stringify(result),
+            succeededAt: new Date(),
+        });
     }
     async setStepErrorImpl(stepId, error) {
         const serializedError = {
@@ -235,65 +300,54 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             stack: error.stack,
             code: error.code,
         };
-        const errorJson = JSON.stringify(serializedError);
+        await this.writeStepTransition(stepId, 'failed', {
+            error: JSON.stringify(serializedError),
+            failedAt: new Date(),
+        });
+    }
+    async createRetryAttemptImpl(stepId, status) {
+        // Read before writing: the new attempt number comes from the history this
+        // step already has, and the row it reads is the one returned below.
+        const previous = await this.db
+            .selectFrom('workflowStep')
+            .select('currentAttempt')
+            .where('workflowStepId', '=', stepId)
+            .executeTakeFirst();
+        const attempt = (previous?.currentAttempt ?? 0) + 1;
         await this.db
             .updateTable('workflowStep')
             .set({
-            status: 'failed',
-            error: errorJson,
+            status,
             result: null,
+            error: null,
+            currentAttempt: attempt,
             updatedAt: new Date(),
         })
             .where('workflowStepId', '=', stepId)
             .execute();
-        const latestHistory = await this.db
-            .selectFrom('workflowStepHistory')
-            .select('historyId')
-            .where('workflowStepId', '=', stepId)
-            .orderBy('createdAt', 'desc')
-            .limit(1)
-            .executeTakeFirst();
-        if (latestHistory) {
-            await this.db
-                .updateTable('workflowStepHistory')
-                .set({ status: 'failed', error: errorJson, failedAt: new Date() })
-                .where('historyId', '=', latestHistory.historyId)
-                .execute();
-        }
-    }
-    async createRetryAttemptImpl(stepId, status) {
-        await this.db
-            .updateTable('workflowStep')
-            .set({ status, result: null, error: null, updatedAt: new Date() })
-            .where('workflowStepId', '=', stepId)
-            .execute();
-        await this.insertHistoryRecord(stepId, status);
+        await this.insertHistoryRecord(stepId, status, attempt);
         const row = await this.db
-            .selectFrom('workflowStep as s')
+            .selectFrom('workflowStep')
             .select([
-            's.workflowStepId',
-            's.status',
-            's.result',
-            's.error',
-            's.retries',
-            's.retryDelay',
-            's.fromStepName',
-            's.createdAt',
-            's.updatedAt',
+            'workflowStepId',
+            'status',
+            'result',
+            'error',
+            'retries',
+            'retryDelay',
+            'fromStepName',
+            'currentAttempt',
+            'createdAt',
+            'updatedAt',
         ])
-            .select((eb) => eb
-            .selectFrom('workflowStepHistory')
-            .select(eb.fn.countAll().as('cnt'))
-            .whereRef('workflowStepHistory.workflowStepId', '=', 's.workflowStepId')
-            .as('attemptCount'))
-            .where('s.workflowStepId', '=', stepId)
+            .where('workflowStepId', '=', stepId)
             .executeTakeFirstOrThrow();
         return {
             stepId: row.workflowStepId,
             status: row.status,
             result: parseJson(row.result),
             error: parseJson(row.error),
-            attemptCount: Number(row.attemptCount),
+            attemptCount: Number(row.currentAttempt ?? 1),
             retries: row.retries != null ? Number(row.retries) : undefined,
             retryDelay: row.retryDelay ?? undefined,
             fromStepName: row.fromStepName ?? undefined,
@@ -386,17 +440,39 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
             .where('workflowStepId', '=', stepId)
             .execute();
     }
+    /**
+     * Merge one key into the run's JSON state, as a single expression evaluated
+     * by the database.
+     *
+     * The SQL is dialect-specific, so subclasses override this rather than the
+     * caller. The default is the SQLite form; MySQL and Postgres differ in how
+     * they cast a JSON literal.
+     *
+     * @param path - JSON path to the key, already quoted (`$."key"`)
+     * @param json - The value as JSON text
+     */
+    jsonSetState(path, json) {
+        return sql `json_set(coalesce(state, '{}'), ${path}, json(${json}))`;
+    }
+    /**
+     * A JSON path for an arbitrary key. State keys are user-supplied (a graph's
+     * `setState` name, an approval's hex-encoded reason), so the key is quoted
+     * rather than interpolated bare — an unquoted `$.a.b` would silently address
+     * a nested path instead of the key literally called `a.b`.
+     */
+    jsonPathFor(name) {
+        return `$.${JSON.stringify(name)}`;
+    }
     async updateRunStateImpl(runId, name, value) {
-        const row = await this.db
-            .selectFrom('workflowRuns')
-            .select('state')
-            .where('workflowRunId', '=', runId)
-            .executeTakeFirst();
-        const state = parseJson(row?.state) ?? {};
-        state[name] = value;
+        // Merged by the database, not read-modify-written in JS: two graph nodes
+        // calling setState concurrently used to race, and the later write silently
+        // dropped whichever key the earlier one had added.
         await this.db
             .updateTable('workflowRuns')
-            .set({ state: JSON.stringify(state), updatedAt: new Date() })
+            .set({
+            state: this.jsonSetState(this.jsonPathFor(name), JSON.stringify(value ?? null)),
+            updatedAt: new Date(),
+        })
             .where('workflowRunId', '=', runId)
             .execute();
     }
@@ -434,21 +510,5 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
     async getWorkflowVersion(name, graphHash) {
         return this.runService.getWorkflowVersion(name, graphHash);
     }
-    async getAIGeneratedWorkflows(agentName) {
-        let query = this.db
-            .selectFrom('workflowVersions')
-            .select(['workflowName', 'graphHash', 'graph'])
-            .where('source', '=', 'dynamic-workflow')
-            .where('status', '=', 'active');
-        if (agentName) {
-            query = query.where('workflowName', 'like', `ai:${agentName}:%`);
-        }
-        const rows = await query.execute();
-        return rows.map((row) => ({
-            workflowName: row.workflowName,
-            graphHash: row.graphHash,
-            graph: typeof row.graph === 'string' ? JSON.parse(row.graph) : row.graph,
-        }));
-    }
     async close() { }
 }

package/dist/src/schema/index.d.ts

@@ -51,6 +51,23 @@ export declare const unsatisfiedRequirements: (db: Kysely<any>, schemas?: PikkuS
  * is the engine's to give, not ours.
  */
 export declare const applyPikkuSchemas: (db: Kysely<any>, schemas?: PikkuSchema[]) => Promise<void>;
+/** A table a schema creates, as the DDL addresses it. */
+export interface DeclaredTable {
+    /** Present when the connection is `withSchema(...)`-bound. */
+    schema?: string;
+    name: string;
+}
+/**
+ * The tables a schema creates, read back out of its own compiled SQL.
+ *
+ * Derived rather than declared alongside the statements, because a hand-kept
+ * list of names is a second source of truth: rename a table in a statement and
+ * the list keeps answering for the old one.
+ *
+ * Compiled against `db` rather than in the abstract, so the answer carries the
+ * schema the DDL will actually target — the same binding the lookup has to use.
+ */
+export declare const declaredTables: (schema: PikkuSchema, db: Kysely<any>) => DeclaredTable[];
 /** What `ensurePikkuSchema` found when it looked. */
 export type EnsureOutcome = 'present' | 'created';
 /**

package/dist/src/schema/index.js

@@ -103,29 +103,113 @@ export const applyPikkuSchemas = async (db, schemas = pikkuSchemas) => {
         const bound = bind(trx);
         for (const schema of schemas) {
             for (const statement of schema.statements) {
-                await statement(bound, types).execute();
+                const query = statement(bound, types);
+                try {
+                    await query.execute();
+                }
+                catch (error) {
+                    throw explain(error, query.compile().sql, schema);
+                }
             }
         }
     });
 };
+/** `references "app"."workflow_runs"` — a foreign key onto a qualified table. */
+const QUALIFIED_REFERENCE = /references "[^"]+"\."[^"]+"/i;
+/**
+ * sqlite's own words for "you put a dot where a table name goes".
+ *
+ * Matched rather than a driver's `code`, because every sqlite binding
+ * (better-sqlite3, node:sqlite, bun:sqlite, libsql) passes the engine's message
+ * through verbatim while disagreeing about how to label it. Postgres phrases the
+ * same class of error the other way round — `syntax error at or near "."` — so
+ * this cannot fire on it.
+ */
+const SQLITE_REJECTED_QUALIFIER = /near "\.":\s*syntax error/i;
+/**
+ * Say what a schema-bound connection did to the DDL, when that is what failed.
+ *
+ * `withSchema(...)` qualifies foreign key targets along with everything else.
+ * Postgres needs that — an unqualified reference resolves against `search_path`,
+ * which a schema-bound connection does not control — and sqlite refuses it: a
+ * `REFERENCES` clause there takes a bare table name, because a foreign key can
+ * only point inside the same database, so there is no qualifier to give. One
+ * declaration cannot spell both, and what the engine says about it is
+ * `near ".": syntax error`, which names neither the schema nor the cause.
+ *
+ * Gated on sqlite's exact phrasing as well as the SQL. Postgres compiles the
+ * same qualified reference legitimately, and can raise a syntax error of its own
+ * on this DDL — a column type resolved from `requires` goes in verbatim — so a
+ * looser `/syntax error/` would answer for postgres in sqlite's name.
+ */
+const explain = (error, sql, schema) => {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!QUALIFIED_REFERENCE.test(sql) ||
+        !SQLITE_REJECTED_QUALIFIER.test(message)) {
+        return error;
+    }
+    return new Error(`The '${schema.name}' schema has a foreign key, and this connection is bound to a schema, ` +
+        `so it compiled to a qualified 'references "schema"."table"' that the database rejected. ` +
+        'sqlite is the engine that does this: its REFERENCES clause takes a bare table name. ' +
+        'Use a connection without withSchema(...) there — sqlite has one schema to be in — ' +
+        'or write the schema down as a migration with `pikku db generate` and apply it yourself. ' +
+        `The database said: ${message}`, { cause: error });
+};
+/** How a table reads in an error message: qualified only when it is. */
+const displayName = (table) => table.schema ? `${table.schema}.${table.name}` : table.name;
+/**
+ * `create table "workflow_runs"` and `create table "app"."workflow_runs"`.
+ *
+ * The schema half is optional and the table is always the LAST quoted
+ * identifier — matching the first one instead reads a `withSchema('app')`
+ * connection's DDL as a table called `app`, which is no table at all.
+ */
+const CREATE_TABLE = /^\s*create table (?:if not exists\s+)?(?:"([^"]+)"\.)?"([^"]+)"/i;
 /**
  * The tables a schema creates, read back out of its own compiled SQL.
  *
  * Derived rather than declared alongside the statements, because a hand-kept
  * list of names is a second source of truth: rename a table in a statement and
  * the list keeps answering for the old one.
+ *
+ * Compiled against `db` rather than in the abstract, so the answer carries the
+ * schema the DDL will actually target — the same binding the lookup has to use.
  */
-const declaredTables = (schema, db) => {
+export const declaredTables = (schema, db) => {
     const bound = bind(db);
     const tables = [];
     for (const statement of schema.statements) {
-        const match = /^\s*create table "([^"]+)"/i.exec(statement(bound, {}).compile().sql);
+        const match = CREATE_TABLE.exec(statement(bound, {}).compile().sql);
         if (match)
-            tables.push(match[1]);
+            tables.push({ schema: match[1], name: match[2] });
     }
     return tables;
 };
-const tablesOf = async (db) => new Set((await bind(db).introspection.getTables()).map((table) => table.name));
+const tablesOf = async (db) => {
+    const tables = await bind(db).introspection.getTables();
+    return {
+        qualified: new Set(tables
+            .filter((table) => table.schema)
+            .map((table) => `${table.schema}.${table.name}`)),
+        bare: new Set(tables.map((table) => table.name)),
+        schemaAware: tables.some((table) => table.schema !== undefined),
+    };
+};
+/**
+ * Qualified declarations match on the pair — but only where that pair means
+ * something.
+ *
+ * `TableMetadata.schema` is optional, and sqlite and mysql leave it unset:
+ * sqlite has one schema to be in, and mysql calls the thing a database. A
+ * `withSchema('main')` connection there declares `main.workflow_runs` while
+ * introspection can only offer `workflow_runs`, and holding out for the pair
+ * would read every existing table as missing — the same false negative this
+ * whole function exists to fix, arrived at from the other side. So when the
+ * engine reports no schemas, the bare name is the only name there is.
+ */
+const isPresent = (existing, table) => table.schema && existing.schemaAware
+    ? existing.qualified.has(`${table.schema}.${table.name}`)
+    : existing.bare.has(table.name);
 /**
  * Make sure one schema's tables are there, creating them only if none are.
  *
@@ -147,12 +231,15 @@ const tablesOf = async (db) => new Set((await bind(db).introspection.getTables()
 export const ensurePikkuSchema = async (db, schema) => {
     const existing = await tablesOf(db);
     const declared = declaredTables(schema, db);
-    const missing = declared.filter((table) => !existing.has(table));
+    const missing = declared.filter((table) => !isPresent(existing, table));
     if (missing.length === 0)
         return 'present';
     if (missing.length < declared.length) {
-        throw new Error(`The '${schema.name}' schema is half applied: ${missing.join(', ')} missing, ` +
-            `${declared.filter((table) => existing.has(table)).join(', ')} already there. ` +
+        throw new Error(`The '${schema.name}' schema is half applied: ${missing.map(displayName).join(', ')} missing, ` +
+            `${declared
+                .filter((table) => isPresent(existing, table))
+                .map(displayName)
+                .join(', ')} already there. ` +
             'Something else owns part of it. Reconcile it with a migration — ' +
             '`pikku db generate` writes the declaration down — rather than creating the rest at boot.');
     }
@@ -167,7 +254,7 @@ export const ensurePikkuSchema = async (db, schema) => {
         // a guarantee — a boot race is only fully answered by having run the
         // migration, which is what `pikku db generate` is for.
         const after = await tablesOf(db);
-        if (declared.every((table) => after.has(table)))
+        if (declared.every((table) => isPresent(after, table)))
             return 'present';
         throw error;
     }

package/dist/src/schema/workflow.schema.d.ts

@@ -6,8 +6,10 @@ import type { PikkuSchema } from './pikku-schema.types.js';
  * primary keys had `defaultTo(sql.raw("'" + crypto.randomUUID() + "'"))`, which
  * evaluates once while the statement is built — every row would have taken the
  * same default, so it was never a generator; the services supply the id. And
- * `workflowStep.fromStepName` was backfilled by an `alterTable(...).catch(() =>
- * {})` bolted on after the fact, which is the job a migration does.
+ * `workflowStep.fromStepName`, `workflowStep.currentAttempt` and
+ * `workflowStepHistory.attempt` were each backfilled by an
+ * `alterTable(...).catch(() => {})` bolted on after the fact, which is the job a
+ * migration does — they are declared here and nowhere else.
  *
  * `KyselyWorkflowMirror` created these same four tables separately. There is one
  * declaration now, and both services read it.

package/dist/src/schema/workflow.schema.js

@@ -6,8 +6,10 @@ import { sql } from 'kysely';
  * primary keys had `defaultTo(sql.raw("'" + crypto.randomUUID() + "'"))`, which
  * evaluates once while the statement is built — every row would have taken the
  * same default, so it was never a generator; the services supply the id. And
- * `workflowStep.fromStepName` was backfilled by an `alterTable(...).catch(() =>
- * {})` bolted on after the fact, which is the job a migration does.
+ * `workflowStep.fromStepName`, `workflowStep.currentAttempt` and
+ * `workflowStepHistory.attempt` were each backfilled by an
+ * `alterTable(...).catch(() => {})` bolted on after the fact, which is the job a
+ * migration does — they are declared here and nowhere else.
  *
  * `KyselyWorkflowMirror` created these same four tables separately. There is one
  * declaration now, and both services read it.
@@ -49,6 +51,7 @@ export const workflowSchema = {
             .addColumn('retries', 'integer')
             .addColumn('retryDelay', 'text')
             .addColumn('fromStepName', 'text')
+            .addColumn('currentAttempt', 'integer')
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addUniqueConstraint('workflow_step_run_name_unique', [
@@ -65,6 +68,7 @@ export const workflowSchema = {
             .addColumn('status', 'text', (col) => col.notNull())
             .addColumn('result', 'text')
             .addColumn('error', 'text')
+            .addColumn('attempt', 'integer')
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('runningAt', 'timestamp')
             .addColumn('scheduledAt', 'timestamp')
@@ -82,5 +86,27 @@ export const workflowSchema = {
             'workflowName',
             'graphHash',
         ]),
+        // The indexes trail the tables so that a table is never indexed before it
+        // exists, whatever order the declarations are read in.
+        (db) => db.schema
+            .createIndex('idx_workflow_runs_status_created')
+            .on('workflowRuns')
+            .columns(['status', 'createdAt']),
+        (db) => db.schema
+            .createIndex('idx_workflow_runs_workflow_created')
+            .on('workflowRuns')
+            .columns(['workflow', 'createdAt']),
+        (db) => db.schema
+            .createIndex('idx_workflow_step_run_status')
+            .on('workflowStep')
+            .columns(['workflowRunId', 'status']),
+        (db) => db.schema
+            .createIndex('idx_workflow_step_history_step')
+            .on('workflowStepHistory')
+            .columns(['workflowStepId', 'createdAt']),
+        (db) => db.schema
+            .createIndex('idx_workflow_versions_source_status')
+            .on('workflowVersions')
+            .columns(['source', 'status']),
     ],
 };