kimaki 0.26.0 → 0.28.0

package/src/queue-question-select-drain.e2e.test.ts

@@ -1,7 +1,4 @@
-// E2e test: queued message must drain after the user answers a pending question
-// via the Discord dropdown select menu. Reproduces a bug where answering via
-// select (not text) leaves queued messages stuck because the session continues
-// processing after the answer and may enter another blocking state.
+// E2e test for ordered queue drain after a pending question is answered via select.
 
 import { describe, test, expect } from 'vitest'
 import {
@@ -53,10 +50,7 @@ async function expectNoBotMessageContaining({
   while (Date.now() - start < timeout) {
     const messages = await discord.thread(threadId).getMessages()
     const match = messages.find((message) => {
-      return (
-        message.author.id === discord.botUserId
-        && message.content.includes(text)
-      )
+      return message.author.id === discord.botUserId && message.content.includes(text)
     })
     if (match) {
       throw new Error(
@@ -78,132 +72,19 @@ describe('queue drain after question select answer', () => {
   })
 
   test(
-    'queued message drains after answering question via dropdown select',
-    async () => {
-      // 1. Send a message that triggers the question tool
-      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-        content: 'QUESTION_SELECT_QUEUE_MARKER',
-      })
-
-      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
-        timeout: 8_000,
-        predicate: (t) => {
-          return t.name === 'QUESTION_SELECT_QUEUE_MARKER'
-        },
-      })
-
-      const th = ctx.discord.thread(thread.id)
-
-      // 2. Wait for the question dropdown message to appear in Discord.
-      // Uses visible message wait instead of internal Map polling which
-      // is too timing-sensitive on CI.
-      const questionMessages = await waitForBotMessageContaining({
-        discord: ctx.discord,
-        threadId: thread.id,
-        text: 'How to proceed?',
-        timeout: 12_000,
-      })
-
-      // Get the pending question context hash from the internal map.
-      // By this point the question message is visible so the context must exist.
-      const pending = await waitForPendingQuestion({
-        threadId: thread.id,
-        timeoutMs: 8_000,
-      })
-      const questionMsg = questionMessages.find((m) => {
-        return m.content.includes('How to proceed?')
-      })!
-      expect(questionMsg).toBeTruthy()
-
-      // 3. Queue a message while question is pending
-      const { id: queueInteractionId } = await th.user(TEST_USER_ID)
-        .runSlashCommand({
-          name: 'queue',
-          options: [{ name: 'message', type: 3, value: 'Reply with exactly: post-question-drain' }],
-        })
-
-      const queueAck = await th.waitForInteractionAck({
-        interactionId: queueInteractionId,
-        timeout: 8_000,
-      })
-      if (!queueAck.messageId) {
-        throw new Error('Expected /queue response message id')
-      }
-
-      // 4. The first queued item should be handed off immediately even while
-      //    the question is still pending, so the visible dispatch indicator
-      //    appears before the user answers the dropdown.
-      await waitForBotMessageContaining({
-        discord: ctx.discord,
-        threadId: thread.id,
-        text: '» **question-select-tester:** Reply with exactly: post-question-drain',
-        timeout: 8_000,
-      })
-
-      // 5. Answer the question via dropdown select (pick first option "Alpha")
-      const interaction = await th.user(TEST_USER_ID).selectMenu({
-        messageId: questionMsg.id,
-        customId: `ask_question:${pending.contextHash}:0`,
-        values: ['0'],
-      })
-
-      await th.waitForInteractionAck({
-        interactionId: interaction.id,
-        timeout: 8_000,
-      })
-
-      // 6. Wait for footer from the drained queued message
-      await waitForFooterMessage({
-        discord: ctx.discord,
-        threadId: thread.id,
-        timeout: 8_000,
-        afterMessageIncludes: '» **question-select-tester:**',
-        afterAuthorId: ctx.discord.botUserId,
-      })
-
-      const timeline = await th.text({ showInteractions: true })
-      expect(timeline).toMatchInlineSnapshot(`
-        "--- from: user (question-select-tester)
-        QUESTION_SELECT_QUEUE_MARKER
-        --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        **Select action**
-        How to proceed?
-        ✓ _Alpha_
-        [user interaction]
-        » **question-select-tester:** Reply with exactly: post-question-drain
-        Queued message (position 1)
-        [user selects dropdown: 0]
-        » **question-select-tester:** Alpha
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
-      expect(timeline).toContain('QUESTION_SELECT_QUEUE_MARKER')
-      expect(timeline).toContain('How to proceed?')
-      expect(timeline).toContain('[user selects dropdown: 0]')
-      expect(timeline).toContain('» **question-select-tester:** Reply with exactly: post-question-drain')
-      expect(timeline).toContain('⬥ ok')
-      expect(timeline).toContain('*project ⋅ main ⋅')
-    },
-    20_000,
-  )
-
-  test(
-    'only the first queued message is handed off after dropdown answer',
+    'queued messages drain in order after answering via dropdown select',
     async () => {
-      const marker = 'QUESTION_SELECT_QUEUE_MARKER second-test'
-
+      const marker = 'QUESTION_SELECT_QUEUE_MARKER'
       await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
         content: marker,
       })
 
       const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
         timeout: 8_000,
-        predicate: (t) => {
-          return t.name === marker
+        predicate: (candidate) => {
+          return candidate.name === marker
         },
       })
-
       const th = ctx.discord.thread(thread.id)
 
       const questionMessages = await waitForBotMessageContaining({
@@ -212,21 +93,18 @@ describe('queue drain after question select answer', () => {
         text: 'How to proceed?',
         timeout: 12_000,
       })
-
       const pending = await waitForPendingQuestion({
         threadId: thread.id,
         timeoutMs: 8_000,
       })
-
-      const questionMsg = questionMessages.find((message) => {
+      const questionMessage = questionMessages.find((message) => {
         return message.content.includes('How to proceed?')
       })
-      expect(questionMsg).toBeTruthy()
-      if (!questionMsg) {
+      if (!questionMessage) {
         throw new Error('Expected question message')
       }
 
-      const firstQueuedPrompt = 'SLOW_ABORT_MARKER run long response'
+      const firstQueuedPrompt = 'QUESTION_SELECT_DRAIN_FIRST_MARKER'
       const secondQueuedPrompt = 'Reply with exactly: post-question-second'
 
       const { id: firstQueueInteractionId } = await th.user(TEST_USER_ID)
@@ -234,48 +112,45 @@ describe('queue drain after question select answer', () => {
           name: 'queue',
           options: [{ name: 'message', type: 3, value: firstQueuedPrompt }],
         })
-
       await th.waitForInteractionAck({
         interactionId: firstQueueInteractionId,
         timeout: 8_000,
       })
 
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: `» **question-select-tester:** ${firstQueuedPrompt}`,
+        timeout: 8_000,
+      })
+
       const { id: secondQueueInteractionId } = await th.user(TEST_USER_ID)
         .runSlashCommand({
           name: 'queue',
           options: [{ name: 'message', type: 3, value: secondQueuedPrompt }],
         })
-
       await th.waitForInteractionAck({
         interactionId: secondQueueInteractionId,
         timeout: 8_000,
       })
 
+      await expectNoBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: `» **question-select-tester:** ${secondQueuedPrompt}`,
+        timeout: 200,
+      })
+
       const interaction = await th.user(TEST_USER_ID).selectMenu({
-        messageId: questionMsg.id,
+        messageId: questionMessage.id,
         customId: `ask_question:${pending.contextHash}:0`,
         values: ['0'],
       })
-
       await th.waitForInteractionAck({
         interactionId: interaction.id,
         timeout: 8_000,
       })
 
-      await waitForBotMessageContaining({
-        discord: ctx.discord,
-        threadId: thread.id,
-        text: `» **question-select-tester:** ${firstQueuedPrompt}`,
-        timeout: 8_000,
-      })
-
-      await expectNoBotMessageContaining({
-        discord: ctx.discord,
-        threadId: thread.id,
-        text: `» **question-select-tester:** ${secondQueuedPrompt}`,
-        timeout: 200,
-      })
-
       await waitForFooterMessage({
         discord: ctx.discord,
         threadId: thread.id,
@@ -283,14 +158,12 @@ describe('queue drain after question select answer', () => {
         afterMessageIncludes: `» **question-select-tester:** ${firstQueuedPrompt}`,
         afterAuthorId: ctx.discord.botUserId,
       })
-
       await waitForBotMessageContaining({
         discord: ctx.discord,
         threadId: thread.id,
         text: `» **question-select-tester:** ${secondQueuedPrompt}`,
         timeout: 8_000,
       })
-
       await waitForFooterMessage({
         discord: ctx.discord,
         threadId: thread.id,
@@ -302,30 +175,32 @@ describe('queue drain after question select answer', () => {
       const timeline = await th.text({ showInteractions: true })
       expect(timeline).toMatchInlineSnapshot(`
         "--- from: user (question-select-tester)
-        QUESTION_SELECT_QUEUE_MARKER second-test
+        QUESTION_SELECT_QUEUE_MARKER
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
         **Select action**
         How to proceed?
         ✓ _Alpha_
         [user interaction]
-        » **question-select-tester:** SLOW_ABORT_MARKER run long response
+        » **question-select-tester:** QUESTION_SELECT_DRAIN_FIRST_MARKER
         Queued message (position 1)
         [user interaction]
         Queued message (position 1)
         [user selects dropdown: 0]
         » **question-select-tester:** Alpha
-        ⬥ slow-response-started
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > question-drain-first
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2*
         » **question-select-tester:** Reply with exactly: post-question-second
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `)
+      expect(timeline).toContain('How to proceed?')
+      expect(timeline).toContain('[user selects dropdown: 0]')
       expect(timeline).toContain(`» **question-select-tester:** ${firstQueuedPrompt}`)
-      expect(timeline).toContain('⬥ slow-response-started')
+      expect(timeline).toContain('question-drain-first')
       expect(timeline).toContain(`» **question-select-tester:** ${secondQueuedPrompt}`)
-      expect(timeline).toContain('⬥ ok')
+      expect(timeline).toContain('ok')
     },
-    20_000,
+    15_000,
   )
 })

package/src/runtime-lifecycle.e2e.test.ts

@@ -39,6 +39,7 @@ import {
   chooseLockPort,
   cleanupTestSessions,
   initTestGitRepo,
+  isFooterMessage,
   waitForBotMessageContaining,
   waitForBotReplyAfterUserMessage,
 } from './test-utils.js'
@@ -264,11 +265,11 @@ describe('runtime lifecycle', () => {
   }, 5_000)
 
   test(
-    'three sequential completions reuse same runtime and listener',
+    'two sequential completions reuse same runtime and listener',
     async () => {
-      // Sends A, waits for full completion (footer), sends B, waits for
-      // footer, sends C, waits for footer. Proves the listener stays alive
-      // across full run cycles without any interrupt/queue involvement.
+      // Sends A, waits for full completion (footer), then sends B and waits
+      // for its footer. Proves the listener stays alive across full run cycles
+      // without any interrupt/queue involvement.
       // This is the "calm" path — no abort, no queue, just sequential use.
 
       // 1. Send first message → thread created, session established
@@ -323,51 +324,20 @@ describe('runtime lifecycle', () => {
 
       // Same runtime instance — listener was not recreated
       const runtimeAfterB = getRuntime(thread.id)
-      expect(runtimeAfterB).toBe(runtimeAfterA)
-
-      // 3. Send C after B fully completed
-      await th.user(TEST_USER_ID).sendMessage({
-        content: 'Reply with exactly: seq-gamma',
-      })
-
-      await waitForBotReplyAfterUserMessage({
-        discord,
-        threadId: thread.id,
-        userId: TEST_USER_ID,
-        userMessageIncludes: 'seq-gamma',
-        timeout: 4_000,
-      })
-
-      await waitForBotMessageContaining({
-        discord,
-        threadId: thread.id,
-        userId: TEST_USER_ID,
-        text: '*project',
-        afterUserMessageIncludes: 'seq-gamma',
-        timeout: 4_000,
-      })
-
-      // Still the same runtime — three full cycles, one runtime, one listener
-      const runtimeAfterC = getRuntime(thread.id)
       expect(await th.text()).toMatchInlineSnapshot(`
         "--- from: user (lifecycle-tester)
         Reply with exactly: seq-alpha
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000888>
         --- from: user (lifecycle-tester)
         Reply with exactly: seq-beta
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        --- from: user (lifecycle-tester)
-        Reply with exactly: seq-gamma
-        --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000888>"
       `)
-      expect(runtimeAfterC).toBe(runtimeAfterA)
+      expect(runtimeAfterB).toBe(runtimeAfterA)
     },
     15_000,
   )
@@ -398,10 +368,7 @@ describe('runtime lifecycle', () => {
       const messages = await discord.thread(thread.id).getMessages()
 
       const footerMessage = messages.find((message) => {
-        if (message.author.id !== discord.botUserId) {
-          return false
-        }
-        if (!message.content.startsWith('*')) {
+        if (!isFooterMessage({ message, botUserId: discord.botUserId })) {
           return false
         }
         return message.content.includes('deterministic-v2') && message.content.includes('%')
@@ -411,9 +378,9 @@ describe('runtime lifecycle', () => {
         "--- from: user (lifecycle-tester)
         Reply with exactly: footer-check
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000888>"
       `)
       expect(footerMessage).toBeDefined()
       if (!footerMessage) {
@@ -483,14 +450,14 @@ describe('runtime lifecycle', () => {
         "--- from: user (lifecycle-tester)
         Reply with exactly: reconnect-alpha
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000888>
         --- from: user (lifecycle-tester)
         Reply with exactly: reconnect-beta
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000888>"
       `)
 
       const runtimeAfterRestart = getRuntime(thread.id)
@@ -531,7 +498,7 @@ describe('runtime lifecycle', () => {
         "--- from: user (lifecycle-tester)
         Reply with exactly: footer-high-usage
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*"
       `)
 
       const threadText = await discord.thread(thread.id).text()

package/src/schema.sql

@@ -105,7 +105,7 @@ CREATE TABLE IF NOT EXISTS `part_messages` (
 	`message_id` text NOT NULL,
 	`thread_id` text NOT NULL,
 	`created_at` datetime DEFAULT CURRENT_TIMESTAMP,
-	CONSTRAINT `fk_part_messages_thread_id_thread_sessions_thread_id_fk` FOREIGN KEY (`thread_id`) REFERENCES `thread_sessions`(`thread_id`) ON UPDATE CASCADE
+	CONSTRAINT `fk_part_messages_thread_id_thread_sessions_thread_id_fk` FOREIGN KEY (`thread_id`) REFERENCES `thread_sessions`(`thread_id`) ON UPDATE CASCADE ON DELETE CASCADE
 );
 
 CREATE TABLE IF NOT EXISTS `scheduled_task_runs` (
@@ -168,6 +168,17 @@ CREATE TABLE IF NOT EXISTS `session_models` (
 	`created_at` datetime DEFAULT CURRENT_TIMESTAMP
 );
 
+CREATE TABLE IF NOT EXISTS `session_sleeps` (
+	`session_id` text PRIMARY KEY,
+	`wake_at` datetime NOT NULL,
+	`reason` text,
+	`status` text DEFAULT 'planned' NOT NULL,
+	`delivery_id` text NOT NULL,
+	`attempts` integer DEFAULT 0 NOT NULL,
+	`last_attempt_at` datetime,
+	`created_at` datetime DEFAULT CURRENT_TIMESTAMP
+);
+
 CREATE TABLE IF NOT EXISTS `session_start_sources` (
 	`session_id` text PRIMARY KEY,
 	`schedule_kind` text NOT NULL,
@@ -183,7 +194,8 @@ CREATE TABLE IF NOT EXISTS `thread_sessions` (
 	`source` text DEFAULT 'kimaki' NOT NULL,
 	`last_synced_name` text,
 	`parent_session_id` text,
-	`created_at` datetime DEFAULT CURRENT_TIMESTAMP
+	`created_at` datetime DEFAULT CURRENT_TIMESTAMP,
+	`updated_at` datetime DEFAULT CURRENT_TIMESTAMP
 );
 
 CREATE TABLE IF NOT EXISTS `thread_workspaces` (
@@ -219,4 +231,5 @@ CREATE INDEX IF NOT EXISTS `scheduled_tasks_channel_id_status_idx` ON `scheduled
 CREATE INDEX IF NOT EXISTS `scheduled_tasks_thread_id_status_idx` ON `scheduled_tasks` (`thread_id`,`status`);
 CREATE INDEX IF NOT EXISTS `session_events_session_id_timestamp_event_index_id_idx` ON `session_events` (`session_id`,`timestamp`,`event_index`,`id`);
 CREATE INDEX IF NOT EXISTS `session_events_thread_id_timestamp_event_index_id_idx` ON `session_events` (`thread_id`,`timestamp`,`event_index`,`id`);
+CREATE INDEX IF NOT EXISTS `session_sleeps_status_wake_at_idx` ON `session_sleeps` (`status`,`wake_at`);
 CREATE INDEX IF NOT EXISTS `session_start_sources_scheduled_task_id_idx` ON `session_start_sources` (`scheduled_task_id`);

package/src/schema.ts

@@ -33,6 +33,10 @@ export const thread_sessions = sqliteCore.sqliteTable('thread_sessions', {
   // Survives bot restarts so child multi-turn system prompts keep the parent ID.
   parent_session_id: sqliteCore.text('parent_session_id'),
   created_at: datetime('created_at').default(orm.sql`CURRENT_TIMESTAMP`),
+  // Bumped on every (re)binding of a session to this thread. /resume can map one
+  // session to several threads, so session_id -> thread_id needs a tiebreaker.
+  // Without it the reverse lookup is arbitrary and tools can target a dead thread.
+  updated_at: datetime('updated_at').default(orm.sql`CURRENT_TIMESTAMP`).$onUpdate(() => new Date()),
 })
 
 export const session_events = sqliteCore.sqliteTable('session_events', {
@@ -50,7 +54,7 @@ export const session_events = sqliteCore.sqliteTable('session_events', {
 export const part_messages = sqliteCore.sqliteTable('part_messages', {
   part_id: sqliteCore.text('part_id').primaryKey().notNull(),
   message_id: sqliteCore.text('message_id').notNull(),
-  thread_id: sqliteCore.text('thread_id').notNull().references(() => thread_sessions.thread_id, { onUpdate: 'cascade' }),
+  thread_id: sqliteCore.text('thread_id').notNull().references(() => thread_sessions.thread_id, { onDelete: 'cascade', onUpdate: 'cascade' }),
   created_at: datetime('created_at').default(orm.sql`CURRENT_TIMESTAMP`),
 })
 
@@ -224,6 +228,36 @@ export const forum_sync_configs = sqliteCore.sqliteTable('forum_sync_configs', {
   sqliteCore.uniqueIndex('forum_sync_configs_app_id_forum_channel_id_key').on(table.app_id, table.forum_channel_id),
 ])
 
+// Durable "wake this session later" rows for the kimaki_sleep tool.
+//
+// Delivery is at-least-once, and ingress makes it at-most-once-per-turn:
+//
+//   planned ──► consumed          cancelled / failed are terminal
+//      ▲   │
+//      └───┘ retried until ingress consumes it
+//
+// A row stays `planned` until ingress turns the wake into a turn, so ANY loss
+// (crash before posting, crash after posting, missed gateway event) is covered
+// by the same retry. `delivery_id` is the Discord message nonce, so a retry
+// returns the existing message instead of waking the session twice.
+//
+// There is no thread_id: the owning thread is resolved from session_id at wake
+// time, so a session rebound by /resume wakes in its current thread.
+export const session_sleeps = sqliteCore.sqliteTable('session_sleeps', {
+  session_id: sqliteCore.text('session_id').primaryKey().notNull(),
+  wake_at: datetime('wake_at').notNull(),
+  reason: sqliteCore.text('reason'),
+  status: sqliteCore.text('status', { enum: ['planned', 'consumed', 'cancelled', 'failed'] }).notNull().default('planned'),
+  // Regenerated per sleep occurrence. Doubles as the Discord nonce and as a
+  // generation guard so a stale in-flight wake cannot mutate a newer sleep.
+  delivery_id: sqliteCore.text('delivery_id').notNull().$defaultFn(() => crypto.randomUUID()),
+  attempts: sqliteCore.integer('attempts', { mode: 'number' }).notNull().default(0),
+  last_attempt_at: datetime('last_attempt_at'),
+  created_at: datetime('created_at').default(orm.sql`CURRENT_TIMESTAMP`),
+}, (table) => [
+  sqliteCore.index('session_sleeps_status_wake_at_idx').on(table.status, table.wake_at),
+])
+
 export const ipc_requests = sqliteCore.sqliteTable('ipc_requests', {
   id: sqliteCore.text('id').primaryKey().notNull().$defaultFn(() => crypto.randomUUID()),
   type: sqliteCore.text('type', { enum: ['file_upload', 'action_buttons'] }).notNull(),
@@ -259,6 +293,7 @@ export const relations = defineRelations({
   scheduled_task_runs,
   session_start_sources,
   forum_sync_configs,
+  session_sleeps,
   ipc_requests,
 }, (r) => ({
   thread_sessions: {
@@ -340,6 +375,7 @@ export const relations = defineRelations({
 export type BotMode = typeof bot_tokens.$inferSelect.bot_mode
 export type ChannelType = typeof channel_directories.$inferSelect.channel_type
 export type IpcRequestType = typeof ipc_requests.$inferSelect.type
+export type SessionSleepStatus = typeof session_sleeps.$inferSelect.status
 export type SessionEvent = typeof session_events.$inferSelect
 export type ThreadSessionSource = typeof thread_sessions.$inferSelect.source
 export type VerbosityLevel = typeof channel_verbosity.$inferSelect.verbosity