kimaki 0.28.0 → 0.30.0

package/dist/guild-categories.test.js

@@ -0,0 +1,225 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { afterEach, beforeEach, expect, test } from 'vitest';
+import { ChannelType, Client, Events, GatewayIntentBits } from 'discord.js';
+import { DigitalDiscord } from 'discord-digital-twin/src';
+import { setDataDir } from './config.js';
+import { closeDb } from './db.js';
+import { createDefaultKimakiChannel, createProjectChannels, ensureKimakiCategory, } from './channel-management.js';
+import { getGuildCategories, initDatabase, setChannelDirectory, } from './database.js';
+const guildId = '100000000000000111';
+const otherGuildId = '100000000000000222';
+let directory;
+let discord;
+let client;
+async function startDiscord({ dataDir }) {
+    discord = new DigitalDiscord({
+        dbUrl: `file:${path.join(dataDir, 'discord.db')}`,
+        users: [{ id: '100000000000000555', username: 'server-owner' }],
+        guilds: [
+            { id: guildId, name: 'Studio', ownerId: '100000000000000555' },
+            { id: otherGuildId, name: 'Office', ownerId: '100000000000000555' },
+        ],
+    });
+    await discord.start();
+    client = new Client({
+        intents: [GatewayIntentBits.Guilds],
+        rest: { api: discord.restUrl, version: '10' },
+    });
+    const ready = new Promise((resolve) => client.once(Events.ClientReady, () => resolve()));
+    await client.login(discord.botToken);
+    await ready;
+}
+async function openDataDir() {
+    const root = path.resolve('tmp/guild-categories');
+    fs.mkdirSync(root, { recursive: true });
+    directory = fs.mkdtempSync(path.join(root, 'run-'));
+    setDataDir(directory);
+    await closeDb();
+    await initDatabase();
+}
+beforeEach(async () => {
+    await openDataDir();
+    await startDiscord({ dataDir: directory });
+});
+afterEach(async () => {
+    await client?.destroy();
+    await discord?.stop();
+    await closeDb();
+    fs.rmSync(directory, { recursive: true, force: true });
+});
+function guild() {
+    return client.guilds.cache.get(guildId);
+}
+test('first project creates a Kimaki group and stores its id', async () => {
+    const created = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'web'),
+    });
+    const channel = await guild().channels.fetch(created.textChannelId);
+    expect(channel?.parentId).toBeTruthy();
+    const category = await guild().channels.fetch(channel.parentId);
+    expect(category?.name).toBe('Kimaki');
+    expect(await getGuildCategories(guildId)).toEqual({
+        guild_id: guildId,
+        category_id: category.id,
+        audio_category_id: null,
+    });
+});
+test('renamed group still receives new project channels', async () => {
+    const first = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'web'),
+    });
+    const firstChannel = await guild().channels.fetch(first.textChannelId);
+    const category = await guild().channels.fetch(firstChannel.parentId);
+    await category.setName('laptop');
+    const second = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'api'),
+    });
+    const secondChannel = await guild().channels.fetch(second.textChannelId);
+    expect(secondChannel?.parentId).toBe(firstChannel?.parentId);
+    expect((await guild().channels.fetch(secondChannel.parentId))?.name).toBe('laptop');
+});
+test('a second machine creates its own Kimaki group', async () => {
+    const first = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'web'),
+    });
+    const firstParent = (await guild().channels.fetch(first.textChannelId))
+        ?.parentId;
+    await closeDb();
+    await openDataDir();
+    const second = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'api'),
+    });
+    const secondParent = (await guild().channels.fetch(second.textChannelId))
+        ?.parentId;
+    expect(secondParent).toBeTruthy();
+    expect(secondParent).not.toBe(firstParent);
+    const categories = [...guild().channels.cache.values()].filter((channel) => channel.type === ChannelType.GuildCategory);
+    expect(categories.map((channel) => channel.name).sort()).toEqual([
+        'Kimaki',
+        'Kimaki',
+    ]);
+});
+test('existing project channels adopt their parent without creating a new group', async () => {
+    const category = await guild().channels.create({
+        name: 'studio',
+        type: ChannelType.GuildCategory,
+    });
+    const text = await guild().channels.create({
+        name: 'web',
+        type: ChannelType.GuildText,
+        parent: category,
+    });
+    await setChannelDirectory({
+        channelId: text.id,
+        directory: path.join(directory, 'web'),
+        channelType: 'text',
+        guildId,
+    });
+    const resolved = await ensureKimakiCategory(guild());
+    expect(resolved.id).toBe(category.id);
+    expect(await getGuildCategories(guildId)).toMatchObject({
+        guild_id: guildId,
+        category_id: category.id,
+    });
+    const categoryCount = [...guild().channels.cache.values()].filter((channel) => channel.type === ChannelType.GuildCategory).length;
+    expect(categoryCount).toBe(1);
+});
+test('a second machine gets its own default kimaki channel', async () => {
+    const first = await createDefaultKimakiChannel({
+        guild: guild(),
+        appId: discord.botUserId,
+        isGatewayMode: true,
+    });
+    expect(first).toBeTruthy();
+    await closeDb();
+    await openDataDir();
+    const second = await createDefaultKimakiChannel({
+        guild: guild(),
+        appId: discord.botUserId,
+        isGatewayMode: true,
+    });
+    expect(second).toBeTruthy();
+    expect(second.textChannelId).not.toBe(first.textChannelId);
+    expect(second.textChannel.parentId).not.toBe(first.textChannel.parentId);
+});
+test('legacy rows from another guild do not block adoption', async () => {
+    const otherGuild = client.guilds.cache.get(otherGuildId);
+    const foreignCategory = await otherGuild.channels.create({
+        name: 'foreign',
+        type: ChannelType.GuildCategory,
+    });
+    const foreignChannel = await otherGuild.channels.create({
+        name: 'web',
+        type: ChannelType.GuildText,
+        parent: foreignCategory,
+    });
+    const localCategory = await guild().channels.create({
+        name: 'studio',
+        type: ChannelType.GuildCategory,
+    });
+    const localChannel = await guild().channels.create({
+        name: 'api',
+        type: ChannelType.GuildText,
+        parent: localCategory,
+    });
+    await setChannelDirectory({
+        channelId: foreignChannel.id,
+        directory: path.join(directory, 'foreign'),
+        channelType: 'text',
+    });
+    await setChannelDirectory({
+        channelId: localChannel.id,
+        directory: path.join(directory, 'api'),
+        channelType: 'text',
+    });
+    const resolved = await ensureKimakiCategory(guild());
+    expect(resolved.id).toBe(localCategory.id);
+});
+test('a kimaki-prefixed project channel does not block the default channel', async () => {
+    await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'kimaki-tools'),
+    });
+    const created = await createDefaultKimakiChannel({
+        guild: guild(),
+        appId: discord.botUserId,
+        isGatewayMode: true,
+    });
+    expect(created).toBeTruthy();
+    expect(created.channelName).toBe('kimaki');
+});
+test('concurrent first creates share one group', async () => {
+    const [first, second] = await Promise.all([
+        ensureKimakiCategory(guild()),
+        ensureKimakiCategory(guild()),
+    ]);
+    expect(first.id).toBe(second.id);
+    const categories = [...guild().channels.cache.values()].filter((channel) => channel.type === ChannelType.GuildCategory);
+    expect(categories).toHaveLength(1);
+});
+test('deleted group is replaced and SQLite is updated', async () => {
+    const first = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'web'),
+    });
+    const firstParent = (await guild().channels.fetch(first.textChannelId))
+        ?.parentId;
+    await (await guild().channels.fetch(firstParent)).delete();
+    const second = await createProjectChannels({
+        guild: guild(),
+        projectDirectory: path.join(directory, 'api'),
+    });
+    const secondParent = (await guild().channels.fetch(second.textChannelId))
+        ?.parentId;
+    expect(secondParent).toBeTruthy();
+    expect(secondParent).not.toBe(firstParent);
+    expect(await getGuildCategories(guildId)).toMatchObject({
+        category_id: secondParent,
+    });
+});

package/dist/hrana-server.js

@@ -148,7 +148,7 @@ export async function startHranaServer({ dbPath, bindAll = false, }) {
         // Health check — no auth required
         if (pathname === '/health') {
             res.writeHead(200, { 'content-type': 'application/json' });
-            res.end(JSON.stringify({ status: 'ok', pid: process.pid }));
+            res.end(JSON.stringify({ status: 'ok', pid: process.pid, wrapperPid: getWrapperPid() }));
             return;
         }
         // OpenCode server port discovery — no auth required (localhost only).
@@ -230,8 +230,12 @@ export async function stopHranaServer() {
  * Evict a previous kimaki instance on the lock port.
  * Fetches /health to get the running process PID, then kills it directly.
  * No lsof/netstat/spawnSync needed — the PID comes from the health response.
+ *
+ * SIGTERM first so the old bot can clean up. Its own shutdown deadline is
+ * 15s, so after a longer grace period we SIGKILL: a stuck process must never
+ * block every future start. Safe because the PID comes from our own /health.
  */
-export async function evictExistingInstance({ port }) {
+export async function evictExistingInstance({ port, gracePeriodMs = 20_000, }) {
     const url = `http://127.0.0.1:${port}/health`;
     const probe = await fetch(url, { signal: AbortSignal.timeout(1000) }).catch((e) => new FetchError({ url, cause: e }));
     if (probe instanceof Error)
@@ -242,9 +246,15 @@ export async function evictExistingInstance({ port }) {
     const targetPid = body.pid;
     if (!targetPid || targetPid === process.pid)
         return;
-    hranaLogger.log(`Evicting existing kimaki process (PID: ${targetPid}) on port ${port}`);
+    // Signal the bin.ts wrapper, not only the child: killing just the child
+    // looks like a crash and the old wrapper respawns it, which then evicts us.
+    // The wrapper forwards SIGTERM and does not restart after it.
+    const wrapperPid = body.wrapperPid && body.wrapperPid !== process.ppid
+        ? body.wrapperPid
+        : null;
+    hranaLogger.log(`Evicting existing kimaki process (PID: ${targetPid}, wrapper: ${wrapperPid ?? 'none'}) on port ${port}`);
     const killResult = errore.try(() => {
-        process.kill(targetPid, 'SIGTERM');
+        process.kill(wrapperPid ?? targetPid, 'SIGTERM');
     }, (e) => new Error('Failed to send SIGTERM to existing kimaki process', {
         cause: e,
     }));
@@ -252,17 +262,61 @@ export async function evictExistingInstance({ port }) {
         hranaLogger.log(`Failed to kill PID ${targetPid}: ${killResult.message}`);
         return;
     }
-    for (let attempt = 0; attempt < 10; attempt += 1) {
+    // Wait for process exit, not just a failed probe: a process that already
+    // closed its HTTP server can still be alive and holding the socket briefly.
+    if (await waitForProcessExit({ pid: targetPid, timeoutMs: gracePeriodMs })) {
+        return;
+    }
+    hranaLogger.log(`PID ${targetPid} still alive after ${gracePeriodMs / 1000}s SIGTERM grace period, sending SIGKILL`);
+    // Wrapper first so it cannot respawn the child we are about to kill.
+    const wrapperKillResult = wrapperPid
+        ? errore.try(() => {
+            process.kill(wrapperPid, 'SIGKILL');
+        }, (e) => new Error('Failed to send SIGKILL to kimaki wrapper', { cause: e }))
+        : null;
+    if (wrapperKillResult instanceof Error) {
+        hranaLogger.log(`Failed to kill wrapper PID ${wrapperPid}: ${wrapperKillResult.message}`);
+    }
+    const forceKillResult = errore.try(() => {
+        process.kill(targetPid, 'SIGKILL');
+    }, (e) => new Error('Failed to send SIGKILL to existing kimaki process', {
+        cause: e,
+    }));
+    if (forceKillResult instanceof Error) {
+        hranaLogger.log(`Failed to kill PID ${targetPid}: ${forceKillResult.message}`);
+        return;
+    }
+    if (await waitForProcessExit({ pid: targetPid, timeoutMs: 5_000 })) {
+        return;
+    }
+    hranaLogger.log(`PID ${targetPid} still alive after SIGKILL`);
+}
+// PID of the bin.ts respawn wrapper, only while it is alive (IPC connected).
+// Without the connected check an orphan would report ppid 1.
+function getWrapperPid() {
+    if (!process.env.__KIMAKI_CHILD || !process.connected) {
+        return null;
+    }
+    return process.ppid;
+}
+function isProcessAlive(pid) {
+    const result = errore.try(() => {
+        process.kill(pid, 0);
+    }, (e) => new Error('Process liveness check failed', { cause: e }));
+    if (result instanceof Error) {
+        // EPERM means the PID exists but belongs to another user.
+        return result.cause instanceof Error && Reflect.get(result.cause, 'code') === 'EPERM';
+    }
+    return true;
+}
+async function waitForProcessExit({ pid, timeoutMs, }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid))
+            return true;
         await new Promise((resolve) => {
-            setTimeout(resolve, 1000);
+            setTimeout(resolve, 200);
         });
-        // Verify it's gone. Some shutdown paths need a few seconds to run cleanup,
-        // so we avoid SIGKILL and just poll for up to 10 seconds.
-        const secondProbe = await fetch(url, {
-            signal: AbortSignal.timeout(2000),
-        }).catch((e) => new FetchError({ url, cause: e }));
-        if (secondProbe instanceof Error)
-            return;
     }
-    hranaLogger.log(`PID ${targetPid} still alive after 10s SIGTERM grace period`);
+    return !isProcessAlive(pid);
 }

package/dist/interaction-handler.js

@@ -28,7 +28,7 @@ import { handleAskQuestionSelectMenu } from './commands/ask-question.js';
 import { handleFileUploadButton, handleFileUploadModalSubmit, } from './commands/file-upload.js';
 import { handleActionButton } from './commands/action-buttons.js';
 import { handleHtmlActionButton } from './html-actions.js';
-import { handleQueueCommand, handleClearQueueCommand, handleQueueCommandCommand, handleQueueCommandAutocomplete, } from './commands/queue.js';
+import { handleQueueCommand, handleClearQueueCommand, handleQueueCommandCommand, handleQueueCommandAutocomplete, handleQueueRemoveButton, QUEUE_REMOVE_CUSTOM_ID_PREFIX, } from './commands/queue.js';
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
 import { handleUserCommand } from './commands/user-command.js';
 import { handleVerbosityCommand, handleVerbositySelectMenu, } from './commands/verbosity.js';
@@ -397,6 +397,10 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                         await handleActionButton(interaction);
                         return;
                     }
+                    if (customId.startsWith(QUEUE_REMOVE_CUSTOM_ID_PREFIX)) {
+                        await handleQueueRemoveButton(interaction);
+                        return;
+                    }
                     if (customId.startsWith('html_action:')) {
                         await handleHtmlActionButton(interaction);
                         return;

package/dist/kimaki-opencode-plugin.js

@@ -11,6 +11,7 @@
 // - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
 // - file-edit-log: record edit/write/apply_patch files per session
 // - bash-tool-schema-plugin: add description and hasSideEffect to bash
+// - task-id-plugin: drop invalid model-generated task resume IDs
 export { ipcToolsPlugin } from './ipc-tools-plugin.js';
 export { contextAwarenessPlugin } from './context-awareness-plugin.js';
 export { memoryOverviewPlugin } from './memory-overview-plugin.js';
@@ -29,3 +30,4 @@ export { injectionGuardInternal as injectionGuard } from 'opencode-injection-gua
 export { kimakiWorkspaceAdaptorPlugin } from './kimaki-workspace-adaptor.js';
 export { fileEditTrackerPlugin } from './file-edit-log.js';
 export { bashToolSchemaPlugin } from './bash-tool-schema-plugin.js';
+export { taskIdPlugin } from './task-id-plugin.js';

package/dist/kimaki-opencode-plugin.test.js

@@ -1,5 +1,6 @@
 import { test, expect, describe } from 'vitest';
 import { condenseMemoryMd } from './condense-memory.js';
+import { sanitizeTaskArguments } from './task-id-plugin.js';
 describe('condenseMemoryMd', () => {
     test('multiple headings with body content', () => {
         const content = [
@@ -96,3 +97,30 @@ describe('condenseMemoryMd', () => {
     `);
     });
 });
+describe('sanitizeTaskArguments', () => {
+    test('removes a model-invented UUID task_id', () => {
+        const args = {
+            description: 'inspect repository',
+            prompt: 'Find the implementation',
+            subagent_type: 'explore',
+            task_id: 'ff120f9f-a28d-4d29-b691-b3a5f770759b',
+        };
+        sanitizeTaskArguments(args);
+        expect(args).toMatchInlineSnapshot(`
+      {
+        "description": "inspect repository",
+        "prompt": "Find the implementation",
+        "subagent_type": "explore",
+      }
+    `);
+    });
+    test('keeps an OpenCode session task_id for resume', () => {
+        const args = { task_id: 'ses_child' };
+        sanitizeTaskArguments(args);
+        expect(args).toMatchInlineSnapshot(`
+      {
+        "task_id": "ses_child",
+      }
+    `);
+    });
+});

package/dist/list-channel-threads.js

@@ -0,0 +1,163 @@
+import { ChannelType, Routes } from 'discord.js';
+import * as errore from 'errore';
+import { DiscordApiError } from './errors.js';
+import { isThreadChannelType } from './discord-utils.js';
+export const DISCORD_THREAD_LIST_PAGE_SIZE = 100;
+const ARCHIVED_THREAD_FETCH_LIMIT = 200;
+class DiscordThreadListError extends errore.createTaggedError({
+    name: 'DiscordThreadListError',
+    message: 'Failed to list Discord threads for channel $channelId',
+}) {
+}
+export function parseDiscordThreadPayload({ payload, parentId, guildId, }) {
+    if (!payload.id || !isThreadChannelType(payload.type ?? -1)) {
+        return null;
+    }
+    if (payload.parent_id && payload.parent_id !== parentId) {
+        return null;
+    }
+    const archived = Boolean(payload.thread_metadata?.archived);
+    return {
+        id: payload.id,
+        name: payload.name || payload.id,
+        parentId,
+        guildId: payload.guild_id || guildId,
+        archived,
+        archiveState: archived ? 'archived' : 'active',
+        lastMessageId: payload.last_message_id ?? null,
+    };
+}
+export function mergeDiscordChannelThreads({ threads, }) {
+    const byId = new Map();
+    for (const thread of threads) {
+        byId.set(thread.id, thread);
+    }
+    return [...byId.values()].sort((left, right) => {
+        if (left.archived !== right.archived) {
+            return left.archived ? 1 : -1;
+        }
+        const leftMessage = left.lastMessageId ?? '';
+        const rightMessage = right.lastMessageId ?? '';
+        if (leftMessage !== rightMessage) {
+            return rightMessage.localeCompare(leftMessage);
+        }
+        return left.name.localeCompare(right.name);
+    });
+}
+function parseThreadListPayload({ payload, parentId, guildId, }) {
+    if (!payload || typeof payload !== 'object') {
+        return { threads: [], hasMore: false };
+    }
+    const list = payload;
+    const threads = (list.threads ?? []).flatMap((thread) => {
+        const parsed = parseDiscordThreadPayload({
+            payload: thread,
+            parentId,
+            guildId,
+        });
+        return parsed ? [parsed] : [];
+    });
+    return {
+        threads,
+        hasMore: Boolean(list.has_more),
+    };
+}
+async function fetchDiscordJson({ rest, route, query, }) {
+    const result = await rest
+        .get(route, query ? { query } : undefined)
+        .catch((cause) => {
+        return new DiscordApiError({
+            status: String(Reflect.get(cause, 'status') ?? 'unknown'),
+            body: cause instanceof Error ? cause.message : String(cause),
+            cause,
+        });
+    });
+    return result;
+}
+async function listArchivedPublicThreads({ rest, channelId, guildId, }) {
+    const threads = [];
+    let before;
+    while (threads.length < ARCHIVED_THREAD_FETCH_LIMIT) {
+        const query = new URLSearchParams({
+            limit: String(DISCORD_THREAD_LIST_PAGE_SIZE),
+        });
+        if (before) {
+            query.set('before', before);
+        }
+        const payload = await fetchDiscordJson({
+            rest,
+            route: Routes.channelThreads(channelId, 'public'),
+            query,
+        });
+        if (payload instanceof DiscordApiError) {
+            return payload;
+        }
+        const page = parseThreadListPayload({
+            payload,
+            parentId: channelId,
+            guildId,
+        });
+        threads.push(...page.threads);
+        const lastThread = page.threads.at(-1);
+        if (!page.hasMore || !lastThread) {
+            break;
+        }
+        before = lastThread.id;
+    }
+    return threads;
+}
+export async function listDiscordChannelThreads({ rest, channelId, }) {
+    const channelPayload = await fetchDiscordJson({
+        rest,
+        route: Routes.channel(channelId),
+    });
+    if (channelPayload instanceof DiscordApiError) {
+        return { ok: false, error: channelPayload };
+    }
+    const channel = (channelPayload ?? {});
+    if (channel.type !== ChannelType.GuildText) {
+        return {
+            ok: false,
+            error: new DiscordThreadListError({
+                channelId,
+                cause: new Error('Channel is not a guild text channel'),
+            }),
+        };
+    }
+    const guildId = channel.guild_id;
+    if (!guildId) {
+        return {
+            ok: false,
+            error: new DiscordThreadListError({
+                channelId,
+                cause: new Error('Channel has no guild ID'),
+            }),
+        };
+    }
+    const activePayload = await fetchDiscordJson({
+        rest,
+        route: Routes.guildActiveThreads(guildId),
+    });
+    if (activePayload instanceof DiscordApiError) {
+        return { ok: false, error: activePayload };
+    }
+    const activeThreads = parseThreadListPayload({
+        payload: activePayload,
+        parentId: channelId,
+        guildId,
+    }).threads;
+    const archivedThreads = await listArchivedPublicThreads({
+        rest,
+        channelId,
+        guildId,
+    });
+    if (archivedThreads instanceof DiscordApiError) {
+        return { ok: false, error: archivedThreads };
+    }
+    return {
+        ok: true,
+        threads: mergeDiscordChannelThreads({
+            threads: [...activeThreads, ...archivedThreads],
+        }),
+    };
+}

package/dist/list-channel-threads.test.js

@@ -0,0 +1,80 @@
+import { ChannelType } from 'discord.js';
+import { describe, expect, test } from 'vitest';
+import { mergeDiscordChannelThreads, parseDiscordThreadPayload, } from './list-channel-threads.js';
+describe('list-channel-threads', () => {
+    test('parses public threads and skips other channel types', () => {
+        const parsed = parseDiscordThreadPayload({
+            payload: {
+                id: 'thread-1',
+                name: 'Fix auth timeout',
+                type: ChannelType.PublicThread,
+                parent_id: 'channel-1',
+                guild_id: 'guild-1',
+                last_message_id: 'msg-9',
+                thread_metadata: { archived: false },
+            },
+            parentId: 'channel-1',
+            guildId: 'guild-1',
+        });
+        expect(parsed).toMatchInlineSnapshot(`
+      {
+        "archiveState": "active",
+        "archived": false,
+        "guildId": "guild-1",
+        "id": "thread-1",
+        "lastMessageId": "msg-9",
+        "name": "Fix auth timeout",
+        "parentId": "channel-1",
+      }
+    `);
+        expect(parseDiscordThreadPayload({
+            payload: {
+                id: 'not-a-thread',
+                name: 'website',
+                type: ChannelType.GuildText,
+                parent_id: 'category-1',
+            },
+            parentId: 'channel-1',
+            guildId: 'guild-1',
+        })).toBe(null);
+    });
+    test('keeps active threads first and drops duplicate ids', () => {
+        const merged = mergeDiscordChannelThreads({
+            threads: [
+                {
+                    id: 'thread-old',
+                    name: 'Old work',
+                    parentId: 'channel-1',
+                    guildId: 'guild-1',
+                    archived: true,
+                    archiveState: 'archived',
+                    lastMessageId: '2',
+                },
+                {
+                    id: 'thread-new',
+                    name: 'New work',
+                    parentId: 'channel-1',
+                    guildId: 'guild-1',
+                    archived: false,
+                    archiveState: 'active',
+                    lastMessageId: '1',
+                },
+                {
+                    id: 'thread-new',
+                    name: 'New work duplicate',
+                    parentId: 'channel-1',
+                    guildId: 'guild-1',
+                    archived: false,
+                    archiveState: 'active',
+                    lastMessageId: '9',
+                },
+            ],
+        });
+        expect(merged.map((thread) => thread.id)).toMatchInlineSnapshot(`
+      [
+        "thread-new",
+        "thread-old",
+      ]
+    `);
+    });
+});