kimaki 0.7.1 → 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/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/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;

package/dist/logger.js

@@ -1,6 +1,6 @@
-// Prefixed logging utility using @clack/prompts for consistent visual style.
-// All log methods use clack's log.message() with appropriate symbols to prevent
-// output interleaving from concurrent async operations.
+// Prefixed logging utility using @clack/prompts for consistent stderr diagnostics and file logs.
+// Never write logger output to stdout because many CLI subcommands print
+// machine-readable data there, for example `kimaki project list --json`.
 import { log as clackLog } from '@clack/prompts';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -106,7 +106,7 @@ export function formatErrorWithStack(error) {
         redactPaths: false,
     });
 }
-function writeToFile(level, prefix, args) {
+function writeToFile({ level, prefix, args, }) {
     const timestamp = new Date().toISOString();
     const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`;
     if (!logFilePath) {
@@ -118,13 +118,10 @@ function getTimestamp() {
     const now = new Date();
     return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
 }
-function padPrefix(prefix) {
-    return prefix.padEnd(MAX_PREFIX_LENGTH);
-}
-function formatMessage(timestamp, prefix, args) {
+function formatMessage({ timestamp, prefix, args, }) {
     return [pc.dim(timestamp), prefix, ...args.map(formatArg)].join(' ');
 }
-const noSpacing = { spacing: 0 };
+const stderrLogOptions = { output: process.stderr, spacing: 0 };
 // Suppress clack terminal output during vitest runs to avoid flooding
 // test output with hundreds of log lines. File logging still works.
 // Set KIMAKI_TEST_LOGS=1 when rerunning a failing test to see all
@@ -132,39 +129,41 @@ const noSpacing = { spacing: 0 };
 const isVitest = !!process.env['KIMAKI_VITEST'];
 const showTestLogs = isVitest && !!process.env['KIMAKI_TEST_LOGS'];
 export function createLogger(prefix) {
-    const paddedPrefix = padPrefix(prefix);
+    const paddedPrefix = prefix.padEnd(MAX_PREFIX_LENGTH);
     const suppressConsole = isVitest && !showTestLogs;
     const log = (...args) => {
-        writeToFile('LOG', prefix, args);
+        writeToFile({ level: 'LOG', prefix, args });
         if (suppressConsole) {
             return;
         }
-        clackLog.message(formatMessage(getTimestamp(), pc.cyan(paddedPrefix), args), {
-            ...noSpacing,
-        });
+        clackLog.message(formatMessage({ timestamp: getTimestamp(), prefix: pc.cyan(paddedPrefix), args }), stderrLogOptions);
     };
     return {
         log,
         error: (...args) => {
-            writeToFile('ERROR', prefix, args);
+            writeToFile({ level: 'ERROR', prefix, args });
             if (suppressConsole) {
                 return;
             }
-            clackLog.error(formatMessage(getTimestamp(), pc.red(paddedPrefix), args), noSpacing);
+            clackLog.error(formatMessage({ timestamp: getTimestamp(), prefix: pc.red(paddedPrefix), args }), stderrLogOptions);
         },
         warn: (...args) => {
-            writeToFile('WARN', prefix, args);
+            writeToFile({ level: 'WARN', prefix, args });
             if (suppressConsole) {
                 return;
             }
-            clackLog.warn(formatMessage(getTimestamp(), pc.yellow(paddedPrefix), args), noSpacing);
+            clackLog.warn(formatMessage({
+                timestamp: getTimestamp(),
+                prefix: pc.yellow(paddedPrefix),
+                args,
+            }), stderrLogOptions);
         },
         info: (...args) => {
-            writeToFile('INFO', prefix, args);
+            writeToFile({ level: 'INFO', prefix, args });
             if (suppressConsole) {
                 return;
             }
-            clackLog.info(formatMessage(getTimestamp(), pc.blue(paddedPrefix), args), noSpacing);
+            clackLog.info(formatMessage({ timestamp: getTimestamp(), prefix: pc.blue(paddedPrefix), args }), stderrLogOptions);
         },
         debug: log,
     };

package/dist/opencode.js

@@ -521,6 +521,7 @@ async function startSingleServer({ directory, } = {}) {
             KIMAKI: '1',
             KIMAKI_DATA_DIR: getDataDir(),
             KIMAKI_LOCK_PORT: getLockPort().toString(),
+            KIMAKI_PARENT_LOCK_PORT: getLockPort().toString(),
             ...(gatewayToken && { KIMAKI_DB_AUTH_TOKEN: gatewayToken }),
             // Guard: prevents agents from running `kimaki` root command inside
             // an OpenCode session, which would steal the lock port and break the bot.

package/dist/queue-advanced-abort.e2e.test.js

@@ -155,6 +155,7 @@ e2eTest('queue advanced: abort and retry', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: abort-no-footer-setup
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (queue-advanced-tester)
@@ -285,7 +286,7 @@ e2eTest('queue advanced: abort and retry', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: force-abort-setup
         --- from: assistant (TestBot)
-        ⬥ ok
+        *using deterministic-provider/deterministic-v2*
         --- from: user (queue-advanced-tester)
         SLOW_ABORT_MARKER run long response"
       `);

package/dist/queue-advanced-action-buttons.e2e.test.js

@@ -122,6 +122,7 @@ describe('queue advanced: action buttons', () => {
         "--- from: user (queue-action-tester)
         Reply with exactly: action-button-setup
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         **Action Required**
@@ -193,6 +194,7 @@ describe('queue advanced: action buttons', () => {
         "--- from: user (queue-action-tester)
         Reply with exactly: action-button-dismiss-setup
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         **Action Required**

package/dist/queue-advanced-footer.e2e.test.js

@@ -33,6 +33,7 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: footer-check
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
@@ -89,6 +90,7 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: footer-multi-setup
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (queue-advanced-tester)
@@ -185,6 +187,7 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: interrupt-footer-setup
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (queue-advanced-tester)
@@ -265,6 +268,7 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: plugin-timeout-setup
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (queue-advanced-tester)
@@ -357,6 +361,7 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         TOOL_CALL_FOOTER_MARKER
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ running tool
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
@@ -411,6 +416,7 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         MULTI_TOOL_FOOTER_MARKER
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ investigating the issue
         ⬥ all done, fixed 3 files
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
@@ -467,6 +473,7 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         MULTI_STEP_CHAIN_MARKER
         --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
         ⬥ chain step 1: reading config
         ⬥ chain step 2: analyzing results
         ⬥ chain step 3: applying fix