@pikku/kysely 0.13.15 → 0.13.18

package/dist/src/schema/{ai.schema.js → agent.schema.js}

@@ -2,18 +2,18 @@ import { sql } from 'kysely';
 /**
  * Threads, messages, tool calls, working memory and agent runs.
  *
- * `aiRun` carries `pendingApprovals` even though the two services that used to
- * create this table disagreed about it: `KyselyAIStorageService` omitted the
- * column while `KyselyAIRunStateService` declared it and read it back through
+ * `agentRun` carries `pendingApprovals` even though the two services that used to
+ * create this table disagreed about it: `KyselyAgentStorageService` omitted the
+ * column while `KyselyAgentRunStateService` declared it and read it back through
  * casts. Whichever service happened to run first decided the shape, and on a
  * database where the storage service won, resolving an approval failed. One
  * declaration ends that — the column is here because live code reads it.
  */
-export const aiSchema = {
-    name: 'ai',
+export const agentSchema = {
+    name: 'agent',
     statements: [
         (db) => db.schema
-            .createTable('aiThreads')
+            .createTable('agentThreads')
             .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
             .addColumn('resourceId', 'varchar(255)', (col) => col.notNull())
             .addColumn('title', 'text')
@@ -21,25 +21,25 @@ export const aiSchema = {
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
         (db) => db.schema
-            .createIndex('idx_ai_threads_resource')
-            .on('aiThreads')
+            .createIndex('idx_agent_threads_resource')
+            .on('agentThreads')
             .column('resourceId'),
         (db) => db.schema
-            .createTable('aiMessage')
+            .createTable('agentMessage')
             .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('aiThreads.id').onDelete('cascade'))
+            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('agentThreads.id').onDelete('cascade'))
             .addColumn('role', 'varchar(50)', (col) => col.notNull())
             .addColumn('content', 'text')
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
         (db) => db.schema
-            .createIndex('idx_ai_message_thread')
-            .on('aiMessage')
+            .createIndex('idx_agent_message_thread')
+            .on('agentMessage')
             .columns(['threadId', 'createdAt']),
         (db) => db.schema
-            .createTable('aiToolCall')
+            .createTable('agentToolCall')
             .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('aiThreads.id').onDelete('cascade'))
-            .addColumn('messageId', 'varchar(36)', (col) => col.notNull().references('aiMessage.id').onDelete('cascade'))
+            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('agentThreads.id').onDelete('cascade'))
+            .addColumn('messageId', 'varchar(36)', (col) => col.notNull().references('agentMessage.id').onDelete('cascade'))
             .addColumn('runId', 'varchar(36)')
             .addColumn('toolName', 'varchar(255)', (col) => col.notNull())
             .addColumn('args', 'text', (col) => col.notNull())
@@ -51,25 +51,25 @@ export const aiSchema = {
             .addColumn('displayArgs', 'text')
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
         (db) => db.schema
-            .createIndex('idx_ai_tool_call_thread')
-            .on('aiToolCall')
+            .createIndex('idx_agent_tool_call_thread')
+            .on('agentToolCall')
             .column('threadId'),
         (db) => db.schema
-            .createIndex('idx_ai_tool_call_message')
-            .on('aiToolCall')
+            .createIndex('idx_agent_tool_call_message')
+            .on('agentToolCall')
             .column('messageId'),
         (db) => db.schema
-            .createTable('aiWorkingMemory')
+            .createTable('agentWorkingMemory')
             .addColumn('id', 'varchar(255)', (col) => col.notNull())
             .addColumn('scope', 'varchar(50)', (col) => col.notNull())
             .addColumn('data', 'text', (col) => col.notNull())
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addPrimaryKeyConstraint('ai_working_memory_pk', ['id', 'scope']),
+            .addPrimaryKeyConstraint('agent_working_memory_pk', ['id', 'scope']),
         (db) => db.schema
-            .createTable('aiRun')
+            .createTable('agentRun')
             .addColumn('runId', 'varchar(36)', (col) => col.primaryKey())
             .addColumn('agentName', 'varchar(255)', (col) => col.notNull())
-            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('aiThreads.id').onDelete('cascade'))
+            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('agentThreads.id').onDelete('cascade'))
             .addColumn('resourceId', 'varchar(255)', (col) => col.notNull())
             .addColumn('status', 'varchar(50)', (col) => col.notNull().defaultTo('running'))
             .addColumn('errorMessage', 'text')
@@ -82,21 +82,21 @@ export const aiSchema = {
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
         (db) => db.schema
-            .createIndex('idx_ai_run_thread')
-            .on('aiRun')
+            .createIndex('idx_agent_run_thread')
+            .on('agentRun')
             .columns(['threadId', 'createdAt']),
         (db) => db.schema
-            .createTable('aiRunScore')
+            .createTable('agentRunScore')
             .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('runId', 'varchar(36)', (col) => col.notNull().references('aiRun.runId').onDelete('cascade'))
+            .addColumn('runId', 'varchar(36)', (col) => col.notNull().references('agentRun.runId').onDelete('cascade'))
             .addColumn('scorerName', 'varchar(255)', (col) => col.notNull())
             .addColumn('score', 'real', (col) => col.notNull())
             .addColumn('reason', 'text')
             .addColumn('metadata', 'text')
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
         (db) => db.schema
-            .createIndex('idx_ai_run_score_run')
-            .on('aiRunScore')
+            .createIndex('idx_agent_run_score_run')
+            .on('agentRunScore')
             .columns(['runId', 'createdAt']),
     ],
 };

package/dist/src/schema/index.js

@@ -1,6 +1,6 @@
 import { CamelCasePlugin } from 'kysely';
 import { schemaContext, } from './pikku-schema.types.js';
-import { aiSchema } from './ai.schema.js';
+import { agentSchema } from './agent.schema.js';
 import { channelSchema } from './channel.schema.js';
 import { credentialSchema } from './credential.schema.js';
 import { deploymentSchema } from './deployment.schema.js';
@@ -31,7 +31,7 @@ export const pikkuSchemas = [
     deploymentSchema,
     webhookSchema,
     workflowSchema,
-    aiSchema,
+    agentSchema,
     scopeSchema,
 ];
 /**
@@ -39,8 +39,8 @@ export const pikkuSchemas = [
  *
  * The plugin is applied here rather than trusted to the caller. Declarations
  * name tables and columns the way the rest of the codebase queries them
- * (`aiThreads.resourceId`), and it is `CamelCasePlugin` that turns those into
- * the physical `ai_threads.resource_id`. Without it the same declaration
+ * (`agentThreads.resourceId`), and it is `CamelCasePlugin` that turns those into
+ * the physical `agent_threads.resource_id`. Without it the same declaration
  * silently creates quoted camelCase tables that nothing can read.
  */
 const bind = (db) => db.withPlugin(new CamelCasePlugin());

package/dist/src/serialize-plugin.d.ts

@@ -69,7 +69,3 @@ export declare class SerializePlugin extends BaseSerializePlugin {
      */
     constructor(options?: SerializePluginOptions);
 }
-/**
- * @deprecated use {@link SerializePlugin} instead
- */
-export declare const SqliteSerializePlugin: typeof SerializePlugin;

package/dist/src/serialize-plugin.js

@@ -171,7 +171,3 @@ export class SerializePlugin extends BaseSerializePlugin {
         super(serializer, deserializer, skipNodeKind);
     }
 }
-/**
- * @deprecated use {@link SerializePlugin} instead
- */
-export const SqliteSerializePlugin = SerializePlugin;

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/create-audited-kysely.ts","../src/index.ts","../src/kysely-ai-agent-run-service.ts","../src/kysely-ai-run-scores.ts","../src/kysely-ai-run-state-service.ts","../src/kysely-ai-storage-service.ts","../src/kysely-audit-service.ts","../src/kysely-channel-store.ts","../src/kysely-credential-service.ts","../src/kysely-deployment-service.ts","../src/kysely-eventhub-store.ts","../src/kysely-json.ts","../src/kysely-scope-service.ts","../src/kysely-secret-service.ts","../src/kysely-session-store.ts","../src/kysely-tables.ts","../src/kysely-virtual-user-run-store.ts","../src/kysely-webhook-service.ts","../src/kysely-workflow-mirror.ts","../src/kysely-workflow-run-service.ts","../src/kysely-workflow-service.ts","../src/serialize-plugin.ts","../src/schema/ai.schema.ts","../src/schema/audit.schema.ts","../src/schema/channel.schema.ts","../src/schema/credential.schema.ts","../src/schema/deployment.schema.ts","../src/schema/index.ts","../src/schema/pikku-schema.types.ts","../src/schema/scope.schema.ts","../src/schema/secret.schema.ts","../src/schema/session.schema.ts","../src/schema/virtual-user.schema.ts","../src/schema/webhook.schema.ts","../src/schema/workflow.schema.ts","../bin/pikku-kysely-pure.ts"],"version":"6.0.3"}
+{"root":["../src/coercion-plugin.ts","../src/create-audited-kysely.ts","../src/index.ts","../src/kysely-agent-run-scores.ts","../src/kysely-agent-run-service.ts","../src/kysely-agent-run-state-service.ts","../src/kysely-agent-storage-service.ts","../src/kysely-audit-service.ts","../src/kysely-channel-store.ts","../src/kysely-credential-service.ts","../src/kysely-deployment-service.ts","../src/kysely-eventhub-store.ts","../src/kysely-json.ts","../src/kysely-scope-service.ts","../src/kysely-secret-service.ts","../src/kysely-session-store.ts","../src/kysely-tables.ts","../src/kysely-virtual-user-run-store.ts","../src/kysely-webhook-service.ts","../src/kysely-workflow-mirror.ts","../src/kysely-workflow-run-service.ts","../src/kysely-workflow-service.ts","../src/serialize-plugin.ts","../src/schema/agent.schema.ts","../src/schema/audit.schema.ts","../src/schema/channel.schema.ts","../src/schema/credential.schema.ts","../src/schema/deployment.schema.ts","../src/schema/index.ts","../src/schema/pikku-schema.types.ts","../src/schema/scope.schema.ts","../src/schema/secret.schema.ts","../src/schema/session.schema.ts","../src/schema/virtual-user.schema.ts","../src/schema/webhook.schema.ts","../src/schema/workflow.schema.ts","../bin/pikku-kysely-pure.ts"],"version":"6.0.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/kysely",
-  "version": "0.13.15",
+  "version": "0.13.18",
   "description": "Kysely-backed Pikku services — workflow state, secrets, sessions, scopes and audit",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -21,20 +21,20 @@
     "prepublishOnly": "yarn build"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.82"
+    "@pikku/core": "^0.12.86"
   },
   "dependencies": {
-    "kysely": "^0.29.0"
+    "kysely": "^0.29.5"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
-    "better-sqlite3": "^12.10.0",
+    "@types/better-sqlite3": "^9.6.0",
+    "better-sqlite3": "^13.0.3",
     "kysely-codegen": "^0.20.0",
     "kysely-postgres-js": "^3.0.0",
-    "postgres": "^3.4.8",
+    "postgres": "^3.4.9",
     "typescript": "^6.0.3"
   },
   "exports": {
     ".": "./dist/src/index.js"
   }
-}
+}

package/src/coercion-plugin.test.ts

@@ -0,0 +1,160 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+import type { QueryResult, UnknownRow } from 'kysely'
+import { createCoercionPlugin, type CoercionMap } from './coercion-plugin.js'
+
+function selectFrom(...tables: string[]) {
+  return {
+    kind: 'SelectQueryNode',
+    from: {
+      kind: 'FromNode',
+      froms: tables.map((table) => ({
+        kind: 'TableNode',
+        table: {
+          kind: 'SchemableIdentifierNode',
+          identifier: { kind: 'IdentifierNode', name: table },
+        },
+      })),
+    },
+  }
+}
+
+const runTransform = async (
+  map: CoercionMap,
+  rows: UnknownRow[],
+  node?: unknown
+): Promise<UnknownRow[]> => {
+  const plugin = createCoercionPlugin({ map })
+  const queryId = {} as { queryId: string }
+  if (node !== undefined) {
+    plugin.transformQuery({ node, queryId } as any)
+  }
+  const result = { rows } as QueryResult<UnknownRow>
+  const out = await plugin.transformResult({ result, queryId } as any)
+  return out.rows as UnknownRow[]
+}
+
+describe('createCoercionPlugin', () => {
+  test('transformQuery passes the node through untouched', () => {
+    const plugin = createCoercionPlugin({ map: {} })
+    const node = selectFrom('users') as any
+    assert.equal(
+      plugin.transformQuery({ node, queryId: { queryId: 'x' } } as any),
+      node
+    )
+  })
+
+  test('coerces date columns from ISO strings to Date', async () => {
+    const [row] = await runTransform({ users: { created_at: 'date' } }, [
+      { created_at: '2026-06-26T00:00:00.000Z' },
+    ])
+    assert.ok(row!.created_at instanceof Date)
+    assert.equal(
+      (row!.created_at as Date).toISOString(),
+      '2026-06-26T00:00:00.000Z'
+    )
+  })
+
+  test('leaves unparseable date strings untouched', async () => {
+    const [row] = await runTransform({ users: { created_at: 'date' } }, [
+      { created_at: 'not-a-date' },
+    ])
+    assert.equal(row!.created_at, 'not-a-date')
+  })
+
+  test('coerces bool columns from 0/1 numbers and bigints', async () => {
+    const rows = await runTransform(
+      { users: { is_active: 'bool', has_pets: 'bool' } },
+      [{ is_active: 1, has_pets: 0n }]
+    )
+    assert.equal(rows[0]!.is_active, true)
+    assert.equal(rows[0]!.has_pets, false)
+  })
+
+  test('parses json columns and tolerates invalid json', async () => {
+    const rows = await runTransform(
+      { users: { meta: 'json', broken: 'json' } },
+      [{ meta: '{"a":1}', broken: '{bad' }]
+    )
+    assert.deepEqual(rows[0]!.meta, { a: 1 })
+    assert.equal(rows[0]!.broken, '{bad')
+  })
+
+  test('passes through null values and unmapped columns', async () => {
+    const rows = await runTransform({ users: { created_at: 'date' } }, [
+      { created_at: null, name: 'leave me' },
+    ])
+    assert.equal(rows[0]!.created_at, null)
+    assert.equal(rows[0]!.name, 'leave me')
+  })
+
+  test('matches both snake_case and camelCase column names', async () => {
+    const rows = await runTransform({ users: { created_at: 'date' } }, [
+      { createdAt: '2026-06-26T00:00:00.000Z' },
+    ])
+    assert.ok(rows[0]!.createdAt instanceof Date)
+  })
+
+  test('leaves columns ambiguous across tables uncoerced', async () => {
+    const rows = await runTransform(
+      { users: { value: 'json' }, events: { value: 'bool' } },
+      [{ value: '{"a":1}' }]
+    )
+    assert.equal(rows[0]!.value, '{"a":1}')
+  })
+
+  test('still coerces columns that agree across tables', async () => {
+    const rows = await runTransform(
+      { users: { active: 'bool' }, events: { active: 'bool' } },
+      [{ active: 1 }]
+    )
+    assert.equal(rows[0]!.active, true)
+  })
+
+  test('uses table-qualified coercions when names collide', async () => {
+    const map: CoercionMap = {
+      users: { settings: 'json' },
+      posts: { settings: 'bool' },
+    }
+    const fromUsers = await runTransform(
+      map,
+      [{ settings: '{"theme":"dark"}' }],
+      selectFrom('users')
+    )
+    assert.deepEqual(fromUsers[0]!.settings, { theme: 'dark' })
+
+    const fromPosts = await runTransform(
+      map,
+      [{ settings: 1 }],
+      selectFrom('posts')
+    )
+    assert.equal(fromPosts[0]!.settings, true)
+  })
+
+  test('table-qualified lookup matches camelCase result columns too', async () => {
+    const rows = await runTransform(
+      { users: { created_at: 'date' }, jobs: { created_at: 'json' } },
+      [{ createdAt: '2026-06-26T00:00:00.000Z' }],
+      selectFrom('users')
+    )
+    assert.ok(rows[0]!.createdAt instanceof Date)
+  })
+
+  test('a join whose tables disagree leaves the column uncoerced', async () => {
+    const rows = await runTransform(
+      { users: { value: 'json' }, events: { value: 'bool' } },
+      [{ value: '{"a":1}' }],
+      selectFrom('users', 'events')
+    )
+    assert.equal(rows[0]!.value, '{"a":1}')
+  })
+
+  test('falls back to flat keys when the query names no known table', async () => {
+    const rows = await runTransform(
+      { users: { created_at: 'date' } },
+      [{ createdAt: '2026-01-02T03:04:05.000Z' }],
+      selectFrom('unrelated')
+    )
+    assert.ok(rows[0]!.createdAt instanceof Date)
+  })
+})

package/src/coercion-plugin.ts

@@ -0,0 +1,187 @@
+import type { KyselyPlugin, RootOperationNode, UnknownRow } from 'kysely'
+
+/**
+ * The kinds a column can be coerced *to* at runtime. This is the value type of
+ * the generated `CoercionMap`, so it is a public artifact contract — a kind may
+ * only appear here if `fromDb` below actually does something with it.
+ *
+ * `uuid` is deliberately absent: it is an annotation kind (it selects the `Uuid`
+ * TypeScript type in the generated schema) but not a coercion kind, and the
+ * codegen filters it out of `coercion.gen.ts` for exactly that reason — a UUID
+ * is a string in both Postgres and SQLite.
+ */
+export type ColumnKind = 'date' | 'bool' | 'json'
+
+/**
+ * Per-table column kind map. Keys are the table names queries are written
+ * against; inner keys are snake_case column names.
+ * Generated into `outDir/db/coercion.gen.ts` by `pikku db migrate` from the
+ * explicit `kind` entries in `db/annotations.ts`.
+ */
+export type CoercionMap = Record<string, Record<string, ColumnKind>>
+
+export interface CreateCoercionPluginOptions {
+  map: CoercionMap
+}
+
+function fromDb(value: unknown, kind: ColumnKind): unknown {
+  if (value == null) return value
+  switch (kind) {
+    case 'date':
+      if (typeof value === 'string') {
+        const d = new Date(value)
+        return Number.isNaN(d.getTime()) ? value : d
+      }
+      return value
+    case 'bool':
+      if (typeof value === 'number') return value !== 0
+      if (typeof value === 'bigint') return value !== 0n
+      return value
+    case 'json':
+      if (typeof value !== 'string') return value
+      try {
+        return JSON.parse(value)
+      } catch {
+        return value
+      }
+  }
+}
+
+function snakeToCamel(name: string): string {
+  return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase())
+}
+
+interface ResolvedMaps {
+  /** `table.column` → kind, for the exact per-query resolution. */
+  qualified: Record<string, ColumnKind>
+  /** `column` → kind, the fallback for when the query's tables say nothing. */
+  flat: Record<string, ColumnKind>
+}
+
+/**
+ * Flatten the per-table map into a table-qualified lookup plus a bare
+ * column-name fallback. Both are indexed by BOTH snake_case and camelCase so
+ * they work regardless of CamelCasePlugin ordering in the plugin array.
+ *
+ * When two tables disagree on the kind for the same column name, the bare name
+ * is ambiguous (a joined/aliased query could carry either) and is dropped from
+ * the flat map rather than letting whichever table was processed last win. The
+ * qualified map still resolves it whenever the query names its tables.
+ */
+function buildMaps(map: CoercionMap): ResolvedMaps {
+  const qualified: Record<string, ColumnKind> = {}
+  const flat: Record<string, ColumnKind> = {}
+  const ambiguous = new Set<string>()
+  const assignFlat = (key: string, kind: ColumnKind) => {
+    const existing = flat[key]
+    if (existing !== undefined && existing !== kind) {
+      ambiguous.add(key)
+      return
+    }
+    flat[key] = kind
+  }
+  for (const [table, cols] of Object.entries(map)) {
+    for (const [col, kind] of Object.entries(cols)) {
+      const camel = snakeToCamel(col)
+      qualified[`${table}.${col}`] = kind
+      qualified[`${table}.${camel}`] = kind
+      assignFlat(col, kind)
+      assignFlat(camel, kind)
+    }
+  }
+  for (const key of ambiguous) delete flat[key]
+  return { qualified, flat }
+}
+
+/**
+ * Collect every table named anywhere in the query's operation node, so a result
+ * column can be resolved against the tables the query actually touched instead
+ * of against every table in the schema.
+ */
+function collectQueryTables(node: unknown, out: Set<string>): void {
+  if (!node || typeof node !== 'object') return
+
+  const op = node as {
+    kind?: string
+    table?: { identifier?: { name?: string } }
+  }
+  if (op.kind === 'TableNode') {
+    const tableName = op.table?.identifier?.name
+    if (typeof tableName === 'string' && tableName.length > 0)
+      out.add(tableName)
+  }
+
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const item of value) collectQueryTables(item, out)
+    } else {
+      collectQueryTables(value, out)
+    }
+  }
+}
+
+/**
+ * Resolve a result column's kind against the query's tables, falling back to
+ * the bare column name. Tables that disagree with each other are as ambiguous
+ * as two schema tables are, so they fall back too.
+ */
+function lookupKind(
+  maps: ResolvedMaps,
+  tables: readonly string[],
+  col: string
+): ColumnKind | undefined {
+  let matchedKind: ColumnKind | undefined
+  for (const table of tables) {
+    const kind = maps.qualified[`${table}.${col}`]
+    if (!kind) continue
+    if (matchedKind && matchedKind !== kind) return maps.flat[col]
+    matchedKind = kind
+  }
+  return matchedKind ?? maps.flat[col]
+}
+
+/**
+ * Convert values stored in a dialect's on-disk representation back into the
+ * logical types app code expects (Date / boolean / parsed JSON).
+ *
+ * SQLite is what makes this necessary — it stores dates as TEXT, booleans as
+ * INTEGER and JSON as TEXT — but the plugin is dialect-neutral: on Postgres the
+ * driver already returns Date/boolean/object, and every branch of `fromDb`
+ * passes a non-string, non-number value straight through. That is why it lives
+ * in `@pikku/kysely` next to `SerializePlugin` rather than in a SQLite package:
+ * the CLI installs it on its local Postgres database too.
+ *
+ * Write-side coercion (Date → ISO string, boolean → 0/1, object → JSON) is
+ * handled in the SQLite database adapters (always-on), so this plugin is
+ * read-only.
+ *
+ * Place AFTER CamelCasePlugin in the plugin array (or it handles both
+ * orderings via the dual-keyed maps).
+ */
+export function createCoercionPlugin(
+  options: CreateCoercionPluginOptions
+): KyselyPlugin {
+  const maps = buildMaps(options.map)
+  const queryTables = new WeakMap<object, readonly string[]>()
+  return {
+    transformQuery(args) {
+      const tables = new Set<string>()
+      collectQueryTables(args.node as RootOperationNode, tables)
+      queryTables.set(args.queryId, [...tables])
+      return args.node
+    },
+    async transformResult(args) {
+      const tables = queryTables.get(args.queryId) ?? []
+      const out: UnknownRow[] = []
+      for (const row of args.result.rows as UnknownRow[]) {
+        const next: UnknownRow = { ...row }
+        for (const [col, val] of Object.entries(row)) {
+          const kind = lookupKind(maps, tables, col)
+          if (kind) next[col] = fromDb(val, kind)
+        }
+        out.push(next)
+      }
+      return { ...args.result, rows: out }
+    },
+  }
+}

package/src/create-audited-kysely.test.ts

@@ -7,7 +7,7 @@ import {
   NoopAuditService,
   type AuditEvent,
   type AuditService,
-} from '../../../core/src/index.js'
+} from '@pikku/core/services'
 
 import { createAuditedKysely } from './create-audited-kysely.js'
 

package/src/create-audited-kysely.ts

@@ -1,4 +1,4 @@
-import type { AuditLog } from '@pikku/core'
+import type { AuditLog } from '@pikku/core/services'
 import type {
   Kysely,
   KyselyPlugin,

package/src/index.ts

@@ -4,9 +4,9 @@ export { KyselyWorkflowService } from './kysely-workflow-service.js'
 export { KyselyWorkflowRunService } from './kysely-workflow-run-service.js'
 export { KyselyWorkflowMirror } from './kysely-workflow-mirror.js'
 export { KyselyDeploymentService } from './kysely-deployment-service.js'
-export { KyselyAIStorageService } from './kysely-ai-storage-service.js'
-export { KyselyAgentRunService } from './kysely-ai-agent-run-service.js'
-export { KyselyAIRunStateService } from './kysely-ai-run-state-service.js'
+export { KyselyAgentStorageService } from './kysely-agent-storage-service.js'
+export { KyselyAgentRunService } from './kysely-agent-run-service.js'
+export { KyselyAgentRunStateService } from './kysely-agent-run-state-service.js'
 export { KyselySecretService } from './kysely-secret-service.js'
 export { KyselyCredentialService } from './kysely-credential-service.js'
 export { KyselySessionStore } from './kysely-session-store.js'
@@ -21,11 +21,16 @@ export { KyselyVirtualUserRunStore } from './kysely-virtual-user-run-store.js'
 
 export {
   SerializePlugin,
-  SqliteSerializePlugin,
   BaseSerializePlugin,
   type Serializer,
   type Deserializer,
 } from './serialize-plugin.js'
+export {
+  createCoercionPlugin,
+  type ColumnKind,
+  type CoercionMap,
+  type CreateCoercionPluginOptions,
+} from './coercion-plugin.js'
 export {
   auditSchema,
   pikkuSchemas,
@@ -42,7 +47,7 @@ export {
 
 export type { KyselyPikkuDB } from './kysely-tables.js'
 export type { WorkflowRunService } from '@pikku/core/workflow'
-export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent'
+export type { AgentRunService, AgentRunRow } from '@pikku/core/agent'
 export type {
   VirtualUserRunStore,
   VirtualUserRunRecord,

package/src/{kysely-ai-run-scores.ts → kysely-agent-run-scores.ts}

@@ -1,11 +1,11 @@
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
+import type { AgentRunScore } from '@pikku/core/agent-scorer'
 import type { SaveScoreInput } from '@pikku/core/services'
-import type { AIRunScore } from '@pikku/core/ai-scorer'
 import { parseJson } from './kysely-json.js'
 
 /**
- * Shared by the two Kysely services that implement `AIRunStateService` — they
+ * Shared by the two Kysely services that implement `AgentRunStateService` — they
  * differ in how they store approvals, not in how they store grades.
  */
 export const saveRunScore = async (
@@ -13,7 +13,7 @@ export const saveRunScore = async (
   score: SaveScoreInput
 ): Promise<void> => {
   await db
-    .insertInto('aiRunScore')
+    .insertInto('agentRunScore')
     .values({
       id: crypto.randomUUID(),
       runId: score.runId,
@@ -28,9 +28,9 @@ export const saveRunScore = async (
 export const getRunScores = async (
   db: Kysely<KyselyPikkuDB>,
   runId: string
-): Promise<AIRunScore[]> => {
+): Promise<AgentRunScore[]> => {
   const rows = await db
-    .selectFrom('aiRunScore')
+    .selectFrom('agentRunScore')
     .selectAll()
     .where('runId', '=', runId)
     .orderBy('createdAt', 'asc')