kimaki 0.7.0 → 0.8.0

package/dist/agent-model.e2e.test.js

@@ -329,6 +329,7 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: agent-model-check
         --- from: assistant (TestBot)
+        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
@@ -372,6 +373,7 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: system-context-check
         --- from: assistant (TestBot)
+        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         ⬥ system-context-ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
@@ -461,6 +463,7 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: channel-model-check
         --- from: assistant (TestBot)
+        *using deterministic-provider/channel-model-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*"
       `);
@@ -516,6 +519,7 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: variant-check
         --- from: assistant (TestBot)
+        *using deterministic-provider/channel-model-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*"
       `);
@@ -583,6 +587,7 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: first-thread-msg
         --- from: assistant (TestBot)
+        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         --- from: user (agent-model-tester)
@@ -665,6 +670,7 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: default-thread-msg
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (agent-model-tester)
@@ -731,6 +737,7 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: switch-in-thread-msg
         --- from: assistant (TestBot)
+        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         Switched to **plan** agent for this session (was **test-agent**)

package/dist/anthropic-auth-plugin.js

@@ -65,6 +65,9 @@ const CLAUDE_CODE_VERSION = "2.1.75";
 const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
 const OPENCODE_IDENTITY = "You are OpenCode, the best coding agent on the planet.";
 const ANTHROPIC_PROMPT_MARKER = "Skills provide specialized instructions";
+// Subagent prompts don't contain OPENCODE_IDENTITY; opencode appends this
+// line + an <env> block instead. We strip from here to </env> inclusive.
+const SUBAGENT_MODEL_IDENTITY = "You are powered by the model named";
 const CLAUDE_CODE_BETA = "claude-code-20250219";
 const OAUTH_BETA = "oauth-2025-04-20";
 const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
@@ -477,28 +480,59 @@ function toClaudeCodeToolName(name) {
  */
 function sanitizeAnthropicSystemText(text, onError) {
     const startIdx = text.indexOf(OPENCODE_IDENTITY);
-    if (startIdx === -1)
-        return text;
-    // Keep the marker aligned with the current OpenCode Anthropic prompt.
-    const endIdx = text.indexOf(ANTHROPIC_PROMPT_MARKER, startIdx);
-    if (endIdx === -1) {
-        onError?.("sanitizeAnthropicSystemText: could not find Anthropic prompt marker after OpenCode identity");
-        return text;
+    if (startIdx !== -1) {
+        // Main session path: strip from OpenCode identity to the Anthropic prompt marker.
+        // Keep the marker aligned with the current OpenCode Anthropic prompt.
+        const endIdx = text.indexOf(ANTHROPIC_PROMPT_MARKER, startIdx);
+        if (endIdx === -1) {
+            onError?.("sanitizeAnthropicSystemText: could not find Anthropic prompt marker after OpenCode identity");
+            return text;
+        }
+        return replaceBlockWithCompactEnv(text, startIdx, endIdx);
+    }
+    // Subagent path: opencode appends "You are powered by the model named ..."
+    // followed by an <env> block. Strip from that line through </env>.
+    const subagentIdx = text.indexOf(SUBAGENT_MODEL_IDENTITY);
+    if (subagentIdx !== -1) {
+        const envCloseTag = "</env>";
+        const envCloseIdx = text.indexOf(envCloseTag, subagentIdx);
+        if (envCloseIdx === -1) {
+            onError?.("sanitizeAnthropicSystemText: could not find </env> after subagent model identity");
+            return text;
+        }
+        const endIdx = envCloseIdx + envCloseTag.length;
+        // Skip trailing newline so the join is clean
+        const afterEnd = text[endIdx] === "\n" ? endIdx + 1 : endIdx;
+        return replaceBlockWithCompactEnv(text, subagentIdx, afterEnd);
     }
-    // Extract the cwd from the block we're about to strip. OpenCode's system
-    // prompt embeds <environment><cwd>/path</cwd></environment> in the identity
-    // block. We preserve the per-session cwd instead of falling back to
-    // process.cwd() which is the opencode server's cwd and wrong for
-    // multi-session/worktree setups where each session has a different directory.
+    return text;
+}
+// Extract cwd from the block being stripped and replace it with a compact
+// <environment> tag. Shared by both main-session and subagent paths.
+// Source: anomalyco/opencode packages/opencode/src/session/system.ts
+// OpenCode's system prompt format (as of 2025):
+//   <env>
+//     Working directory: ${Instance.directory}
+//     Workspace root folder: ${Instance.worktree}
+//     Is directory a git repo: yes/no
+//     Platform: ${process.platform}
+//     Today's date: ${new Date().toDateString()}
+//   </env>
+// Older format used <environment><cwd>/path</cwd></environment>.
+// We try both patterns to stay compatible across opencode versions.
+// We preserve the per-session directory instead of falling back to
+// process.cwd() which is the opencode server's cwd and wrong for
+// multi-session/worktree setups where each session has a different directory.
+function replaceBlockWithCompactEnv(text, startIdx, endIdx) {
     const strippedBlock = text.slice(startIdx, endIdx);
-    const cwdMatch = strippedBlock.match(/<cwd>([^<]+)<\/cwd>/);
-    const cwd = cwdMatch?.[1] || process.cwd();
+    const cwdMatch = strippedBlock.match(/Working directory:\s*(.+)/)?.[1]?.trim() ||
+        strippedBlock.match(/<cwd>([^<]+)<\/cwd>/)?.[1];
+    const cwd = cwdMatch || process.cwd();
     const envContext = `\n<environment>\n<cwd>${cwd}</cwd>\n</environment>\n` +
-        `Read, write, and edit files under <cwd>.\n\n`;
-    const result = text.slice(0, startIdx) +
+        `Read, write, and edit files under ${cwd}.\n\n`;
+    return (text.slice(0, startIdx) +
         envContext +
-        text.slice(endIdx);
-    return result;
+        text.slice(endIdx));
 }
 function mapSystemTextPart(part, onError) {
     if (typeof part === "string") {

package/dist/cli-send-thread.e2e.test.js

@@ -243,12 +243,14 @@ describe('kimaki send --channel thread creation', () => {
                 body: { name: 'cmd-detection-test', auto_archive_duration: 1440 },
             }));
             await botClient.rest.put(Routes.threadMembers(threadData.id, TEST_USER_ID));
-            // Wait for any bot reply AFTER the starter message
+            // Wait for the command detection result AFTER the starter message.
+            // New-session model banners are also bot replies, so waiting for any
+            // message can return before the command result is visible.
             await waitForBotMessageContaining({
                 discord,
                 threadId: threadData.id,
                 userId: discord.botUserId,
-                text: '',
+                text: 'Command not found: "hello-test"',
                 afterMessageId: starterMessage.id,
                 timeout: 4_000,
             });

package/dist/cli.js

@@ -1297,15 +1297,21 @@ cli
     .optional()
     .describe('Blacklist a built-in skill by name. Listed skills are hidden from the model. Repeatable: pass --disable-skill multiple times. Mutually exclusive with --enable-skill. See https://github.com/remorses/kimaki/tree/main/skills for available skills.'))
     .action(async (options) => {
-    // Guard: only one kimaki bot process can run at a time (they share a lock
-    // port). Running `kimaki` here would kill the already-running bot process
-    // and take over the lock port, breaking all active Discord sessions.
-    if (process.env.KIMAKI_OPENCODE_PROCESS) {
+    // Guard: only one kimaki bot process can run per lock port. Agents may run
+    // a second dev bot only when they explicitly choose a different lock port.
+    const parentLockPort = process.env.KIMAKI_PARENT_LOCK_PORT;
+    const currentLockPort = process.env.KIMAKI_LOCK_PORT;
+    const usesDifferentLockPort = currentLockPort !== parentLockPort;
+    if (process.env.KIMAKI_OPENCODE_PROCESS && !usesDifferentLockPort) {
         cliLogger.error('Cannot run `kimaki` inside an OpenCode session — it would kill the already-running bot process.\n' +
             'Only one kimaki bot can run at a time (they share a lock port).\n' +
-            'Use `kimaki send`, `kimaki session`, or other subcommands instead.');
+            'Set KIMAKI_LOCK_PORT to a different port for an isolated dev process, or use `kimaki send`, `kimaki session`, and other subcommands instead.');
         process.exit(EXIT_NO_RESTART);
     }
+    if (process.env.KIMAKI_OPENCODE_PROCESS && usesDifferentLockPort) {
+        delete process.env['KIMAKI_DB_URL'];
+        delete process.env['KIMAKI_DB_AUTH_TOKEN'];
+    }
     try {
         // Set data directory early, before any database access
         if (options.dataDir) {

package/dist/commands/add-dir.js

@@ -1,7 +1,7 @@
 // /add-dir command - Expand the current session's external_directory permissions.
 // Resolves the requested directory against the active working directory, then
 // updates the current session permission rules via OpenCode.
-import { ChannelType, MessageFlags, } from 'discord.js';
+import { MessageFlags, } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { getThreadSession } from '../database.js';
@@ -10,6 +10,46 @@ import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.PERMISSIONS);
 const ALL_DIRECTORIES_PATTERN = '*';
+async function waitForSessionIdle({ client, sessionId, directory, timeoutMs = 2_000, }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const statusResponse = await client.session.status({ directory });
+        const sessionStatus = statusResponse.data?.[sessionId];
+        if (!sessionStatus || sessionStatus.type === 'idle') {
+            return;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 50);
+        });
+    }
+}
+async function restartSessionIfBusy({ client, sessionId, directory, }) {
+    const statusResponse = await client.session.status({ directory });
+    if (statusResponse.error) {
+        return new Error('Failed to check session status');
+    }
+    const sessionStatus = statusResponse.data?.[sessionId];
+    if (!sessionStatus || sessionStatus.type === 'idle') {
+        return false;
+    }
+    const abortResponse = await client.session.abort({
+        sessionID: sessionId,
+        directory,
+    });
+    if (abortResponse.error) {
+        return new Error('Failed to abort in-progress session');
+    }
+    await waitForSessionIdle({ client, sessionId, directory });
+    const resumeResponse = await client.session.promptAsync({
+        sessionID: sessionId,
+        directory,
+        parts: [],
+    });
+    if (resumeResponse.error) {
+        return new Error('Failed to resume session');
+    }
+    return true;
+}
 export function resolveDirectoryPermissionPattern({ input, workingDirectory, }) {
     const trimmedInput = input.trim();
     if (!trimmedInput) {
@@ -49,12 +89,7 @@ export async function handleAddDirCommand({ command, }) {
         });
         return;
     }
-    const isThread = [
-        ChannelType.PublicThread,
-        ChannelType.PrivateThread,
-        ChannelType.AnnouncementThread,
-    ].includes(channel.type);
-    if (!isThread) {
+    if (!channel.isThread()) {
         await command.reply({
             content: 'This command can only be used in a thread with an active session',
             flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
@@ -62,7 +97,7 @@ export async function handleAddDirCommand({ command, }) {
         return;
     }
     const resolvedDirectories = await resolveWorkingDirectory({
-        channel: channel,
+        channel,
     });
     if (!resolvedDirectories) {
         await command.reply({
@@ -111,9 +146,21 @@ export async function handleAddDirCommand({ command, }) {
             await command.editReply('Failed to update session permissions');
             return;
         }
+        const restarted = await restartSessionIfBusy({
+            client,
+            sessionId,
+            directory: resolvedDirectories.workingDirectory,
+        });
+        if (restarted instanceof Error) {
+            await command.editReply(`Updated session permissions, but ${restarted.message.toLowerCase()}`);
+            return;
+        }
+        const restartSuffix = restarted
+            ? '. Restarted the in-progress session so the change applies now'
+            : '';
         await command.editReply(resolvedPattern === ALL_DIRECTORIES_PATTERN
-            ? 'Updated session permissions: all external directories are now allowed'
-            : `Updated session permissions: allowed \`${resolvedPattern}\``);
+            ? `Updated session permissions: all external directories are now allowed${restartSuffix}`
+            : `Updated session permissions: allowed \`${resolvedPattern}\`${restartSuffix}`);
     }
     catch (error) {
         logger.error('[ADD-DIR] Failed to update session permissions:', error);

package/dist/commands/last-sessions.js

@@ -0,0 +1,120 @@
+// /last-sessions command — list the 20 most recently active sessions across
+// all projects, sorted by last activity. Renders a markdown table with
+// clickable thread links and project names via Discord CV2 components.
+import { ChatInputCommandInteraction, ComponentType, MessageFlags, } from 'discord.js';
+import path from 'node:path';
+import { getPrisma } from '../db.js';
+import { getChannelDirectory } from '../database.js';
+import { splitTablesFromMarkdown } from '../format-tables.js';
+import { formatTimeAgo } from './worktrees.js';
+const MAX_ROWS = 20;
+async function fetchRecentSessions({ client, }) {
+    const prisma = await getPrisma();
+    // Fetch all thread sessions with their most recent event timestamp.
+    // Prisma doesn't support ORDER BY aggregated subquery, so we fetch all
+    // sessions with their latest event and sort in JS.
+    const sessions = await prisma.thread_sessions.findMany({
+        select: {
+            thread_id: true,
+            session_id: true,
+            created_at: true,
+            session_events: {
+                orderBy: { timestamp: 'desc' },
+                take: 1,
+                select: { timestamp: true },
+            },
+        },
+    });
+    // Build rows with resolved last-active timestamp
+    const withTimestamp = sessions.map((s) => {
+        const latestEventTs = s.session_events[0]?.timestamp;
+        const lastActive = latestEventTs
+            ? new Date(Number(latestEventTs))
+            : s.created_at ?? new Date(0);
+        return {
+            threadId: s.thread_id,
+            sessionId: s.session_id,
+            lastActive,
+        };
+    });
+    // Sort by last active descending, take top N
+    withTimestamp.sort((a, b) => {
+        return b.lastActive.getTime() - a.lastActive.getTime();
+    });
+    const top = withTimestamp.slice(0, MAX_ROWS);
+    // Resolve project names via Discord thread parent channel
+    const channelDirCache = new Map();
+    const rows = await Promise.all(top.map(async (row) => {
+        let projectName;
+        try {
+            const channel = await client.channels.fetch(row.threadId);
+            const parentId = channel && 'parentId' in channel ? channel.parentId : undefined;
+            if (parentId) {
+                if (!channelDirCache.has(parentId)) {
+                    const dir = await getChannelDirectory(parentId);
+                    channelDirCache.set(parentId, dir ? path.basename(dir.directory) : undefined);
+                }
+                projectName = channelDirCache.get(parentId);
+            }
+        }
+        catch {
+            // Thread may have been deleted or is inaccessible
+        }
+        return {
+            threadId: row.threadId,
+            sessionId: row.sessionId,
+            lastActive: row.lastActive,
+            projectName,
+        };
+    }));
+    return rows;
+}
+function buildSessionTable({ rows }) {
+    const header = '| Project | Thread | Last Active |';
+    const separator = '|---|---|---|';
+    const tableRows = rows.map((row) => {
+        const project = row.projectName ?? 'unknown';
+        const thread = `<#${row.threadId}>`;
+        const lastActive = formatTimeAgo(row.lastActive);
+        return `| ${project} | ${thread} | ${lastActive} |`;
+    });
+    return [header, separator, ...tableRows].join('\n');
+}
+export async function handleLastSessionsCommand({ command, }) {
+    if (!command.guildId) {
+        await command.reply({
+            content: 'This command can only be used in a server.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    const rows = await fetchRecentSessions({ client: command.client });
+    if (rows.length === 0) {
+        const textDisplay = {
+            type: ComponentType.TextDisplay,
+            content: 'No sessions found.',
+        };
+        await command.editReply({
+            components: [textDisplay],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const tableMarkdown = buildSessionTable({ rows });
+    const segments = splitTablesFromMarkdown(tableMarkdown);
+    const components = segments.flatMap((segment) => {
+        if (segment.type === 'components') {
+            return segment.components;
+        }
+        const textDisplay = {
+            type: ComponentType.TextDisplay,
+            content: segment.text,
+        };
+        return [textDisplay];
+    });
+    await command.editReply({
+        components,
+        flags: MessageFlags.IsComponentsV2,
+    });
+}

package/dist/commands/permissions.js

@@ -7,6 +7,28 @@ import { getOpencodeClient } from '../opencode.js';
 import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.PERMISSIONS);
+async function resumeSessionIfIdleAfterPermission({ client, sessionId, directory, }) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, 100);
+    });
+    const statusResponse = await client.session.status({ directory });
+    if (statusResponse.error) {
+        return new Error('Failed to check session status');
+    }
+    const sessionStatus = statusResponse.data?.[sessionId];
+    if (!sessionStatus || sessionStatus.type !== 'idle') {
+        return false;
+    }
+    const resumeResponse = await client.session.promptAsync({
+        sessionID: sessionId,
+        directory,
+        parts: [],
+    });
+    if (resumeResponse.error) {
+        return new Error('Failed to resume session');
+    }
+    return true;
+}
 function wildcardMatch({ value, pattern, }) {
     let escapedPattern = pattern
         .replace(/[.+^${}()|[\]\\]/g, '\\$&')
@@ -87,6 +109,10 @@ export async function showPermissionButtons({ thread, permission, directory, per
             })).catch((error) => {
                 logger.error('Failed to auto-reject expired permission:', error);
             });
+            updatePermissionMessage({
+                context: ctx,
+                status: '_Permission expired after 10 minutes and was rejected._',
+            });
         }
     }, PERMISSION_CONTEXT_TTL_MS).unref();
     const patternStr = compactPermissionPatterns(permission.patterns).join(', ');
@@ -206,10 +232,16 @@ export async function handlePermissionButton(interaction) {
         return;
     }
     const response = actionPart.replace('permission_', '');
+    if (response !== 'once' && response !== 'always' && response !== 'reject') {
+        return;
+    }
     // Atomic take: if TTL already expired and auto-rejected, context is gone.
     const context = takePendingPermissionContext(contextHash);
     if (!context) {
-        await interaction.update({ components: [] });
+        await interaction.update({
+            content: '_Permission expired and was already rejected. Send a new message to continue._',
+            components: [],
+        });
         return;
     }
     await interaction.deferUpdate();
@@ -228,6 +260,19 @@ export async function handlePermissionButton(interaction) {
                 reply: response,
             });
         }));
+        if (response !== 'reject') {
+            const resumed = await resumeSessionIfIdleAfterPermission({
+                client: permClient,
+                sessionId: context.permission.sessionID,
+                directory: context.permissionDirectory,
+            });
+            if (resumed instanceof Error) {
+                logger.error('Failed to resume idle session after permission:', resumed);
+            }
+            if (resumed === true) {
+                logger.log(`Resumed idle session after permission ${context.permission.id}`);
+            }
+        }
         // Context already removed by takePendingPermissionContext above.
         // Update message: show result and remove dropdown
         const resultText = (() => {
@@ -266,9 +311,3 @@ export function addPermissionRequestToContext({ contextHash, requestId, }) {
     pendingPermissionContexts.set(contextHash, context);
     return true;
 }
-/**
- * Clean up a pending permission context (e.g., on auto-reject).
- */
-export function cleanupPermissionContext(contextHash) {
-    pendingPermissionContexts.delete(contextHash);
-}

package/dist/discord-command-registration.js

@@ -151,6 +151,11 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('List all active worktree sessions'))
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('last-sessions')
+            .setDescription(truncateCommandDescription('List the 20 most recently active sessions across all projects'))
+            .setDMPermission(false)
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('tasks')
             .setDescription(truncateCommandDescription('List scheduled tasks created via send --send-at'))

package/dist/format-tables.test.js

@@ -439,6 +439,25 @@ Read this first.
       ]
     `);
     });
+    test('renders callout that was prefixed with ⬥ as plain text (regression)', () => {
+        // Before the fix, formatPart would add ⬥ prefix to callout lines,
+        // breaking the callout parser. Now formatPart skips the prefix for callouts.
+        const result = splitTablesFromMarkdown(`⬥ <callout accent="#ef4444">
+## Top priority
+- **Stripe dispute** deadline
+</callout>`);
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "⬥ <callout accent="#ef4444">
+      ## Top priority
+      - **Stripe dispute** deadline
+      </callout>",
+          "type": "text",
+        },
+      ]
+    `);
+    });
     test('falls back to plain text when a callout is not closed', () => {
         const result = splitTablesFromMarkdown(`<callout accent="#2b7fff">
 ## Important

package/dist/gateway-proxy.e2e.test.js

@@ -323,6 +323,7 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         hello from gateway proxy test
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ gateway-proxy-reply
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
@@ -349,6 +350,7 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         hello from gateway proxy test
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ gateway-proxy-reply
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (proxy-tester)
@@ -380,6 +382,7 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         hello from gateway proxy test
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ gateway-proxy-reply
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (proxy-tester)
@@ -414,7 +417,7 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         second message through proxy
         --- from: assistant (TestBot)
-        ⬥ gateway-proxy-reply"
+        *using deterministic-provider/deterministic-v2*"
       `);
         expect(reply).toBeDefined();
         expect(reply.content.trim().length).toBeGreaterThan(0);

package/dist/interaction-handler.js

@@ -8,6 +8,7 @@ import { handleMergeWorktreeCommand, handleMergeWorktreeAutocomplete, } from './
 import { handleToggleWorktreesCommand } from './commands/worktree-settings.js';
 import { handleWorktreesCommand } from './commands/worktrees.js';
 import { handleTasksCommand } from './commands/tasks.js';
+import { handleLastSessionsCommand } from './commands/last-sessions.js';
 import { handleResumeCommand, handleResumeAutocomplete, } from './commands/resume.js';
 import { handleAddProjectCommand, handleAddProjectAutocomplete, } from './commands/add-project.js';
 import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './commands/remove-project.js';
@@ -122,6 +123,12 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                             appId,
                         });
                         return;
+                    case 'last-sessions':
+                        await handleLastSessionsCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
                     case 'resume':
                         await handleResumeCommand({ command: interaction, appId });
                         return;