kimaki 0.17.1 → 0.18.0

package/dist/commands/new-worktree.js

@@ -4,11 +4,11 @@
 import { ChannelType, REST, } from 'discord.js';
 import fs from 'node:fs';
 import { OpenCodeSdkError } from '../errors.js';
-import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadSession, setThreadSession, } from '../database.js';
+import { createPendingWorkspace, setWorkspaceReady, setWorkspaceError, getChannelDirectory, getThreadSession, setThreadSession, } from '../database.js';
 import { SILENT_MESSAGE_FLAGS, reactToThread, resolveProjectDirectoryFromAutocomplete, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
-import { createWorktreeWithSubmodules, execAsync, listBranchesByLastCommit, validateBranchRef, } from '../worktrees.js';
+import { execAsync, listBranchesByLastCommit, validateBranchRef, } from '../worktrees.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { buildSessionPermissions, initializeOpencodeForDirectory, } from '../opencode.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
@@ -139,10 +139,40 @@ async function getProjectDirectoryFromChannel(channel) {
     return channelConfig.directory;
 }
 /**
- * Create worktree and update the status message when done.
- * Handles the full lifecycle: pending DB entry, git creation, DB ready/error,
+ * Try creating a worktree via the OpenCode workspace SDK.
+ * Returns the workspace directory on success, or an Error if the workspace
+ * feature is not available or the creation fails. Callers fall back to the
+ * direct git path on Error.
+ */
+async function tryWorkspaceCreate({ threadId, worktreeName, projectDirectory, baseBranch, }) {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error)
+        return getClient;
+    const client = getClient();
+    const response = await client.experimental.workspace.create({
+        directory: projectDirectory,
+        type: 'kimaki-worktree',
+        branch: worktreeName,
+        extra: baseBranch ? { baseBranch } : null,
+    }).catch((e) => new OpenCodeSdkError({ operation: 'workspace.create', cause: e }));
+    if (response instanceof Error)
+        return response;
+    if (response.error) {
+        return new Error(`Workspace creation failed: ${JSON.stringify(response.error)}`);
+    }
+    const workspace = response.data;
+    if (!workspace?.directory) {
+        return new Error('Workspace SDK returned no directory');
+    }
+    return { directory: workspace.directory, workspaceId: workspace.id };
+}
+/**
+ * Create worktree via the OpenCode workspace SDK and update the status message.
+ * Handles the full lifecycle: pending DB entry, SDK creation, DB ready/error,
  * tree emoji reaction, and editing the status message.
  *
+ * Uses thread_workspaces table exclusively (no legacy thread_worktrees).
+ *
  * starterMessage is optional — if omitted, status edits are skipped (creation
  * still proceeds). This keeps worktree creation independent of Discord message
  * delivery, so a transient send failure never silently skips the worktree.
@@ -163,33 +193,32 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
             })
                 .catch(() => { });
         };
-        // DB pending entry must complete before git creation so error paths
-        // (setWorktreeError) can find the row reliably
-        await createPendingWorktree({
+        // Write pending row BEFORE workspace creation so restarts/follow-up
+        // messages can see the in-progress state.
+        await createPendingWorkspace({
             threadId: thread.id,
-            worktreeName,
+            workspaceType: 'kimaki-worktree',
+            workspaceName: worktreeName,
             projectDirectory,
         });
-        const worktreeResult = await createWorktreeWithSubmodules({
-            directory: projectDirectory,
-            name: worktreeName,
+        const workspaceResult = await tryWorkspaceCreate({
+            threadId: thread.id,
+            worktreeName,
+            projectDirectory,
             baseBranch,
-            onProgress: (phase) => {
-                editStatus(`🌳 **Worktree: ${worktreeName}**\n${phase}`);
-            },
         });
-        if (worktreeResult instanceof Error) {
-            const errorMsg = worktreeResult.message;
-            logger.error('[WORKTREE] Creation failed:', worktreeResult);
-            await setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
+        if (workspaceResult instanceof Error) {
+            const errorMsg = workspaceResult.message;
+            logger.error('[WORKTREE] Workspace creation failed:', workspaceResult);
+            await setWorkspaceError({ threadId: thread.id, errorMessage: errorMsg });
             editStatus(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
             await editChain;
-            return worktreeResult;
+            return workspaceResult;
         }
-        // DB ready update is critical; reaction is best-effort
-        await setWorktreeReady({
+        await setWorkspaceReady({
             threadId: thread.id,
-            worktreeDirectory: worktreeResult.directory,
+            workspaceId: workspaceResult.workspaceId,
+            workspaceDirectory: workspaceResult.directory,
         });
         void reactToThread({
             rest,
@@ -198,10 +227,11 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
             emoji: '🌳',
         }).catch(() => { });
         editStatus(`🌳 **Worktree: ${worktreeName}**\n` +
-            `📁 \`${worktreeResult.directory}\`\n` +
-            `🌿 Branch: \`${worktreeResult.branch}\``);
+            `📁 \`${workspaceResult.directory}\`\n` +
+            `🌿 Branch: \`${worktreeName}\``);
         await editChain;
-        return worktreeResult.directory;
+        logger.log(`[WORKTREE] Created via workspace SDK: ${workspaceResult.directory}`);
+        return workspaceResult.directory;
     })().catch((e) => {
         logger.error('[WORKTREE] Unexpected error in createWorktreeInBackground:', e);
         return new Error(`Worktree creation failed: ${e instanceof Error ? e.message : String(e)}`, { cause: e });

package/dist/commands/worktrees.js

@@ -5,14 +5,15 @@
 // Renders a markdown table that the CV2 pipeline auto-formats for Discord,
 // including HTML-backed action buttons for deletable worktrees.
 import { ButtonInteraction, ChatInputCommandInteraction, ChannelType, ComponentType, MessageFlags, } from 'discord.js';
-import { deleteThreadWorktree, } from '../database.js';
+import { deleteThreadWorkspace, } from '../database.js';
 import { getDb } from '../db.js';
 import { splitTablesFromMarkdown, truncateComponents } from '../format-tables.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
 import * as errore from 'errore';
 import crypto from 'node:crypto';
-import { GitCommandError } from '../errors.js';
+import { GitCommandError, OpenCodeSdkError } from '../errors.js';
 import { resolveWorkingDirectory } from '../discord-utils.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
 import { deleteWorktree, git, getDefaultBranch, listGitWorktrees, } from '../worktrees.js';
 import path from 'node:path';
 // Extracts the git stderr from a deleteWorktree error via errore.findCause.
@@ -144,11 +145,7 @@ function buildActionCell({ row, gitStatus, }) {
     if (!canDeleteWorktree({ row, gitStatus })) {
         return '-';
     }
-    return buildDeleteButtonHtml({
-        buttonId: `del-wt-${worktreeButtonKey(row.directory)}`,
-    });
-}
-function buildDeleteButtonHtml({ buttonId, }) {
+    const buttonId = `del-wt-${worktreeButtonKey(row.directory)}`;
     return `<button id="${buttonId}" variant="secondary">Delete</button>`;
 }
 function canDeleteWorktree({ row, gitStatus, }) {
@@ -198,21 +195,24 @@ async function resolveGitStatuses({ rows, projectDirectory, timeout, }) {
 // in the git list (pending/error) are appended at the end.
 async function buildWorktreeRows({ projectDirectory, gitWorktrees, }) {
     const db = await getDb();
-    const dbWorktrees = await db.query.thread_worktrees.findMany({
+    const dbWorkspaces = await db.query.thread_workspaces.findMany({
         where: { project_directory: projectDirectory },
     });
-    // Index DB worktrees by directory for fast lookup
+    const toDate = (v) => {
+        if (!v)
+            return null;
+        return v instanceof Date ? v : new Date(v);
+    };
+    // Index by directory for fast lookup
     const dbByDirectory = new Map();
-    for (const dbWt of dbWorktrees) {
-        if (dbWt.worktree_directory) {
-            dbByDirectory.set(dbWt.worktree_directory, dbWt);
+    for (const ws of dbWorkspaces) {
+        if (ws.workspace_directory) {
+            dbByDirectory.set(ws.workspace_directory, ws);
         }
     }
     // Track which DB rows got matched so we can append unmatched ones
     const matchedDbThreadIds = new Set();
     // Build rows from git worktrees (the source of truth for on-disk state).
-    // Use real DB status when available — a git-visible worktree whose DB row
-    // is still 'pending' means setup hasn't finished (race window).
     const gitRows = gitWorktrees.map((gw) => {
         const dbMatch = dbByDirectory.get(gw.directory);
         if (dbMatch) {
@@ -224,15 +224,12 @@ async function buildWorktreeRows({ projectDirectory, gitWorktrees, }) {
         });
         const name = gw.branch ?? path.basename(gw.directory);
         const dbStatus = (() => {
-            if (!dbMatch) {
+            if (!dbMatch)
                 return 'ready';
-            }
-            if (dbMatch.status === 'error') {
+            if (dbMatch.status === 'error')
                 return 'error';
-            }
-            if (dbMatch.status === 'pending') {
+            if (dbMatch.status === 'pending')
                 return 'pending';
-            }
             return 'ready';
         })();
         return {
@@ -240,48 +237,33 @@ async function buildWorktreeRows({ projectDirectory, gitWorktrees, }) {
             branch: gw.branch,
             name,
             threadId: dbMatch?.thread_id ?? null,
-            guildId: null, // filled in by caller
-            createdAt: dbMatch?.created_at ?? null,
+            guildId: null,
+            createdAt: toDate(dbMatch?.created_at),
             source,
+            workspaceId: dbMatch?.workspace_id ?? null,
             dbStatus,
             locked: gw.locked,
             prunable: gw.prunable,
         };
     });
-    // Append DB-only worktrees (pending/error/stale — not visible to git).
-    // Preserve actual DB status so stale 'ready' rows show as 'ready' (missing).
-    const dbOnlyRows = dbWorktrees
-        .filter((dbWt) => {
-        return !matchedDbThreadIds.has(dbWt.thread_id);
-    })
-        .map((dbWt) => {
-        const dbStatus = (() => {
-            if (dbWt.status === 'error') {
-                return 'error';
-            }
-            if (dbWt.status === 'pending') {
-                return 'pending';
-            }
-            return 'ready';
-        })();
-        return {
-            directory: dbWt.worktree_directory ?? dbWt.project_directory,
-            branch: null,
-            name: dbWt.worktree_name,
-            threadId: dbWt.thread_id,
-            guildId: null,
-            createdAt: dbWt.created_at,
-            source: 'kimaki',
-            dbStatus,
-            locked: false,
-            prunable: false,
-        };
-    });
+    // Append DB-only workspaces (pending/error/stale — not visible to git).
+    const dbOnlyRows = dbWorkspaces
+        .filter((ws) => !matchedDbThreadIds.has(ws.thread_id))
+        .map((ws) => ({
+        directory: ws.workspace_directory ?? ws.project_directory,
+        branch: null,
+        name: ws.workspace_name,
+        threadId: ws.thread_id,
+        guildId: null,
+        createdAt: toDate(ws.created_at),
+        source: 'kimaki',
+        workspaceId: ws.workspace_id,
+        dbStatus: ws.status === 'error' ? 'error' : ws.status === 'pending' ? 'pending' : 'ready',
+        locked: false,
+        prunable: false,
+    }));
     return [...gitRows, ...dbOnlyRows];
 }
-function getWorktreesActionOwnerKey({ userId, channelId, }) {
-    return `worktrees:${userId}:${channelId}`;
-}
 function isProjectChannel(channel) {
     if (!channel) {
         return false;
@@ -293,8 +275,19 @@ function isProjectChannel(channel) {
         ChannelType.AnnouncementThread,
     ].includes(channel.type);
 }
+function resolveWorktreesWorkingDirectory(channel) {
+    switch (channel.type) {
+        case ChannelType.GuildText:
+        case ChannelType.PublicThread:
+        case ChannelType.PrivateThread:
+        case ChannelType.AnnouncementThread:
+            return resolveWorkingDirectory({ channel });
+        default:
+            return undefined;
+    }
+}
 async function renderWorktreesReply({ guildId, userId, channelId, projectDirectory, notice, editReply, }) {
-    const ownerKey = getWorktreesActionOwnerKey({ userId, channelId });
+    const ownerKey = `worktrees:${userId}:${channelId}`;
     cancelHtmlActionsForOwner(ownerKey);
     const gitWorktrees = await listGitWorktrees({
         projectDirectory,
@@ -405,14 +398,17 @@ async function handleDeleteWorktreeAction({ interaction, row, projectDirectory,
         });
         return;
     }
-    // Pass branch name for branch cleanup. Empty string for detached HEAD
-    // worktrees so deleteWorktree skips the `git branch -d` step.
+    // SDK-created workspaces must be removed through OpenCode so its workspace
+    // table stays in sync. Legacy/manual worktrees have no workspace_id, so they
+    // still use the direct git cleanup path.
     const displayName = row.branch ?? row.name;
-    const deleteResult = await deleteWorktree({
-        projectDirectory,
-        worktreeDirectory: row.directory,
-        worktreeName: row.branch ?? '',
-    });
+    const deleteResult = row.workspaceId
+        ? await deleteWorkspace({ projectDirectory, workspaceId: row.workspaceId })
+        : await deleteWorktree({
+            projectDirectory,
+            worktreeDirectory: row.directory,
+            worktreeName: row.branch ?? '',
+        });
     if (deleteResult instanceof Error) {
         const gitStderr = extractGitStderr(deleteResult);
         const detail = gitStderr
@@ -428,9 +424,8 @@ async function handleDeleteWorktreeAction({ interaction, row, projectDirectory,
         });
         return;
     }
-    // Clean up DB row if this was a kimaki-tracked worktree
     if (row.threadId) {
-        await deleteThreadWorktree(row.threadId);
+        await deleteThreadWorkspace(row.threadId);
     }
     await renderWorktreesReply({
         guildId,
@@ -443,6 +438,19 @@ async function handleDeleteWorktreeAction({ interaction, row, projectDirectory,
         },
     });
 }
+async function deleteWorkspace({ projectDirectory, workspaceId, }) {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error)
+        return getClient;
+    const response = await getClient().experimental.workspace.remove({
+        id: workspaceId,
+        directory: projectDirectory,
+    }).catch((e) => new OpenCodeSdkError({ operation: 'workspace.remove', cause: e }));
+    if (response instanceof Error)
+        return response;
+    if (response.error)
+        return new Error(`Workspace removal failed: ${JSON.stringify(response.error)}`);
+}
 export async function handleWorktreesCommand({ command, }) {
     const channel = command.channel;
     const guildId = command.guildId;
@@ -460,9 +468,7 @@ export async function handleWorktreesCommand({ command, }) {
         });
         return;
     }
-    const resolved = await resolveWorkingDirectory({
-        channel: channel,
-    });
+    const resolved = await resolveWorktreesWorkingDirectory(channel);
     if (!resolved) {
         await command.reply({
             content: 'Could not determine the project folder for this channel.',

package/dist/database.js

@@ -276,6 +276,60 @@ export async function deleteThreadWorktree(threadId) {
     const db = await getDb();
     await db.delete(schema.thread_worktrees).where(orm.eq(schema.thread_worktrees.thread_id, threadId));
 }
+export async function createPendingWorkspace({ threadId, workspaceType, workspaceName, projectDirectory, }) {
+    const db = await getDb();
+    await db.batch([
+        db.insert(schema.thread_sessions)
+            .values({ thread_id: threadId, session_id: '' })
+            .onConflictDoNothing({ target: schema.thread_sessions.thread_id }),
+        db.insert(schema.thread_workspaces)
+            .values({
+            thread_id: threadId,
+            workspace_type: workspaceType,
+            workspace_name: workspaceName,
+            project_directory: projectDirectory,
+            status: 'pending',
+        })
+            .onConflictDoUpdate({
+            target: schema.thread_workspaces.thread_id,
+            set: {
+                workspace_type: workspaceType,
+                workspace_name: workspaceName,
+                project_directory: projectDirectory,
+                status: 'pending',
+                workspace_id: null,
+                workspace_directory: null,
+                error_message: null,
+            },
+        }),
+    ]);
+}
+export async function setWorkspaceReady({ threadId, workspaceId, workspaceDirectory, }) {
+    const db = await getDb();
+    await db.update(schema.thread_workspaces)
+        .set({
+        workspace_directory: workspaceDirectory,
+        workspace_id: workspaceId ?? null,
+        status: 'ready',
+    })
+        .where(orm.eq(schema.thread_workspaces.thread_id, threadId));
+}
+export async function setWorkspaceError({ threadId, errorMessage, }) {
+    const db = await getDb();
+    await db.update(schema.thread_workspaces)
+        .set({ status: 'error', error_message: errorMessage })
+        .where(orm.eq(schema.thread_workspaces.thread_id, threadId));
+}
+export async function getThreadWorkspace(threadId) {
+    const db = await getDb();
+    return await db.query.thread_workspaces.findFirst({ where: { thread_id: threadId } }) ?? undefined;
+}
+export async function deleteThreadWorkspace(threadId) {
+    const db = await getDb();
+    await db.delete(schema.thread_workspaces).where(orm.eq(schema.thread_workspaces.thread_id, threadId));
+}
+/** Alias for getThreadWorkspace — used throughout the codebase. */
+export const getThreadWorktreeOrWorkspace = getThreadWorkspace;
 export async function getChannelVerbosity(channelId) {
     const db = await getDb();
     const row = await db.query.channel_verbosity.findFirst({ where: { channel_id: channelId } });

package/dist/db.js

@@ -142,6 +142,19 @@ async function migrateSchema({ db, client, }) {
     for (const stmt of migrationStatements) {
         await client.execute(stmt).catch(() => undefined);
     }
+    // Migrate legacy thread_worktrees rows into thread_workspaces.
+    // Rows that already exist in thread_workspaces (by thread_id) are skipped.
+    await client.execute(`
+    INSERT OR IGNORE INTO thread_workspaces (
+      thread_id, workspace_type, status, error_message,
+      project_directory, workspace_directory, workspace_name, created_at
+    )
+    SELECT
+      thread_id, 'kimaki-worktree', status, error_message,
+      project_directory, worktree_directory, worktree_name, created_at
+    FROM thread_worktrees
+    WHERE thread_id NOT IN (SELECT thread_id FROM thread_workspaces)
+  `).catch(() => undefined);
     const botRows = await db.query.bot_tokens.findMany({
         columns: {
             app_id: true,

package/dist/db.test.js

@@ -7,7 +7,7 @@ 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, createPendingWorktree, getSessionEventSnapshot, getSessionModel, setSessionModel, } from './database.js';
+import { appendSessionEventsSinceLastTimestamp, createPendingWorkspace, getSessionEventSnapshot, getSessionModel, setSessionModel, } from './database.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { chooseLockPort } from './test-utils.js';
 import { copyCurrentSessionModel } from './commands/model.js';
@@ -78,12 +78,13 @@ describe('getDb', () => {
             }
         }
     });
-    test('createPendingWorktree creates parent and child rows', async () => {
+    test('createPendingWorkspace creates parent and child rows', async () => {
         const db = await getDb();
-        const threadId = `test-worktree-${Date.now()}`;
-        await createPendingWorktree({
+        const threadId = `test-workspace-${Date.now()}`;
+        await createPendingWorkspace({
             threadId,
-            worktreeName: 'regression-worktree',
+            workspaceType: 'kimaki-worktree',
+            workspaceName: 'regression-workspace',
             projectDirectory: '/tmp/regression-project',
         });
         const session = await db.query.thread_sessions.findFirst({
@@ -91,14 +92,14 @@ describe('getDb', () => {
         });
         expect(session).toBeTruthy();
         expect(session?.session_id).toBe('');
-        const worktree = await db.query.thread_worktrees.findFirst({
+        const workspace = await db.query.thread_workspaces.findFirst({
             where: { thread_id: threadId },
         });
-        expect(worktree).toBeTruthy();
-        expect(worktree?.worktree_name).toBe('regression-worktree');
-        expect(worktree?.project_directory).toBe('/tmp/regression-project');
-        expect(worktree?.status).toBe('pending');
-        await db.delete(schema.thread_worktrees).where(orm.eq(schema.thread_worktrees.thread_id, threadId));
+        expect(workspace).toBeTruthy();
+        expect(workspace?.workspace_name).toBe('regression-workspace');
+        expect(workspace?.project_directory).toBe('/tmp/regression-project');
+        expect(workspace?.status).toBe('pending');
+        await db.delete(schema.thread_workspaces).where(orm.eq(schema.thread_workspaces.thread_id, threadId));
         await db.delete(schema.thread_sessions).where(orm.eq(schema.thread_sessions.thread_id, threadId));
     });
     test('copyCurrentSessionModel snapshots source session model to forked session', async () => {

package/dist/discord-bot.js

@@ -1,8 +1,14 @@
 // Core Discord bot module that handles message events and bot lifecycle.
 // Bridges Discord messages to OpenCode sessions, manages voice connections,
 // and orchestrates the main event loop for the Kimaki bot.
+//
+// Shutdown resilience: during self-restart (gateway reconnect limit, SIGUSR2),
+// discord.js can still fire errors from pending async operations (DNS lookups,
+// WebSocket frames) after the client is destroyed. The uncaughtException handler
+// suppresses these when shuttingDown is already set, and we removeAllListeners()
+// before destroying the client to prevent late events from becoming uncaught.
 import { DiscordOperationError } from './errors.js';
-import { initDatabase, closeDatabase, getThreadWorktree, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, cancelAllPendingIpcRequests, deleteChannelDirectoryById, createPendingWorktree, setWorktreeReady, } from './database.js';
+import { initDatabase, closeDatabase, getThreadWorktreeOrWorkspace, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, cancelAllPendingIpcRequests, deleteChannelDirectoryById, createPendingWorkspace, setWorkspaceReady, } from './database.js';
 import { stopOpencodeServer, } from './opencode.js';
 import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js';
 import { resolveSessionWorkingDirectory, git, isGitRepositoryRoot } from './worktrees.js';
@@ -359,6 +365,32 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     }
                 }
             }
+            // Multi-machine routing: check channel ownership before permission
+            // checks so we don't send permission-denial replies in channels owned
+            // by another machine. Resolve the "owning" channel: for threads, check
+            // the parent channel; for text channels, check the channel itself.
+            if (!isCliInjectedPrompt && message.guild) {
+                const channel = message.channel;
+                let owningChannelId;
+                if ([
+                    ChannelType.PublicThread,
+                    ChannelType.PrivateThread,
+                    ChannelType.AnnouncementThread,
+                ].includes(channel.type)) {
+                    const thread = channel;
+                    owningChannelId = thread.parent?.id || thread.parentId || undefined;
+                }
+                else {
+                    owningChannelId = channel.id;
+                }
+                if (owningChannelId) {
+                    const channelConfig = await getChannelDirectory(owningChannelId);
+                    if (!channelConfig) {
+                        voiceLogger.log(`[IGNORED] Channel ${owningChannelId} has no project directory configured`);
+                        return;
+                    }
+                }
+            }
             if (!isCliInjectedPrompt && message.guild) {
                 const member = await resolveGuildMessageMember(message);
                 if (!member) {
@@ -392,7 +424,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 // thread itself (e.g. /new-worktree, /fork, kimaki send). This prevents
                 // the bot from hijacking user-created threads in project channels while
                 // still responding to bot-created threads that may not yet have a session
-                // row with a non-empty session_id (createPendingWorktree sets ''). (GitHub #84)
+                // row with a non-empty session_id (createPendingWorkspace sets ''). (GitHub #84)
                 const hasExistingSession = await getThreadSession(thread.id);
                 const botMentioned = discordClient.user && message.mentions.has(discordClient.user.id);
                 const botCreatedThread = discordClient.user && thread.ownerId === discordClient.user.id;
@@ -416,7 +448,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 // the preprocess chain (messages queue behind the worktree promise).
                 // After a bot restart the runtime is gone, so we must reject messages
                 // for pending worktrees to avoid running in the base directory.
-                const worktreeInfo = await getThreadWorktree(thread.id);
+                // Check both thread_workspaces (new) and thread_worktrees (legacy)
+                const worktreeInfo = await getThreadWorktreeOrWorkspace(thread.id);
                 if (worktreeInfo) {
                     if (worktreeInfo.status === 'pending' && !getRuntime(thread.id)) {
                         await message.reply({
@@ -436,7 +469,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     // The worktree directory is passed via query.directory in prompt/command calls
                     if (worktreeInfo.project_directory) {
                         projectDirectory = worktreeInfo.project_directory;
-                        discordLogger.log(`Using project directory: ${projectDirectory} (worktree: ${worktreeInfo.worktree_directory})`);
+                        discordLogger.log(`Using project directory: ${projectDirectory} (worktree: ${worktreeInfo.workspace_directory})`);
                     }
                 }
                 if (projectDirectory && !fs.existsSync(projectDirectory)) {
@@ -456,8 +489,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     const shellCmd = message.content.slice(1).trim();
                     if (shellCmd) {
                         const shellDir = worktreeInfo?.status === 'ready' &&
-                            worktreeInfo.worktree_directory
-                            ? worktreeInfo.worktree_directory
+                            worktreeInfo.workspace_directory
+                            ? worktreeInfo.workspace_directory
                             : projectDirectory;
                         const loadingReply = await message.reply({
                             content: `Running \`${shellCmd.slice(0, 1900)}\`...`,
@@ -514,8 +547,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 }
                 const resolvedProjectDir = projectDirectory;
                 const sdkDir = worktreeInfo?.status === 'ready' &&
-                    worktreeInfo.worktree_directory
-                    ? worktreeInfo.worktree_directory
+                    worktreeInfo.workspace_directory
+                    ? worktreeInfo.workspace_directory
                     : resolvedProjectDir;
                 const runtime = getOrCreateRuntime({
                     threadId: thread.id,
@@ -895,7 +928,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             }
             // --cwd: reuse an existing project subfolder or worktree directory. Revalidate at bot-time
             // (CLI validated at send-time but the path could become stale).
-            // Only worktree directories are stored in thread_worktrees. Project
+            // Only worktree directories are stored in thread_workspaces. Project
             // subfolders simply become the OpenCode session directory.
             // --cwd: if it matches projectDirectory, ignore silently (already the default).
             let cwdDirectory;
@@ -921,14 +954,15 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     const cwdWorktreeName = branchResult instanceof Error
                         ? path.basename(cwdDirectory)
                         : branchResult;
-                    await createPendingWorktree({
+                    await createPendingWorkspace({
                         threadId: thread.id,
-                        worktreeName: cwdWorktreeName,
+                        workspaceType: 'kimaki-worktree',
+                        workspaceName: cwdWorktreeName,
                         projectDirectory,
                     });
-                    await setWorktreeReady({
+                    await setWorkspaceReady({
                         threadId: thread.id,
-                        worktreeDirectory: cwdDirectory,
+                        workspaceDirectory: cwdDirectory,
                     });
                     // React with tree emoji to mark as worktree thread
                     await reactToThread({
@@ -1048,7 +1082,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             discordLogger.log('Already shutting down, ignoring duplicate signal');
             return;
         }
-        ;
         global.shuttingDown = true;
         try {
             await stopRuntimeIdleSweeper();
@@ -1078,6 +1111,10 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             discordLogger.log('Stopping hrana server...');
             await stopHranaServer();
             discordLogger.log('Destroying Discord client...');
+            // Remove all listeners before destroy to prevent late-arriving shard
+            // errors (from pending DNS lookups, WebSocket frames) from becoming
+            // uncaught exceptions after the client's internal handlers are torn down.
+            discordClient.removeAllListeners();
             void discordClient.destroy();
             discordLogger.log('Cleanup complete.');
             if (!skipExit) {
@@ -1150,6 +1187,14 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         void selfRestart('SIGUSR2');
     });
     process.on('uncaughtException', (error) => {
+        // During self-restart or shutdown, discord.js can still fire errors from
+        // pending async operations (DNS lookups, WebSocket frames) after the client
+        // is destroyed. These are expected and must not interfere with the restart
+        // flow — let the existing selfRestart/handleShutdown finish cleanly.
+        if (selfRestarting || global.shuttingDown) {
+            discordLogger.log('Ignoring uncaught exception during shutdown:', error?.message || String(error));
+            return;
+        }
         discordLogger.error('Uncaught exception:', formatErrorWithStack(error));
         notifyError(error, 'Uncaught exception in bot process');
         void handleShutdown('uncaughtException', { skipExit: true }).catch((shutdownError) => {