kimaki 0.26.0 → 0.27.0

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,13 @@ 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);
     }
+    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,171 @@ 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('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)

package/dist/discord-bot.js

@@ -8,7 +8,7 @@
 // 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, getThreadWorktreeOrWorkspace, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, cancelAllPendingIpcRequests, deleteChannelDirectoryById, createPendingWorkspace, setWorkspaceReady, } from './database.js';
+import { initDatabase, closeDatabase, getThreadWorktreeOrWorkspace, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, cancelAllPendingIpcRequests, consumeSessionSleepWake, 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';
@@ -277,8 +277,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         discordLogger.warn(`[GATEWAY] Shard ${shardId} reconnecting: ${parts.join(', ')}`);
         if (state.attempts >= MAX_RECONNECT_ATTEMPTS) {
             discordLogger.error(`[GATEWAY] Shard ${shardId} exceeded ${MAX_RECONNECT_ATTEMPTS} reconnect attempts, self-restarting`);
-            // Self-restart: cleanup, then exit non-zero so the bin.ts wrapper
-            // restarts us. Without the wrapper this exits after logging a warning.
+            // Self-restart: cleanup, then SIGKILL so the bin.ts wrapper
+            // restarts us. Without the wrapper this dies after logging a warning.
             void selfRestart('gateway-reconnect-limit');
         }
     });
@@ -613,6 +613,21 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     }
                     void cancelPendingFileUpload(thread.id);
                 }
+                // A sleep wake only becomes a turn if it can still claim its own row.
+                // The claim fails when the user cancelled the sleep while the wake was
+                // being posted, so the superseded wake is dropped instead of starting a
+                // turn the user already replaced. Cancellation for every other kind of
+                // message happens inside runtime.enqueueIncoming().
+                const isSleepWake = Boolean(promptMarker?.sleepWake);
+                if (isSleepWake) {
+                    const claimedWake = promptMarker?.sleepId
+                        ? await consumeSessionSleepWake({ deliveryId: promptMarker.sleepId })
+                        : false;
+                    if (!claimedWake) {
+                        discordLogger.log(`[SLEEP] ignoring superseded wake in thread ${thread.id}`);
+                        return;
+                    }
+                }
                 // Expensive pre-processing (voice transcription, context fetch,
                 // attachment download) runs inside the runtime's serialized
                 // preprocess chain, preserving Discord arrival order without
@@ -631,6 +646,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     permissions: cliInjectedPermissions,
                     injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
                     parentSessionId: cliInjectedParentSessionId,
+                    isSleepWake: isSleepWake || undefined,
                     noReply: isLeadingMentionToOtherUser || undefined,
                     sessionStartSource: sessionStartSource
                         ? {
@@ -771,15 +787,10 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         rest: discordClient.rest,
                     });
                 }
-                const sessionDirectory = await (async () => {
-                    if (!worktreePromise) {
-                        return projectDirectory;
-                    }
-                    const result = await worktreePromise;
-                    if (result instanceof Error)
-                        return projectDirectory;
-                    return result;
-                })();
+                const worktreeResult = worktreePromise ? await worktreePromise : projectDirectory;
+                if (worktreeResult instanceof Error)
+                    return;
+                const sessionDirectory = worktreeResult;
                 const channelRuntime = getOrCreateRuntime({
                     threadId: thread.id,
                     thread,
@@ -1055,18 +1066,10 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             }
             discordLogger.log(`[BOT_SESSION] Starting session for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}..."`);
             const botThreadStartSource = parseSessionStartSourceFromMarker(marker);
-            const sessionDirectory = await (async () => {
-                if (cwdDirectory) {
-                    return cwdDirectory;
-                }
-                if (!worktreePromise) {
-                    return projectDirectory;
-                }
-                const result = await worktreePromise;
-                if (result instanceof Error)
-                    return projectDirectory;
-                return result;
-            })();
+            const worktreeResult = worktreePromise ? await worktreePromise : undefined;
+            if (worktreeResult instanceof Error)
+                return;
+            const sessionDirectory = cwdDirectory ?? worktreeResult ?? projectDirectory;
             const runtime = getOrCreateRuntime({
                 threadId: thread.id,
                 thread,
@@ -1244,13 +1247,11 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             discordLogger.error('Failed to write heap snapshot:', e instanceof Error ? e.message : String(e));
         });
     });
-    // Self-restart: exit with code 1 so the bin.ts wrapper restarts us with
-    // exponential backoff and crash-loop detection. When running without the
-    // wrapper (e.g. `tsx src/cli.ts`), the process just exits and the user
-    // sees the non-zero exit code — they should use `tsx src/bin.ts` instead
-    // for auto-restart support. The previous detached-spawn fallback was
-    // unreliable: process.exit(0) could kill the child before it started,
-    // there was no backoff between restarts, and spawn failures were silent.
+    // Self-restart: die so the bin.ts wrapper restarts us with exponential
+    // backoff and crash-loop detection. process.exit() can hang joining native
+    // worker threads after Discord gateway failures, so SIGKILL instead.
+    // When running without the wrapper (e.g. `tsx src/cli.ts`), the process
+    // just dies — use `tsx src/bin.ts` for auto-restart support.
     let selfRestarting = false;
     async function selfRestart(reason) {
         if (selfRestarting) {
@@ -1259,6 +1260,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         }
         selfRestarting = true;
         discordLogger.log(`Self-restarting (reason: ${reason})...`);
+        setTimeout(() => process.kill(process.pid, 'SIGKILL'), 15_000);
         try {
             await handleShutdown(reason, { skipExit: true });
         }
@@ -1268,7 +1270,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         if (!process.env.__KIMAKI_CHILD) {
             discordLogger.warn('No restart wrapper detected. Run via `tsx src/bin.ts` (dev) or `kimaki` (npm) for auto-restart on crash.');
         }
-        process.exit(1);
+        process.kill(process.pid, 'SIGKILL');
     }
     process.on('SIGUSR2', () => {
         discordLogger.log('Received SIGUSR2, restarting after cleanup...');

package/dist/discord-command-registration.js

@@ -98,7 +98,15 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON(),
         new SlashCommandBuilder()
             .setName('merge-worktree')
-            .setDescription(truncateCommandDescription('Squash-merge worktree into default branch. Aborts if main has uncommitted changes.'))
+            .setDescription(truncateCommandDescription('Merge worktree commits into the default branch'))
+            .addStringOption((option) => {
+            option
+                .setName('strategy')
+                .setDescription(truncateCommandDescription('How to merge commits (default: keep commits)'))
+                .setRequired(false)
+                .addChoices({ name: 'Keep commits (rebase)', value: 'rebase' }, { name: 'Squash into one commit', value: 'squash' });
+            return option;
+        })
             .addStringOption((option) => {
             option
                 .setName('target-branch')

package/dist/discord-utils.js

@@ -168,11 +168,6 @@ export async function archiveThread({ rest, threadId, parentChannelId, sessionId
         if (updateResult instanceof Error) {
             discordLogger.warn(`[archive-thread] ${updateResult.message}`);
         }
-        const abortResult = await client.session.abort({ sessionID: sessionId })
-            .catch((e) => new Error('Failed to abort session', { cause: e }));
-        if (abortResult instanceof Error) {
-            discordLogger.warn(`[archive-thread] ${abortResult.message}`);
-        }
     }
     if (archiveDelay > 0) {
         await new Promise((resolve) => {
@@ -185,6 +180,19 @@ export async function archiveThread({ rest, threadId, parentChannelId, sessionId
         body: { archived: true },
     });
 }
+export const DISCORD_THREAD_RENAME_TIMEOUT_MS = 3000;
+// Discord rename can hang on the 3rd call (~2 per 10 min). Race so it never blocks.
+export async function raceDiscordRename({ rename, timeoutMs = DISCORD_THREAD_RENAME_TIMEOUT_MS, }) {
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    return Promise.race([
+        rename,
+        new Promise((resolve) => {
+            timeoutSignal.addEventListener('abort', () => {
+                resolve('timeout');
+            });
+        }),
+    ]);
+}
 /**
  * Add a user as a thread member so the thread shows up in their Discord left
  * sidebar. Discord only lists threads you are a member of, so a scheduled

package/dist/discord-utils.test.js

@@ -1,6 +1,6 @@
 import { PermissionsBitField } from 'discord.js';
 import { afterEach, describe, expect, test } from 'vitest';
-import { hasKimakiAdminPermission, hasKimakiBotPermission, resolveGuildMessageMember, splitMarkdownForDiscord, } from './discord-utils.js';
+import { hasKimakiAdminPermission, hasKimakiBotPermission, raceDiscordRename, resolveGuildMessageMember, splitMarkdownForDiscord, } from './discord-utils.js';
 import { store } from './store.js';
 describe('splitMarkdownForDiscord', () => {
     test('never returns chunks over the max length with code fences', () => {
@@ -248,3 +248,19 @@ describe('resolveGuildMessageMember', () => {
         await expect(resolveGuildMessageMember(message)).resolves.toBe(null);
     });
 });
+describe('raceDiscordRename', () => {
+    test('returns timeout when rename hangs', async () => {
+        const result = await raceDiscordRename({
+            rename: new Promise(() => { }),
+            timeoutMs: 20,
+        });
+        expect(result).toBe('timeout');
+    });
+    test('returns rename result when it finishes first', async () => {
+        const result = await raceDiscordRename({
+            rename: Promise.resolve('ok'),
+            timeoutMs: 1000,
+        });
+        expect(result).toBe('ok');
+    });
+});

package/dist/errors.js

@@ -109,6 +109,11 @@ export class OpenCodeSdkError extends errore.createTaggedError({
     message: 'OpenCode SDK call failed: $operation',
 }) {
 }
+export class InvalidModelError extends errore.createTaggedError({
+    name: 'InvalidModelError',
+    message: 'Invalid model "$model": $reason',
+}) {
+}
 export class FilesystemOperationError extends errore.createTaggedError({
     name: 'FilesystemOperationError',
     message: 'Filesystem operation failed: $operation',

package/dist/exec-async.js

@@ -1,23 +1,35 @@
-import { exec } from 'node:child_process';
+import { exec, execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 const DEFAULT_EXEC_TIMEOUT_MS = 10_000;
 const _execAsync = promisify(exec);
+const _execFileAsync = promisify(execFile);
 export function execAsync(command, options) {
     const timeoutMs = options?.timeout || DEFAULT_EXEC_TIMEOUT_MS;
-    const execPromise = _execAsync(command, options);
+    const childPromise = typeof command === 'string'
+        ? _execAsync(command, options)
+        : _execFileAsync(command.command, command.args, options);
+    const execPromise = childPromise.then(({ stdout, stderr }) => {
+        return {
+            stdout: typeof stdout === 'string' ? stdout : stdout.toString(),
+            stderr: typeof stderr === 'string' ? stderr : stderr.toString(),
+        };
+    });
+    const commandLabel = typeof command === 'string'
+        ? command
+        : [command.command, ...command.args].join(' ');
     let timer;
     const timeoutPromise = new Promise((_, reject) => {
         timer = setTimeout(() => {
-            const pid = execPromise.child?.pid;
+            const pid = childPromise.child?.pid;
             if (pid) {
                 try {
                     process.kill(-pid, 'SIGTERM');
                 }
                 catch {
-                    execPromise.child?.kill('SIGTERM');
+                    childPromise.child?.kill('SIGTERM');
                 }
             }
-            reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`));
+            reject(new Error(`Command timed out after ${timeoutMs}ms: ${commandLabel}`));
         }, timeoutMs);
     });
     return Promise.race([execPromise, timeoutPromise]).finally(() => {

package/dist/external-directory-permissions.e2e.test.js

@@ -68,14 +68,14 @@ describe('external directory permissions', () => {
       ⬥ reading external directory
       ┣ read *probe.txt*
       ⬥ external-directory-probe-done
-      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
       --- from: user (external-directory-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER followup
       --- from: assistant (TestBot)
       ⬥ reading external directory
       ┣ read *probe.txt*
       ⬥ external-directory-probe-done
-      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
     `);
         expect(text).not.toContain('Permission Required');
     });