kimaki 0.17.1 → 0.19.0

package/dist/commands/merge-worktree.js

@@ -3,7 +3,7 @@
 // Preserves all commits (no squash). On rebase conflicts, asks the AI model
 // in the thread to resolve them.
 import {} from 'discord.js';
-import { getThreadWorktree, getThreadSession, getChannelDirectory, } from '../database.js';
+import { getThreadWorktreeOrWorkspace, getThreadSession, getChannelDirectory, } from '../database.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
 import { mergeWorktree, listBranchesByLastCommit, validateBranchRef } from '../worktrees.js';
@@ -63,20 +63,21 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
         return;
     }
     const thread = channel;
-    const worktreeInfo = await getThreadWorktree(thread.id);
-    if (!worktreeInfo) {
+    // Check both thread_workspaces (new) and thread_worktrees (legacy)
+    const info = await getThreadWorktreeOrWorkspace(thread.id);
+    if (!info) {
         await command.editReply('This thread is not associated with a worktree');
         return;
     }
-    if (worktreeInfo.status !== 'ready' || !worktreeInfo.worktree_directory) {
-        await command.editReply(`Worktree is not ready (status: ${worktreeInfo.status})${worktreeInfo.error_message ? `: ${worktreeInfo.error_message}` : ''}`);
+    if (info.status !== 'ready' || !info.workspace_directory) {
+        await command.editReply(`Worktree is not ready (status: ${info.status})${info.error_message ? `: ${info.error_message}` : ''}`);
         return;
     }
     const rawTargetBranch = command.options.getString('target-branch') || undefined;
     let targetBranch = rawTargetBranch;
     if (targetBranch) {
         const validated = await validateBranchRef({
-            directory: worktreeInfo.project_directory,
+            directory: info.project_directory,
             ref: targetBranch,
         });
         if (validated instanceof Error) {
@@ -86,9 +87,9 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
         targetBranch = validated;
     }
     const result = await mergeWorktree({
-        worktreeDir: worktreeInfo.worktree_directory,
-        mainRepoDir: worktreeInfo.project_directory,
-        worktreeName: worktreeInfo.worktree_name,
+        worktreeDir: info.workspace_directory,
+        mainRepoDir: info.project_directory,
+        worktreeName: info.workspace_name,
         targetBranch,
         onProgress: (msg) => {
             logger.log(`[merge] ${msg}`);
@@ -126,7 +127,7 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
                     '9. Once the rebase is fully complete, tell me so I can run `/merge-worktree` again',
                 ].join('\n'),
                 thread,
-                projectDirectory: worktreeInfo.project_directory,
+                projectDirectory: info.project_directory,
                 command,
                 appId,
             });

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 () => {