@pikku/kysely 0.13.2 → 0.13.4

package/CHANGELOG.md

@@ -1,3 +1,59 @@
+## 0.13.4
+
+### Patch Changes
+
+- 91077ff: Declare the pikku runtime tables instead of creating them at boot.
+
+  The tables the runtime needs — workflow, AI, scopes, secrets, credentials, webhooks, channels, deployments, sessions — were created by `createTable(...).ifNotExists()` inside each service's `init()`. A table therefore existed if and only if some service happened to be constructed, in whatever order, with whatever schema qualifier that call site passed. In one deployment that produced a duplicate set of AI tables in `public` shadowing the intended ones in `app`.
+
+  `pikkuSchemas` is now the single declaration, exported from `@pikku/kysely`: the same kysely schema-builder chains, moved out of `init()` and never executed at boot. `applyPikkuSchemas` materializes them onto a database, `compilePikkuSchemas` renders them as SQL for a dialect, and both bind `CamelCasePlugin` themselves so a declaration always compiles to the physical names the rest of the package queries.
+
+  `applyPikkuSchemas` runs its statements in one transaction, so the promise it makes about a half-applied database holds for the failures the prerequisite check cannot foresee too — a statement colliding with a table something else already created rolls back the ones that ran before it.
+
+  Auth is a declared prerequisite. `pikkuUserRole` and `pikkuUserScope` reference `user.id`, which Better Auth owns, so `scopeSchema` says so via `requires` and `applyPikkuSchemas` checks every prerequisite before creating anything — a project without auth gets a sentence naming what is missing and who owns it, not a foreign key error and not a half-applied database. `resolveRequirements` returns the same answer as data for callers that need to describe the gap rather than die on it.
+
+  That prerequisite also fixes a fourth disagreement: `user_id` was declared `text`, but `user.id` has no fixed type — Better Auth decides it from config, giving `uuid` under `generateId: 'uuid'` and an identity `integer` under `'serial'`, and postgres refuses a `text` column referencing either. The whole statement was rejected, so `KyselyScopeService.init()` had never actually created these tables on such a project — one had a migration written by hand with a comment explaining why. The column now takes its type from the column it references, whatever that turns out to be.
+
+  Three further disagreements the single declaration settled:
+  - `aiRun` was created by two services with different columns. `KyselyAIStorageService` omitted `pendingApprovals`; `KyselyAIRunStateService` declared it and read it back through `as any` casts. Whichever ran first decided the shape, and where the storage service won, resolving an approval failed. The column is declared.
+  - `workflowRuns`, `workflowStep` and `workflowStepHistory` defaulted their primary keys to `sql.raw("'" + crypto.randomUUID() + "'")`, evaluated once when the statement was built — one shared default for every row, not a generator. Dropped; the services supply the id.
+  - `workflowStep.fromStepName` was backfilled by an `alterTable(...).execute().catch(() => {})` bolted on after the fact. It is part of the declaration.
+
+  Every service's `init()` now goes through `ensurePikkuSchema`, which looks before it creates: all the tables present is a no-op, none present creates them from the declaration, and some present throws rather than filling in the rest. That last case is the point. `.ifNotExists()` turned every failure into a silent success — it is why nobody noticed the `user_id` type had been rejected since the day it was written — and a schema half-owned by a migration and half by a boot-time create is the condition all of this exists to end. Around 615 lines of duplicated DDL went with it.
+
+  Creating at boot is now the fallback rather than the intent: run `pikku db generate` and `init()` takes the `present` path and issues no DDL at all.
+
+  `KyselyPikkuDB` stays hand-written, because it carries what introspection cannot recover — `WorkflowStatus` rather than `string`, `Generated<Date>` rather than `Date`. A test materializes the declaration and asserts the two agree on every table and column, which is the drift protection generating it would have bought. It found one on its first run: `ai_run.pending_approvals` was in the DDL and in `KyselyAIRunStateService`, but not in `AIRunTable` — the reason that service read it back through `as any`. Declared, and the casts are gone.
+
+## 0.13.3
+
+### Patch Changes
+
+- e3d4454: Add job groups, so one shared queue can stay fair without splitting into one
+  queue per producer.
+
+  A job may now carry `group: { id, tier }`, and a worker may cap how many jobs
+  of any one group run at once via `groupConcurrency`. On pg-boss this maps to
+  `localGroupConcurrency`, which excludes at-capacity groups from the fetch query
+  itself, so a capped group costs nothing rather than being fetched and restored.
+  BullMQ declares it unsupported (groups are a BullMQ Pro feature) — being
+  push-based, it can simply use a queue per group at no polling cost.
+
+  Workflow services accept a `queueStrategy`. The default `'per-workflow'` is
+  unchanged: every workflow gets its own `wf-orchestrator-*` / `wf-step-*` queue,
+  which is also what lets serverless providers deploy one unit per workflow. The
+  new `'shared-groups'` routes every workflow through the shared
+  orchestrator/step-worker queues and isolates them by group instead, so a
+  monolith runs one set of pollers rather than one per workflow — on a
+  pull-based backend with dozens of workflows that is the difference between
+  hundreds of poll loops and twenty. It is for single-process runtimes only; a
+  per-unit serverless deploy still needs the per-workflow queues to route to its
+  units.
+
+- Updated dependencies [24252b8]
+- Updated dependencies [e3d4454]
+  - @pikku/core@0.12.69
+
 ## 0.13.2
 
 ### Patch Changes

package/dist/src/index.d.ts

@@ -17,6 +17,7 @@ export { KyselyWebhookService } from './kysely-webhook-service.js';
 export { createAuditedKysely, type CreateAuditedKyselyOptions, } from './create-audited-kysely.js';
 export { KyselyAuditService } from './kysely-audit-service.js';
 export { SerializePlugin, SqliteSerializePlugin, BaseSerializePlugin, defaultSerializer, defaultDeserializer, maybeJson, skipTransform, dateRegex, type Serializer, type Deserializer, type SerializePluginOptions, } from './serialize-plugin.js';
+export { pikkuSchemas, applyPikkuSchemas, compilePikkuSchemas, ensurePikkuSchema, type EnsureOutcome, resolveRequirements, unsatisfiedRequirements, rawStatement, requiredType, type PikkuSchema, type RequiredTypes, type SchemaRequirement, type UnmetRequirement, type SchemaStatement, type SchemaStatementFactory, } from './schema/index.js';
 export type { KyselyPikkuDB } from './kysely-tables.js';
 export type { WorkflowRunService } from '@pikku/core/workflow';
 export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent';

package/dist/src/index.js

@@ -15,3 +15,4 @@ export { KyselyWebhookService } from './kysely-webhook-service.js';
 export { createAuditedKysely, } from './create-audited-kysely.js';
 export { KyselyAuditService } from './kysely-audit-service.js';
 export { SerializePlugin, SqliteSerializePlugin, BaseSerializePlugin, defaultSerializer, defaultDeserializer, maybeJson, skipTransform, dateRegex, } from './serialize-plugin.js';
+export { pikkuSchemas, applyPikkuSchemas, compilePikkuSchemas, ensurePikkuSchema, resolveRequirements, unsatisfiedRequirements, rawStatement, requiredType, } from './schema/index.js';

package/dist/src/kysely-ai-run-state-service.js

@@ -1,4 +1,6 @@
 import { sql } from 'kysely';
+import { ensurePikkuSchema } from './schema/index.js';
+import { aiSchema } from './schema/ai.schema.js';
 export class KyselyAIRunStateService {
     db;
     initialized = false;
@@ -8,24 +10,7 @@ export class KyselyAIRunStateService {
     async init() {
         if (this.initialized)
             return;
-        await this.db.schema
-            .createTable('aiRun')
-            .ifNotExists()
-            .addColumn('runId', 'text', (col) => col.primaryKey())
-            .addColumn('agentName', 'text', (col) => col.notNull())
-            .addColumn('threadId', 'text', (col) => col.notNull())
-            .addColumn('resourceId', 'text', (col) => col.notNull())
-            .addColumn('status', 'text', (col) => col.defaultTo('running').notNull())
-            .addColumn('errorMessage', 'text')
-            .addColumn('suspendReason', 'text')
-            .addColumn('missingRpcs', 'text')
-            .addColumn('pendingApprovals', 'text')
-            .addColumn('usageInputTokens', 'integer', (col) => col.defaultTo(0))
-            .addColumn('usageOutputTokens', 'integer', (col) => col.defaultTo(0))
-            .addColumn('usageModel', 'text', (col) => col.defaultTo(''))
-            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
+        await ensurePikkuSchema(this.db, aiSchema);
         this.initialized = true;
     }
     async createRun(run) {

package/dist/src/kysely-ai-storage-service.d.ts

@@ -6,7 +6,6 @@ export declare class KyselyAIStorageService implements AIStorageService, AIRunSt
     private db;
     private initialized;
     constructor(db: Kysely<KyselyPikkuDB>);
-    private createIndexSafe;
     init(): Promise<void>;
     createThread(resourceId: string, options?: {
         threadId?: string;

package/dist/src/kysely-ai-storage-service.js

@@ -1,113 +1,16 @@
-import { sql } from 'kysely';
 import { parseJson } from './kysely-json.js';
+import { ensurePikkuSchema } from './schema/index.js';
+import { aiSchema } from './schema/ai.schema.js';
 export class KyselyAIStorageService {
     db;
     initialized = false;
     constructor(db) {
         this.db = db;
     }
-    async createIndexSafe(builder) {
-        try {
-            await builder.execute();
-        }
-        catch (e) {
-            // Ignore "index already exists" errors across databases
-            // MySQL: ER_DUP_KEYNAME, Postgres: 42P07, SQLite: "already exists"
-            if (e?.code === 'ER_DUP_KEYNAME' || e?.errno === 1061)
-                return;
-            if (e?.code === '42P07')
-                return;
-            if (e?.message?.includes('already exists'))
-                return;
-            throw e;
-        }
-    }
     async init() {
-        if (this.initialized) {
+        if (this.initialized)
             return;
-        }
-        await this.db.schema
-            .createTable('ai_threads')
-            .ifNotExists()
-            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('resource_id', 'varchar(255)', (col) => col.notNull())
-            .addColumn('title', 'text')
-            .addColumn('metadata', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await this.createIndexSafe(this.db.schema
-            .createIndex('idx_ai_threads_resource')
-            .on('ai_threads')
-            .column('resource_id'));
-        await this.db.schema
-            .createTable('ai_message')
-            .ifNotExists()
-            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('thread_id', 'varchar(36)', (col) => col.notNull().references('ai_threads.id').onDelete('cascade'))
-            .addColumn('role', 'varchar(50)', (col) => col.notNull())
-            .addColumn('content', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await this.createIndexSafe(this.db.schema
-            .createIndex('idx_ai_message_thread')
-            .on('ai_message')
-            .columns(['thread_id', 'created_at']));
-        await this.db.schema
-            .createTable('ai_tool_call')
-            .ifNotExists()
-            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('thread_id', 'varchar(36)', (col) => col.notNull().references('ai_threads.id').onDelete('cascade'))
-            .addColumn('message_id', 'varchar(36)', (col) => col.notNull().references('ai_message.id').onDelete('cascade'))
-            .addColumn('run_id', 'varchar(36)')
-            .addColumn('tool_name', 'varchar(255)', (col) => col.notNull())
-            .addColumn('args', 'text', (col) => col.notNull())
-            .addColumn('result', 'text')
-            .addColumn('approval_status', 'varchar(50)')
-            .addColumn('approval_type', 'varchar(50)')
-            .addColumn('agent_run_id', 'varchar(36)')
-            .addColumn('display_tool_name', 'varchar(255)')
-            .addColumn('display_args', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await this.createIndexSafe(this.db.schema
-            .createIndex('idx_ai_tool_call_thread')
-            .on('ai_tool_call')
-            .column('thread_id'));
-        await this.createIndexSafe(this.db.schema
-            .createIndex('idx_ai_tool_call_message')
-            .on('ai_tool_call')
-            .column('message_id'));
-        await this.db.schema
-            .createTable('ai_working_memory')
-            .ifNotExists()
-            .addColumn('id', 'varchar(255)', (col) => col.notNull())
-            .addColumn('scope', 'varchar(50)', (col) => col.notNull())
-            .addColumn('data', 'text', (col) => col.notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addPrimaryKeyConstraint('ai_working_memory_pk', ['id', 'scope'])
-            .execute();
-        await this.db.schema
-            .createTable('ai_run')
-            .ifNotExists()
-            .addColumn('run_id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('agent_name', 'varchar(255)', (col) => col.notNull())
-            .addColumn('thread_id', 'varchar(36)', (col) => col.notNull().references('ai_threads.id').onDelete('cascade'))
-            .addColumn('resource_id', 'varchar(255)', (col) => col.notNull())
-            .addColumn('status', 'varchar(50)', (col) => col.notNull().defaultTo('running'))
-            .addColumn('error_message', 'text')
-            .addColumn('suspend_reason', 'text')
-            .addColumn('missing_rpcs', 'text')
-            .addColumn('usage_input_tokens', 'integer', (col) => col.notNull().defaultTo(0))
-            .addColumn('usage_output_tokens', 'integer', (col) => col.notNull().defaultTo(0))
-            .addColumn('usage_model', 'varchar(255)', (col) => col.notNull().defaultTo(''))
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await this.createIndexSafe(this.db.schema
-            .createIndex('idx_ai_run_thread')
-            .on('ai_run')
-            .columns(['thread_id', 'created_at']));
+        await ensurePikkuSchema(this.db, aiSchema);
         this.initialized = true;
     }
     async createThread(resourceId, options) {

package/dist/src/kysely-channel-store.js

@@ -1,6 +1,7 @@
 import { ChannelStore } from '@pikku/core/channel';
-import { sql } from 'kysely';
 import { parseJson } from './kysely-json.js';
+import { ensurePikkuSchema } from './schema/index.js';
+import { channelSchema } from './schema/channel.schema.js';
 export class KyselyChannelStore extends ChannelStore {
     db;
     initialized = false;
@@ -9,30 +10,9 @@ export class KyselyChannelStore extends ChannelStore {
         this.db = db;
     }
     async init() {
-        if (this.initialized) {
+        if (this.initialized)
             return;
-        }
-        await this.db.schema
-            .createTable('channels')
-            .ifNotExists()
-            .addColumn('channel_id', 'text', (col) => col.primaryKey())
-            .addColumn('channel_name', 'text', (col) => col.notNull())
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('opening_data', 'text', (col) => col.notNull().defaultTo('{}'))
-            .addColumn('pikku_user_id', 'text')
-            .addColumn('state', 'text')
-            .addColumn('last_wire', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await this.db.schema
-            .createTable('channel_subscriptions')
-            .ifNotExists()
-            .addColumn('channel_id', 'text', (col) => col.notNull().references('channels.channel_id').onDelete('cascade'))
-            .addColumn('topic', 'text', (col) => col.notNull())
-            .addPrimaryKeyConstraint('channel_subscriptions_pk', [
-            'channel_id',
-            'topic',
-        ])
-            .execute();
+        await ensurePikkuSchema(this.db, channelSchema);
         this.initialized = true;
     }
     async addChannel({ channelId, channelName, openingData, }) {

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

@@ -1,5 +1,6 @@
-import { sql } from 'kysely';
 import { envelopeEncrypt, envelopeDecrypt, envelopeRewrap, } from '@pikku/core/crypto-utils';
+import { ensurePikkuSchema } from './schema/index.js';
+import { credentialSchema } from './schema/credential.schema.js';
 export class KyselyCredentialService {
     db;
     initialized = false;
@@ -19,29 +20,7 @@ export class KyselyCredentialService {
     async init() {
         if (this.initialized)
             return;
-        await this.db.schema
-            .createTable('credentials')
-            .ifNotExists()
-            .addColumn('name', 'varchar(255)', (col) => col.notNull())
-            .addColumn('user_id', 'varchar(255)')
-            .addColumn('ciphertext', 'text', (col) => col.notNull())
-            .addColumn('wrapped_dek', 'text', (col) => col.notNull())
-            .addColumn('key_version', 'integer', (col) => col.notNull())
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await sql `CREATE UNIQUE INDEX IF NOT EXISTS credentials_name_user_id_unique ON credentials (name, COALESCE(user_id, ''))`.execute(this.db);
-        if (this.audit) {
-            await this.db.schema
-                .createTable('credentials_audit')
-                .ifNotExists()
-                .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-                .addColumn('credential_name', 'varchar(255)', (col) => col.notNull())
-                .addColumn('user_id', 'varchar(255)')
-                .addColumn('action', 'varchar(20)', (col) => col.notNull())
-                .addColumn('performed_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-                .execute();
-        }
+        await ensurePikkuSchema(this.db, credentialSchema);
         this.initialized = true;
     }
     async logAudit(name, userId, action) {

package/dist/src/kysely-deployment-service.d.ts

@@ -16,6 +16,5 @@ export declare class KyselyDeploymentService implements DeploymentService {
     start(config: DeploymentConfig): Promise<void>;
     stop(): Promise<void>;
     invoke(funcName: string, data: unknown, session?: unknown, traceId?: string): Promise<unknown>;
-    private createIndexSafe;
     private sendHeartbeat;
 }

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

@@ -1,6 +1,7 @@
 import { buildRemoteHeaders } from '@pikku/core/remote';
 import { getAllFunctionNames } from '@pikku/core/function';
-import { sql } from 'kysely';
+import { ensurePikkuSchema } from './schema/index.js';
+import { deploymentSchema } from './schema/deployment.schema.js';
 export class KyselyDeploymentService {
     db;
     jwt;
@@ -18,40 +19,9 @@ export class KyselyDeploymentService {
         this.heartbeatTtl = config.heartbeatTtl ?? 30000;
     }
     async init() {
-        if (this.initialized) {
+        if (this.initialized)
             return;
-        }
-        await this.db.schema
-            .createTable('pikku_deployments')
-            .ifNotExists()
-            .addColumn('deployment_id', 'text', (col) => col.primaryKey())
-            .addColumn('endpoint', 'text', (col) => col.notNull())
-            .addColumn('last_heartbeat', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await this.db.schema
-            .createTable('pikku_deployment_functions')
-            .ifNotExists()
-            .addColumn('deployment_id', 'text', (col) => col
-            .notNull()
-            .references('pikku_deployments.deployment_id')
-            .onDelete('cascade'))
-            .addColumn('function_name', 'text', (col) => col.notNull())
-            .addPrimaryKeyConstraint('pikku_deployment_functions_pk', [
-            'deployment_id',
-            'function_name',
-        ])
-            .execute();
-        await this.createIndexSafe(this.db.schema
-            .createIndex('idx_pikku_deployments_heartbeat')
-            .ifNotExists()
-            .on('pikku_deployments')
-            .column('last_heartbeat'));
-        await this.createIndexSafe(this.db.schema
-            .createIndex('idx_pikku_deployment_functions_name')
-            .ifNotExists()
-            .on('pikku_deployment_functions')
-            .column('function_name'));
+        await ensurePikkuSchema(this.db, deploymentSchema);
         this.initialized = true;
     }
     async start(config) {
@@ -129,20 +99,6 @@ export class KyselyDeploymentService {
         }
         return response.json();
     }
-    async createIndexSafe(builder) {
-        try {
-            await builder.execute();
-        }
-        catch (e) {
-            if (e?.code === 'ER_DUP_KEYNAME' || e?.errno === 1061)
-                return;
-            if (e?.code === '42P07')
-                return;
-            if (e?.message?.includes('already exists'))
-                return;
-            throw e;
-        }
-    }
     async sendHeartbeat() {
         if (!this.deploymentConfig)
             return;

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

@@ -1,4 +1,5 @@
-import { sql } from 'kysely';
+import { ensurePikkuSchema } from './schema/index.js';
+import { scopeSchema } from './schema/scope.schema.js';
 /**
  * Resolves and administers user scopes against four self-created tables.
  *
@@ -18,60 +19,9 @@ export class KyselyScopeService {
         this.db = db;
     }
     async init() {
-        if (this.initialized) {
+        if (this.initialized)
             return;
-        }
-        await this.db.schema
-            .createTable('pikku_scopes')
-            .ifNotExists()
-            .addColumn('name', 'text', (col) => col.primaryKey())
-            .addColumn('description', 'text')
-            .addColumn('declared', 'boolean', (col) => col.defaultTo(true).notNull())
-            .execute();
-        await this.db.schema
-            .createTable('pikku_roles')
-            .ifNotExists()
-            .addColumn('name', 'text', (col) => col.primaryKey())
-            .addColumn('description', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await this.db.schema
-            .createTable('pikku_role_scopes')
-            .ifNotExists()
-            .addColumn('role', 'text', (col) => col.notNull().references('pikku_roles.name').onDelete('cascade'))
-            .addColumn('scope', 'text', (col) => col.notNull().references('pikku_scopes.name').onDelete('cascade'))
-            .addPrimaryKeyConstraint('pikku_role_scopes_pk', ['role', 'scope'])
-            .execute();
-        await this.db.schema
-            .createTable('pikku_user_role')
-            .ifNotExists()
-            .addColumn('user_id', 'text', (col) => col.notNull().references('user.id').onDelete('cascade'))
-            .addColumn('role', 'text', (col) => col.notNull().references('pikku_roles.name').onDelete('cascade'))
-            .addColumn('granted_by', 'text')
-            .addColumn('granted_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addPrimaryKeyConstraint('pikku_user_role_pk', ['user_id', 'role'])
-            .execute();
-        await this.db.schema
-            .createTable('pikku_user_scope')
-            .ifNotExists()
-            .addColumn('user_id', 'text', (col) => col.notNull().references('user.id').onDelete('cascade'))
-            .addColumn('scope', 'text', (col) => col.notNull().references('pikku_scopes.name').onDelete('cascade'))
-            .addColumn('granted_by', 'text')
-            .addColumn('granted_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addPrimaryKeyConstraint('pikku_user_scope_pk', ['user_id', 'scope'])
-            .execute();
-        await this.db.schema
-            .createIndex('pikku_role_scopes_scope_idx')
-            .ifNotExists()
-            .on('pikku_role_scopes')
-            .column('scope')
-            .execute();
-        await this.db.schema
-            .createIndex('pikku_user_role_role_idx')
-            .ifNotExists()
-            .on('pikku_user_role')
-            .column('role')
-            .execute();
+        await ensurePikkuSchema(this.db, scopeSchema);
         this.initialized = true;
     }
     /**

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

@@ -1,5 +1,6 @@
-import { sql } from 'kysely';
 import { envelopeEncrypt, envelopeDecrypt, envelopeRewrap, } from '@pikku/core/crypto-utils';
+import { ensurePikkuSchema } from './schema/index.js';
+import { secretSchema } from './schema/secret.schema.js';
 export class KyselySecretService {
     db;
     initialized = false;
@@ -19,26 +20,7 @@ export class KyselySecretService {
     async init() {
         if (this.initialized)
             return;
-        await this.db.schema
-            .createTable('secrets')
-            .ifNotExists()
-            .addColumn('key', 'varchar(255)', (col) => col.primaryKey())
-            .addColumn('ciphertext', 'text', (col) => col.notNull())
-            .addColumn('wrapped_dek', 'text', (col) => col.notNull())
-            .addColumn('key_version', 'integer', (col) => col.notNull())
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        if (this.audit) {
-            await this.db.schema
-                .createTable('secrets_audit')
-                .ifNotExists()
-                .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-                .addColumn('secret_key', 'varchar(255)', (col) => col.notNull())
-                .addColumn('action', 'varchar(20)', (col) => col.notNull())
-                .addColumn('performed_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-                .execute();
-        }
+        await ensurePikkuSchema(this.db, secretSchema);
         this.initialized = true;
     }
     async logAudit(secretKey, action) {

package/dist/src/kysely-session-store.js

@@ -1,5 +1,6 @@
-import { sql } from 'kysely';
 import { parseJson } from './kysely-json.js';
+import { ensurePikkuSchema } from './schema/index.js';
+import { sessionSchema } from './schema/session.schema.js';
 export class KyselySessionStore {
     db;
     initialized = false;
@@ -7,17 +8,9 @@ export class KyselySessionStore {
         this.db = db;
     }
     async init() {
-        if (this.initialized) {
+        if (this.initialized)
             return;
-        }
-        await this.db.schema
-            .createTable('pikku_user_sessions')
-            .ifNotExists()
-            .addColumn('pikku_user_id', 'text', (col) => col.primaryKey())
-            .addColumn('session', 'text', (col) => col.notNull())
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
+        await ensurePikkuSchema(this.db, sessionSchema);
         this.initialized = true;
     }
     async get(pikkuUserId) {

package/dist/src/kysely-tables.d.ts

@@ -112,6 +112,8 @@ export interface AIRunTable {
     errorMessage: string | null;
     suspendReason: 'approval' | 'credential' | 'rpc-missing' | null;
     missingRpcs: string | null;
+    /** JSON-serialized approvals the run is suspended on. */
+    pendingApprovals: string | null;
     usageInputTokens: Generated<number>;
     usageOutputTokens: Generated<number>;
     usageModel: Generated<string>;

package/dist/src/kysely-webhook-service.d.ts

@@ -23,5 +23,4 @@ export declare class KyselyWebhookService extends QueueWebhookService {
     }): Promise<WebhookDeliveryRecord[]>;
     /** A single delivery with its full attempt history, or null if unknown. */
     getDelivery(deliveryId: string): Promise<WebhookDeliveryWithAttempts | null>;
-    private createIndexSafe;
 }

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

@@ -1,5 +1,6 @@
 import { PIKKU_OUTGOING_WEBHOOK_QUEUE_NAME, QueueWebhookService, } from '@pikku/core/services';
-import { sql } from 'kysely';
+import { ensurePikkuSchema } from './schema/index.js';
+import { webhookSchema } from './schema/webhook.schema.js';
 /**
  * Durable {@link QueueWebhookService}: still delivers through the
  * `pikku-outgoing-webhooks` queue, but records a `webhook_delivery` row per
@@ -15,43 +16,9 @@ export class KyselyWebhookService extends QueueWebhookService {
         this.db = db;
     }
     async init() {
-        if (this.initialized) {
+        if (this.initialized)
             return;
-        }
-        await this.db.schema
-            .createTable('webhook_delivery')
-            .ifNotExists()
-            .addColumn('delivery_id', 'text', (col) => col.primaryKey())
-            .addColumn('organization_id', 'text')
-            .addColumn('url', 'text', (col) => col.notNull())
-            .addColumn('event', 'text')
-            .addColumn('status', 'text', (col) => col.defaultTo('pending').notNull())
-            .addColumn('attempts', 'integer', (col) => col.defaultTo(0).notNull())
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('delivered_at', 'timestamp')
-            .execute();
-        await this.db.schema
-            .createTable('webhook_delivery_attempt')
-            .ifNotExists()
-            .addColumn('attempt_id', 'text', (col) => col.primaryKey())
-            .addColumn('delivery_id', 'text', (col) => col.notNull().references('webhook_delivery.delivery_id').onDelete('cascade'))
-            .addColumn('attempt_number', 'integer', (col) => col.notNull())
-            .addColumn('status_code', 'integer')
-            .addColumn('response_body', 'text')
-            .addColumn('error', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await this.createIndexSafe(this.db.schema
-            .createIndex('idx_webhook_delivery_org')
-            .ifNotExists()
-            .on('webhook_delivery')
-            .column('organization_id'));
-        await this.createIndexSafe(this.db.schema
-            .createIndex('idx_webhook_delivery_attempt_delivery')
-            .ifNotExists()
-            .on('webhook_delivery_attempt')
-            .column('delivery_id'));
+        await ensurePikkuSchema(this.db, webhookSchema);
         this.initialized = true;
     }
     async send(input) {
@@ -133,18 +100,4 @@ export class KyselyWebhookService extends QueueWebhookService {
             .execute();
         return { delivery, attempts };
     }
-    async createIndexSafe(builder) {
-        try {
-            await builder.execute();
-        }
-        catch (e) {
-            if (e?.code === 'ER_DUP_KEYNAME' || e?.errno === 1061)
-                return;
-            if (e?.code === '42P07')
-                return;
-            if (e?.message?.includes('already exists'))
-                return;
-            throw e;
-        }
-    }
 }

package/dist/src/kysely-workflow-mirror.d.ts

@@ -19,9 +19,13 @@ export declare class KyselyWorkflowMirror implements WorkflowRunMirror {
     private initialized;
     constructor(db: Kysely<KyselyPikkuDB>);
     /**
-     * Create the underlying tables if they don't exist. Safe to call from
-     * either the mirror or `KyselyWorkflowService.init()` — schema is the
-     * same and uses `ifNotExists`.
+     * Create the underlying tables if none of them exist yet.
+     *
+     * Safe to call from either the mirror or `KyselyWorkflowService.init()` —
+     * both apply the same `workflowSchema`, and `ensurePikkuSchema` is a no-op
+     * once the tables are there. A database holding only *part* of the schema
+     * throws rather than filling in the rest: something else owns those tables,
+     * and boot is not where that gets reconciled.
      */
     init(): Promise<void>;
     createRun(runId: string, workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire, options?: {