kimaki 0.26.0 → 0.28.0

package/dist/database.js

@@ -2,6 +2,9 @@
 // Stores thread-session mappings, bot tokens, channel directories,
 // API keys, and model preferences in <dataDir>/discord-sessions.db.
 import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as errore from 'errore';
 import * as orm from 'drizzle-orm';
 import { getDb, closeDb } from './db.js';
 import { createLogger, LogPrefix } from './logger.js';
@@ -213,6 +216,104 @@ export async function setSessionStartSource({ sessionId, scheduleKind, scheduled
         set: { schedule_kind: scheduleKind, scheduled_task_id: scheduledTaskId ?? null, updated_at: new Date() },
     });
 }
+export async function upsertSessionSleep({ sessionId, wakeAt, reason, }) {
+    const db = await getDb();
+    // A new occurrence gets a fresh delivery_id, which invalidates any in-flight
+    // wake for the previous occurrence: every delivery write is guarded on it.
+    const deliveryId = crypto.randomUUID();
+    await db.insert(schema.session_sleeps)
+        .values({
+        session_id: sessionId,
+        wake_at: wakeAt,
+        reason: reason ?? null,
+        status: 'planned',
+        delivery_id: deliveryId,
+    })
+        .onConflictDoUpdate({
+        target: schema.session_sleeps.session_id,
+        set: {
+            wake_at: wakeAt,
+            reason: reason ?? null,
+            status: 'planned',
+            delivery_id: deliveryId,
+            attempts: 0,
+            last_attempt_at: null,
+            created_at: new Date(),
+        },
+    });
+    return deliveryId;
+}
+export async function getSessionSleep({ sessionId }) {
+    const db = await getDb();
+    return await db.query.session_sleeps.findFirst({
+        where: { session_id: sessionId },
+    }) ?? null;
+}
+/** Rows that are due and not attempted too recently. Status stays `planned`. */
+export async function getDueSessionSleeps({ now, retryAfterMs, limit, }) {
+    const db = await getDb();
+    const retryBefore = new Date(now.getTime() - retryAfterMs);
+    return db.select()
+        .from(schema.session_sleeps)
+        .where(orm.and(orm.eq(schema.session_sleeps.status, 'planned'), orm.lte(schema.session_sleeps.wake_at, now), orm.or(orm.isNull(schema.session_sleeps.last_attempt_at), orm.lte(schema.session_sleeps.last_attempt_at, retryBefore))))
+        .orderBy(orm.asc(schema.session_sleeps.wake_at))
+        .limit(limit);
+}
+/**
+ * Reserve one delivery attempt. The row never leaves `planned` here.
+ *
+ * Only `last_attempt_at` moves, which keeps concurrent ticks off the same row
+ * for retryAfterMs. Because posting does not change the status either, one
+ * retry path covers every loss: dying before the post, dying after it, or
+ * never receiving the gateway event for the message we posted.
+ */
+export async function claimSessionSleepAttempt({ sessionId, deliveryId, now, retryAfterMs, }) {
+    const db = await getDb();
+    const retryBefore = new Date(now.getTime() - retryAfterMs);
+    const rows = await db.update(schema.session_sleeps)
+        .set({ last_attempt_at: now, attempts: orm.sql `${schema.session_sleeps.attempts} + 1` })
+        .where(orm.and(orm.eq(schema.session_sleeps.session_id, sessionId), orm.eq(schema.session_sleeps.delivery_id, deliveryId), orm.eq(schema.session_sleeps.status, 'planned'), orm.lte(schema.session_sleeps.wake_at, now), orm.or(orm.isNull(schema.session_sleeps.last_attempt_at), orm.lte(schema.session_sleeps.last_attempt_at, retryBefore))))
+        .returning();
+    return rows[0] ?? null;
+}
+export async function markSessionSleepFailed({ sessionId, deliveryId, }) {
+    const db = await getDb();
+    const rows = await db.update(schema.session_sleeps)
+        .set({ status: 'failed' })
+        .where(orm.and(orm.eq(schema.session_sleeps.session_id, sessionId), orm.eq(schema.session_sleeps.delivery_id, deliveryId), orm.eq(schema.session_sleeps.status, 'planned')))
+        .returning({ session_id: schema.session_sleeps.session_id });
+    return countRows(rows) > 0;
+}
+/**
+ * Ingress commit point. Marks the wake as delivered to the session.
+ *
+ * Returns false when the row is missing or no longer `planned`, which is how a
+ * wake that raced a user cancellation, or a duplicate of one already delivered,
+ * gets dropped instead of starting a turn.
+ */
+export async function consumeSessionSleepWake({ deliveryId }) {
+    const db = await getDb();
+    const rows = await db.update(schema.session_sleeps)
+        .set({ status: 'consumed' })
+        .where(orm.and(orm.eq(schema.session_sleeps.delivery_id, deliveryId), orm.eq(schema.session_sleeps.status, 'planned')))
+        .returning({ session_id: schema.session_sleeps.session_id });
+    return countRows(rows) > 0;
+}
+/**
+ * Cancel the pending sleep of the session currently bound to a thread.
+ *
+ * Runs on every ingress, so the binding is resolved with a correlated subquery
+ * rather than a second round trip. thread_id is the primary key of
+ * thread_sessions, so it yields at most one session.
+ */
+export async function cancelSessionSleepForThread({ threadId }) {
+    const db = await getDb();
+    const rows = await db.update(schema.session_sleeps)
+        .set({ status: 'cancelled' })
+        .where(orm.and(orm.eq(schema.session_sleeps.status, 'planned'), orm.eq(schema.session_sleeps.session_id, orm.sql `(SELECT ${schema.thread_sessions.session_id} FROM ${schema.thread_sessions} WHERE ${schema.thread_sessions.thread_id} = ${threadId})`)))
+        .returning({ session_id: schema.session_sleeps.session_id });
+    return countRows(rows) > 0;
+}
 export async function getSessionStartSourcesBySessionIds(sessionIds) {
     if (sessionIds.length === 0)
         return new Map();
@@ -226,6 +327,12 @@ export async function getSessionStartSourcesBySessionIds(sessionIds) {
     }
     return new Map(rows.map((row) => [row.session_id, row]));
 }
+export async function getSessionStartSource({ sessionId }) {
+    const db = await getDb();
+    return await db.query.session_start_sources.findFirst({
+        where: { session_id: sessionId },
+    }) ?? null;
+}
 export async function getChannelModel(channelId) {
     const db = await getDb();
     const row = await db.query.channel_models.findFirst({ where: { channel_id: channelId } });
@@ -440,9 +547,18 @@ export async function setThreadSession(threadId, sessionId) {
 }
 export async function upsertThreadSession({ threadId, sessionId, source }) {
     const db = await getDb();
+    // updated_at is written explicitly on BOTH paths, never left to the column's
+    // CURRENT_TIMESTAMP default. The default stores "YYYY-MM-DD HH:MM:SS" while
+    // Date values store ISO with a "T", and those two text formats do not sort
+    // against each other correctly. Writing ISO everywhere keeps the ordering in
+    // getThreadIdBySessionId honest and gives it millisecond resolution.
+    const boundAt = new Date();
     await db.insert(schema.thread_sessions)
-        .values({ thread_id: threadId, session_id: sessionId, source })
-        .onConflictDoUpdate({ target: schema.thread_sessions.thread_id, set: { session_id: sessionId, source } });
+        .values({ thread_id: threadId, session_id: sessionId, source, updated_at: boundAt })
+        .onConflictDoUpdate({
+        target: schema.thread_sessions.thread_id,
+        set: { session_id: sessionId, source, updated_at: boundAt },
+    });
 }
 export async function getThreadParentSessionId(threadId) {
     const db = await getDb();
@@ -462,9 +578,23 @@ export async function getThreadSessionSource(threadId) {
     const db = await getDb();
     return (await db.query.thread_sessions.findFirst({ where: { thread_id: threadId }, columns: { source: true } }))?.source;
 }
+/**
+ * Reverse lookup of the Discord thread that currently owns an OpenCode session.
+ *
+ * `thread_sessions.session_id` is NOT unique: /resume binds an existing session
+ * to a brand new thread without clearing the old row. An unordered findFirst
+ * therefore returns an arbitrary (often dead) thread, which made plugin tools
+ * post into the wrong conversation. Order by the most recent binding instead,
+ * falling back to created_at for rows written before updated_at existed.
+ */
 export async function getThreadIdBySessionId(sessionId) {
     const db = await getDb();
-    return (await db.query.thread_sessions.findFirst({ where: { session_id: sessionId } }))?.thread_id;
+    const rows = await db.select({ thread_id: schema.thread_sessions.thread_id })
+        .from(schema.thread_sessions)
+        .where(orm.eq(schema.thread_sessions.session_id, sessionId))
+        .orderBy(orm.desc(orm.sql `COALESCE(${schema.thread_sessions.updated_at}, ${schema.thread_sessions.created_at})`))
+        .limit(1);
+    return rows[0]?.thread_id;
 }
 export async function getAllThreadSessionIds() {
     const db = await getDb();
@@ -671,6 +801,25 @@ export async function findChannelsByDirectory({ directory, channelType }) {
                 : undefined;
     return db.query.channel_directories.findMany({ where, columns: { channel_id: true, directory: true, channel_type: true, guild_id: true } });
 }
+function canonicalizeDirectory(directory) {
+    const resolved = path.resolve(directory);
+    const real = errore.try(() => fs.realpathSync(resolved), (e) => new Error('realpath failed', { cause: e }));
+    if (real instanceof Error)
+        return resolved;
+    return real;
+}
+export async function findRegisteredTextChannelForDirectory(directory) {
+    const wanted = canonicalizeDirectory(directory);
+    const channels = await findChannelsByDirectory({ channelType: 'text' });
+    return channels.find((ch) => canonicalizeDirectory(ch.directory) === wanted) ?? null;
+}
+export function formatProjectAlreadyRegisteredError({ channelId, directory, }) {
+    return [
+        `Channel already exists for this directory: ${directory}`,
+        `Channel ID: ${channelId}`,
+        `Remove the mapping first: kimaki project remove ${channelId}`,
+    ].join('\n');
+}
 export async function getAllTextChannelDirectories() {
     const db = await getDb();
     const rows = await db.query.channel_directories.findMany({ where: { channel_type: 'text' }, columns: { directory: true } });

package/dist/db.js

@@ -89,6 +89,20 @@ async function initializeDb() {
     dbInstance = db;
     return db;
 }
+// CREATE TABLE IF NOT EXISTS cannot drop columns. The first two session_sleeps
+// shapes kept thread_id NOT NULL and posted_at. Inserts now omit thread_id, so
+// existing DBs fail with SQLITE_CONSTRAINT_NOTNULL until those columns go away.
+async function dropLegacySessionSleepsColumns(client) {
+    const info = await client.execute('PRAGMA table_info(session_sleeps)');
+    const columns = new Set(info.rows.map((row) => String(row.name)));
+    if (columns.has('thread_id')) {
+        await client.execute('ALTER TABLE session_sleeps DROP COLUMN thread_id');
+    }
+    if (columns.has('posted_at')) {
+        await client.execute('ALTER TABLE session_sleeps DROP COLUMN posted_at');
+    }
+    await client.execute("UPDATE session_sleeps SET status = 'planned' WHERE status = 'posted'");
+}
 async function migrateSchema({ db, client, }) {
     const schemaPath = path.join(__dirname, '../src/schema.sql');
     const sql = fs.readFileSync(schemaPath, 'utf-8');
@@ -120,7 +134,12 @@ async function migrateSchema({ db, client, }) {
         "ALTER TABLE thread_sessions ADD COLUMN source TEXT DEFAULT 'kimaki'",
         'ALTER TABLE thread_sessions ADD COLUMN last_synced_name TEXT',
         'ALTER TABLE thread_sessions ADD COLUMN parent_session_id TEXT',
+        'ALTER TABLE thread_sessions ADD COLUMN updated_at DATETIME',
         'ALTER TABLE channel_directories ADD COLUMN guild_id TEXT',
+        // First session_sleeps shape had thread_id only. Later ticks query these.
+        'ALTER TABLE session_sleeps ADD COLUMN delivery_id TEXT',
+        'ALTER TABLE session_sleeps ADD COLUMN attempts INTEGER DEFAULT 0',
+        'ALTER TABLE session_sleeps ADD COLUMN last_attempt_at DATETIME',
     ];
     for (const stmt of alterStatements) {
         await client.execute(stmt).catch(() => undefined);
@@ -140,10 +159,24 @@ async function migrateSchema({ db, client, }) {
         "UPDATE bot_tokens SET bot_mode = 'self_hosted' WHERE bot_mode = 'self-hosted'",
         "UPDATE bot_tokens SET proxy_url = REPLACE(proxy_url, 'discord-gateway.kimaki.xyz', 'discord-gateway.kimaki.dev') WHERE bot_mode = 'gateway' AND proxy_url LIKE '%discord-gateway.kimaki.xyz%'",
         "UPDATE thread_worktrees SET status = 'pending' WHERE status IS NULL",
+        "UPDATE session_sleeps SET delivery_id = lower(hex(randomblob(16))) WHERE delivery_id IS NULL",
+        'UPDATE session_sleeps SET attempts = 0 WHERE attempts IS NULL',
     ];
     for (const stmt of migrationStatements) {
         await client.execute(stmt).catch(() => undefined);
     }
+    // Existing part_messages tables never get a rewritten FK. Drop orphans.
+    // NOT EXISTS, not NOT IN: a NULL thread_sessions.thread_id would make
+    // NOT IN unknown for every row and skip the whole cleanup.
+    await client.execute(`
+    DELETE FROM part_messages
+    WHERE NOT EXISTS (
+      SELECT 1
+      FROM thread_sessions
+      WHERE thread_sessions.thread_id = part_messages.thread_id
+    )
+  `);
+    await dropLegacySessionSleepsColumns(client);
     // Migrate legacy thread_worktrees rows into thread_workspaces.
     // Rows that already exist in thread_workspaces (by thread_id) are skipped.
     await client.execute(`

package/dist/db.test.js

@@ -7,7 +7,8 @@ import { afterAll, describe, expect, test } from 'vitest';
 import { closeDb, getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
-import { appendSessionEventsSinceLastTimestamp, createPendingWorkspace, getSessionEventSnapshot, getSessionModel, setSessionModel, } from './database.js';
+import { appendSessionEventsSinceLastTimestamp, createPendingWorkspace, getDueSessionSleeps, getSessionEventSnapshot, getSessionModel, getSessionSleep, setSessionModel, upsertSessionSleep, } from './database.js';
+import { createClient } from '@libsql/client';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { chooseLockPort } from './test-utils.js';
 import { copyCurrentSessionModel } from './commands/model.js';
@@ -15,6 +16,271 @@ afterAll(async () => {
     await closeDb();
 });
 describe('getDb', () => {
+    test('schema.sql creates every drizzle table', () => {
+        const schemaTs = fs.readFileSync(path.join(import.meta.dirname, 'schema.ts'), 'utf8');
+        const schemaSql = fs.readFileSync(path.join(import.meta.dirname, 'schema.sql'), 'utf8');
+        const tablesFromTs = [
+            ...schemaTs.matchAll(/sqliteTable\('([^']+)'/g),
+        ].map((match) => match[1]);
+        const tablesFromSql = [
+            ...schemaSql.matchAll(/CREATE TABLE IF NOT EXISTS `([^`]+)`/g),
+        ].map((match) => match[1]);
+        expect(new Set(tablesFromSql)).toEqual(new Set(tablesFromTs));
+        expect(tablesFromSql).toContain('session_sleeps');
+    });
+    test('removes part_messages rows whose thread_sessions parent is gone', async () => {
+        await closeDb();
+        const previousDbUrl = process.env['KIMAKI_DB_URL'];
+        const dbPath = path.join(process.cwd(), `tmp/test-db-orphan-parts-${crypto.randomUUID().slice(0, 8)}.db`);
+        try {
+            const client = createClient({ url: `file:${dbPath}` });
+            await client.execute(`
+        CREATE TABLE thread_sessions (
+          thread_id text PRIMARY KEY,
+          session_id text NOT NULL
+        )
+      `);
+            await client.execute(`
+        CREATE TABLE part_messages (
+          part_id text PRIMARY KEY,
+          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
+        )
+      `);
+            await client.execute(`
+        INSERT INTO thread_sessions (thread_id, session_id)
+        VALUES ('thr-keep', 'ses-keep'), ('thr-gone', 'ses-gone')
+      `);
+            await client.execute(`
+        INSERT INTO part_messages (part_id, message_id, thread_id)
+        VALUES
+          ('part-keep', 'msg-keep', 'thr-keep'),
+          ('part-orphan', 'msg-orphan', 'thr-gone')
+      `);
+            // sqlite3 CLI leaves foreign_keys OFF, which is how real installs
+            // accumulate these orphans. libsql defaults to ON.
+            await client.execute('PRAGMA foreign_keys = OFF');
+            await client.execute(`DELETE FROM thread_sessions WHERE thread_id = 'thr-gone'`);
+            await client.execute(`
+        INSERT INTO thread_sessions (thread_id, session_id)
+        VALUES (NULL, 'ses-null')
+      `);
+            await client.execute('PRAGMA foreign_keys = ON');
+            const before = await client.execute(`
+        SELECT COUNT(*) AS n FROM part_messages
+        WHERE NOT EXISTS (
+          SELECT 1 FROM thread_sessions
+          WHERE thread_sessions.thread_id = part_messages.thread_id
+        )
+      `);
+            expect(Number(before.rows[0]?.n)).toBe(1);
+            client.close();
+            process.env['KIMAKI_DB_URL'] = `file:${dbPath}`;
+            const db = await getDb();
+            const remaining = await db.query.part_messages.findMany({
+                columns: { part_id: true },
+                orderBy: { part_id: 'asc' },
+            });
+            expect(remaining).toMatchInlineSnapshot(`
+        [
+          {
+            "part_id": "part-keep",
+          },
+        ]
+      `);
+        }
+        finally {
+            await closeDb();
+            if (previousDbUrl === undefined) {
+                delete process.env['KIMAKI_DB_URL'];
+            }
+            else {
+                process.env['KIMAKI_DB_URL'] = previousDbUrl;
+            }
+            for (const file of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+                try {
+                    fs.unlinkSync(file);
+                }
+                catch {
+                    // Test cleanup best effort.
+                }
+            }
+        }
+    });
+    test('deleting a thread_sessions row also deletes its part_messages', async () => {
+        const db = await getDb();
+        const threadId = `test-part-cascade-${crypto.randomUUID()}`;
+        await db.insert(schema.thread_sessions).values({
+            thread_id: threadId,
+            session_id: 'ses-part-cascade',
+        });
+        await db.insert(schema.part_messages).values({
+            part_id: `${threadId}-part`,
+            message_id: 'msg-part-cascade',
+            thread_id: threadId,
+        });
+        await db.delete(schema.thread_sessions).where(orm.eq(schema.thread_sessions.thread_id, threadId));
+        const leftover = await db.query.part_messages.findFirst({
+            where: { thread_id: threadId },
+        });
+        expect(leftover).toBeUndefined();
+    });
+    test('adds session_sleeps delivery columns on databases created before that schema', async () => {
+        await closeDb();
+        const previousDbUrl = process.env['KIMAKI_DB_URL'];
+        const dbPath = path.join(process.cwd(), `tmp/test-db-legacy-sleeps-${crypto.randomUUID().slice(0, 8)}.db`);
+        try {
+            const client = createClient({ url: `file:${dbPath}` });
+            await client.execute(`
+        CREATE TABLE thread_sessions (
+          thread_id text PRIMARY KEY,
+          session_id text NOT NULL
+        )
+      `);
+            await client.execute(`
+        CREATE TABLE session_sleeps (
+          session_id text PRIMARY KEY,
+          thread_id text NOT NULL,
+          wake_at datetime NOT NULL,
+          reason text,
+          status text DEFAULT 'planned' NOT NULL,
+          created_at datetime DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            await client.execute(`
+        INSERT INTO thread_sessions (thread_id, session_id)
+        VALUES ('thr-legacy', 'ses-legacy')
+      `);
+            await client.execute(`
+        INSERT INTO session_sleeps (session_id, thread_id, wake_at, status)
+        VALUES ('ses-legacy', 'thr-legacy', '2020-01-01T00:00:00.000Z', 'planned')
+      `);
+            client.close();
+            process.env['KIMAKI_DB_URL'] = `file:${dbPath}`;
+            await getDb();
+            const due = await getDueSessionSleeps({
+                now: new Date('2026-08-21T00:00:00Z'),
+                retryAfterMs: 30_000,
+                limit: 10,
+            });
+            const legacy = due.find((row) => row.session_id === 'ses-legacy');
+            expect(legacy?.delivery_id).toBeTruthy();
+            expect(legacy?.attempts).toBe(0);
+            // The first table required thread_id. After the column was dropped from
+            // the schema, inserts that omit it must still work on existing databases.
+            await upsertSessionSleep({
+                sessionId: 'ses-legacy-new',
+                wakeAt: new Date('2026-08-26T00:00:00Z'),
+                reason: 'check the reply',
+            });
+            const created = await getSessionSleep({ sessionId: 'ses-legacy-new' });
+            expect(created?.status).toBe('planned');
+            expect(created?.reason).toBe('check the reply');
+            expect(created?.delivery_id).toBeTruthy();
+        }
+        finally {
+            await closeDb();
+            if (previousDbUrl === undefined) {
+                delete process.env['KIMAKI_DB_URL'];
+            }
+            else {
+                process.env['KIMAKI_DB_URL'] = previousDbUrl;
+            }
+            for (const file of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+                try {
+                    fs.unlinkSync(file);
+                }
+                catch {
+                    // Test cleanup best effort.
+                }
+            }
+        }
+    });
+    test('rebuilds session_sleeps that still have posted_at from the intermediate schema', async () => {
+        await closeDb();
+        const previousDbUrl = process.env['KIMAKI_DB_URL'];
+        const dbPath = path.join(process.cwd(), `tmp/test-db-posted-sleeps-${crypto.randomUUID().slice(0, 8)}.db`);
+        try {
+            const client = createClient({ url: `file:${dbPath}` });
+            await client.execute(`
+        CREATE TABLE thread_sessions (
+          thread_id text PRIMARY KEY,
+          session_id text NOT NULL
+        )
+      `);
+            await client.execute(`
+        CREATE TABLE session_sleeps (
+          session_id text PRIMARY KEY,
+          thread_id text NOT NULL,
+          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,
+          posted_at datetime,
+          created_at datetime DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            await client.execute(`
+        INSERT INTO thread_sessions (thread_id, session_id)
+        VALUES ('thr-posted', 'ses-posted')
+      `);
+            await client.execute(`
+        INSERT INTO session_sleeps (
+          session_id, thread_id, wake_at, status, delivery_id, posted_at
+        )
+        VALUES (
+          'ses-posted',
+          'thr-posted',
+          '2020-01-01T00:00:00.000Z',
+          'posted',
+          'del-posted',
+          '2020-01-01T00:00:01.000Z'
+        )
+      `);
+            client.close();
+            process.env['KIMAKI_DB_URL'] = `file:${dbPath}`;
+            await getDb();
+            const due = await getDueSessionSleeps({
+                now: new Date('2026-08-21T00:00:00Z'),
+                retryAfterMs: 30_000,
+                limit: 10,
+            });
+            const posted = due.find((row) => row.session_id === 'ses-posted');
+            expect(posted?.status).toBe('planned');
+            expect(posted?.delivery_id).toBe('del-posted');
+            await upsertSessionSleep({
+                sessionId: 'ses-posted',
+                wakeAt: new Date('2026-08-26T00:00:00Z'),
+                reason: 'retry after schema change',
+            });
+            const updated = await getSessionSleep({ sessionId: 'ses-posted' });
+            expect(updated?.status).toBe('planned');
+            expect(updated?.reason).toBe('retry after schema change');
+            expect(updated?.delivery_id).not.toBe('del-posted');
+        }
+        finally {
+            await closeDb();
+            if (previousDbUrl === undefined) {
+                delete process.env['KIMAKI_DB_URL'];
+            }
+            else {
+                process.env['KIMAKI_DB_URL'] = previousDbUrl;
+            }
+            for (const file of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+                try {
+                    fs.unlinkSync(file);
+                }
+                catch {
+                    // Test cleanup best effort.
+                }
+            }
+        }
+    });
     test('creates sqlite file and migrates schema automatically', async () => {
         const db = await getDb();
         const [session] = await db.insert(schema.thread_sessions)