kimaki 0.27.0 → 0.28.0

package/dist/commands/model.js

@@ -321,15 +321,16 @@ export async function handleModelCommand({ interaction, appId, }) {
             });
             return;
         }
-        const currentModelText = (() => {
+        const currentModelText = await (async () => {
             if (currentModelInfo.type === 'none') {
                 return '**Current:** none';
             }
-            const displayed = resolveDisplayedModelId({
+            const displayed = (await resolveDisplayedModelId({
                 providers: allProviders,
                 providerID: currentModelInfo.providerID,
                 modelID: currentModelInfo.modelID,
-            }) ?? currentModelInfo.model;
+                sessionID: sessionId,
+            })) ?? currentModelInfo.model;
             switch (currentModelInfo.type) {
                 case 'session':
                     return `**Current (this thread):** \`${displayed}\``;

package/dist/commands/queue.js

@@ -6,6 +6,7 @@ import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils
 import { getOrCreateRuntime, getRuntime, } from '../session-handler/thread-session-runtime.js';
 import { buildHtmlActionCustomId, registerHtmlAction, } from '../html-actions.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { QUEUE_PREFIX } from '../message-formatting.js';
 import { store } from '../store.js';
 const logger = createLogger(LogPrefix.QUEUE);
 function buildQueueRemoveRow({ threadId, queueId, position, }) {
@@ -108,7 +109,7 @@ export async function handleQueueCommand({ command, appId, }) {
         });
         return;
     }
-    const responseText = `» **${command.user.displayName}:** ${message.slice(0, 1000)}${message.length > 1000 ? '...' : ''}`;
+    const responseText = `${QUEUE_PREFIX}**${command.user.displayName}:** ${message.slice(0, 1000)}${message.length > 1000 ? '...' : ''}`;
     await command.reply({
         content: responseText,
         flags: SILENT_MESSAGE_FLAGS,
@@ -264,7 +265,7 @@ export async function handleQueueCommandCommand({ command, appId, }) {
         logger.log(`[QUEUE] User ${command.user.displayName} queued command /${commandName} in thread ${channel.id}`);
         return;
     }
-    const responseText = `» **${command.user.displayName}:** ${displayText}`;
+    const responseText = `${QUEUE_PREFIX}**${command.user.displayName}:** ${displayText}`;
     await command.reply({
         content: responseText,
         flags: SILENT_MESSAGE_FLAGS,

package/dist/commands/resume.js

@@ -3,7 +3,7 @@ import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
 import { getChannelDirectory, setThreadSession, setPartMessagesBatch, getAllThreadSessionIds, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { sendThreadMessage, resolveProjectDirectoryFromAutocomplete, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { sendThreadMessage, sendSessionPartBatches, resolveProjectDirectoryFromAutocomplete, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { collectSessionChunks, batchChunksForDiscord } from '../message-formatting.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
@@ -79,11 +79,11 @@ export async function handleResumeCommand({ command, }) {
                 await sendThreadMessage(thread, `*Skipped ${skippedCount} older assistant parts...*`);
             }
             const batched = batchChunksForDiscord(chunks);
-            for (const batch of batched) {
-                const discordMessage = await sendThreadMessage(thread, batch.content);
+            const sent = await sendSessionPartBatches({ thread, batches: batched });
+            for (const batch of sent) {
                 await setPartMessagesBatch(batch.partIds.map((partId) => ({
                     partId,
-                    messageId: discordMessage.id,
+                    messageId: batch.message.id,
                     threadId: thread.id,
                 })));
             }

package/dist/commands/session.js

@@ -2,16 +2,56 @@
 // Works in both text channels and threads. When used in a thread, the new
 // session inherits the same working directory (worktree/workspace) so the
 // user stays in the same folder context.
+// Also owns the fresh-thread creation flow used by voice routing.
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { getChannelDirectory, getThreadWorktreeOrWorkspace, createPendingWorkspace, setWorkspaceReady, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { SILENT_MESSAGE_FLAGS, resolveProjectDirectoryFromAutocomplete, resolveWorkingDirectory, resolveTextChannel, } from '../discord-utils.js';
+import { sendThreadMessage, splitMarkdownForDiscord, SILENT_MESSAGE_FLAGS, resolveProjectDirectoryFromAutocomplete, resolveWorkingDirectory, resolveTextChannel, } from '../discord-utils.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
-import * as errore from 'errore';
+import { DiscordOperationError } from '../errors.js';
 const logger = createLogger(LogPrefix.SESSION);
+// Create only: callers confirm the destination before dispatching the full prompt.
+export async function createNewSessionThread({ textChannel, projectDirectory, sourceWorkspace, prompt, files = [], userId, }) {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error)
+        return getClient;
+    const [starter, ...remaining] = splitMarkdownForDiscord({
+        content: `**Starting OpenCode session**\n${prompt}${files.length > 0 ? `\nFiles: ${files.join(', ')}` : ''}`,
+        maxLength: 2000,
+    });
+    if (!starter)
+        return new Error('No session request to send. Retry with /new-session and a prompt.');
+    const starterMessage = await textChannel.send({ content: starter, flags: SILENT_MESSAGE_FLAGS });
+    const thread = await starterMessage.startThread({
+        name: prompt.slice(0, 100),
+        autoArchiveDuration: 1440,
+        reason: 'OpenCode session',
+    });
+    for (const chunk of remaining) {
+        await sendThreadMessage(thread, chunk);
+    }
+    // Persist the directory association for later commands and bot restarts.
+    if (sourceWorkspace?.status === 'ready' && sourceWorkspace.workspace_directory) {
+        await createPendingWorkspace({
+            threadId: thread.id,
+            workspaceType: sourceWorkspace.workspace_type,
+            workspaceName: sourceWorkspace.workspace_name ?? '',
+            projectDirectory,
+        });
+        await setWorkspaceReady({
+            threadId: thread.id,
+            workspaceId: sourceWorkspace.workspace_id ?? undefined,
+            workspaceDirectory: sourceWorkspace.workspace_directory,
+        });
+    }
+    await thread.members.add(userId).catch((error) => {
+        logger.warn('Could not add session member:', error);
+    });
+    return thread;
+}
 export async function handleSessionCommand({ command, appId, }) {
     await command.deferReply();
     const prompt = command.options.getString('prompt', true);
@@ -67,68 +107,43 @@ export async function handleSessionCommand({ command, appId, }) {
         await command.editReply(`Directory does not exist: ${projectDirectory}`);
         return;
     }
-    try {
-        const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (getClient instanceof Error) {
-            await command.editReply(getClient.message);
-            return;
-        }
-        const files = filesString
-            .split(',')
-            .map((f) => f.trim())
-            .filter((f) => f);
-        let fullPrompt = prompt;
-        if (files.length > 0) {
-            fullPrompt = `${prompt}\n\n@${files.join(' @')}`;
-        }
-        const starterMessage = await textChannel.send({
-            content: `**Starting OpenCode session**\n${prompt}${files.length > 0 ? `\nFiles: ${files.join(', ')}` : ''}`,
-            flags: SILENT_MESSAGE_FLAGS,
-        });
-        const thread = await starterMessage.startThread({
-            name: prompt.slice(0, 100),
-            autoArchiveDuration: 1440,
-            reason: 'OpenCode session',
-        });
-        // Persist workspace association so commands in the new thread resolve the
-        // correct working directory, and the runtime survives bot restarts.
-        if (sourceWorkspace?.status === 'ready' && sourceWorkspace.workspace_directory) {
-            await createPendingWorkspace({
-                threadId: thread.id,
-                workspaceType: sourceWorkspace.workspace_type,
-                workspaceName: sourceWorkspace.workspace_name ?? '',
-                projectDirectory,
-            });
-            await setWorkspaceReady({
-                threadId: thread.id,
-                workspaceId: sourceWorkspace.workspace_id ?? undefined,
-                workspaceDirectory: sourceWorkspace.workspace_directory,
-            });
-        }
-        // Add user to thread so it appears in their sidebar
-        await thread.members.add(command.user.id);
-        await command.editReply(`Created new session in ${thread.toString()}`);
-        const runtime = getOrCreateRuntime({
-            threadId: thread.id,
-            thread,
-            projectDirectory,
-            sdkDirectory,
-            channelId: textChannel.id,
-            appId,
-        });
-        await runtime.enqueueIncoming({
-            prompt: fullPrompt,
-            userId: command.user.id,
-            username: command.user.displayName,
-            agent,
-            appId,
-            mode: 'opencode',
-        });
-    }
-    catch (error) {
-        logger.error('[SESSION] Error:', error);
-        await command.editReply(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    const files = filesString
+        .split(',')
+        .map((f) => f.trim())
+        .filter((f) => f);
+    const thread = await createNewSessionThread({
+        textChannel,
+        projectDirectory,
+        sourceWorkspace,
+        prompt,
+        files,
+        userId: command.user.id,
+    }).catch((cause) => new DiscordOperationError({ operation: 'createSessionThread', cause }));
+    if (thread instanceof Error) {
+        logger.error('New session creation failed:', thread);
+        await command.editReply(`${thread.message}. Retry with /new-session.`);
+        return;
     }
+    await command.editReply(`Created new session in ${thread.toString()}`);
+    const runtime = getOrCreateRuntime({
+        threadId: thread.id,
+        thread,
+        projectDirectory,
+        sdkDirectory,
+        channelId: textChannel.id,
+        appId,
+    });
+    await runtime.enqueueIncoming({
+        prompt: files.length > 0 ? `${prompt}\n\n@${files.join(' @')}` : prompt,
+        userId: command.user.id,
+        username: command.user.displayName,
+        agent,
+        appId,
+        mode: 'opencode',
+    }).catch(async (error) => {
+        logger.error('New session dispatch failed:', error);
+        await sendThreadMessage(thread, 'Could not send the request to OpenCode. Send your request again in this thread.');
+    });
 }
 async function handleAgentAutocomplete({ interaction, }) {
     const focusedValue = interaction.options.getFocused();

package/dist/cpu-profiler.js

@@ -0,0 +1,211 @@
+// Live CPU profiling for the running Kimaki process.
+// Type `cpuprof` in the bot terminal to start. Type it again to stop,
+// or wait 20s for auto-stop. Writes Chrome DevTools .cpuprofile files
+// to <dataDir>/cpu-profiles/.
+import * as errore from 'errore';
+import fs from 'node:fs';
+import inspector from 'node:inspector/promises';
+import path from 'node:path';
+import readline from 'node:readline';
+import { getDataDir } from './config.js';
+import { FilesystemOperationError } from './errors.js';
+import { createLogger, LogPrefix } from './logger.js';
+const logger = createLogger(LogPrefix.CPU);
+export const CPU_PROF_AUTO_STOP_MS = 20_000;
+class CpuProfilerError extends errore.createTaggedError({
+    name: 'CpuProfilerError',
+    message: '$reason',
+}) {
+}
+let session = null;
+let autoStopTimer = null;
+let stdinReader = null;
+let lock = Promise.resolve();
+function withLock(fn) {
+    const run = lock.then(fn, fn);
+    lock = run.then(() => { }, () => { });
+    return run;
+}
+function getCpuProfileDir() {
+    return path.join(getDataDir(), 'cpu-profiles');
+}
+function cpuProfilePath() {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(getCpuProfileDir(), `cpu-${timestamp}.cpuprofile`);
+}
+export function isCpuProfiling() {
+    return session !== null;
+}
+export function parseStdinCommand(line) {
+    if (line.trim().toLowerCase() === 'cpuprof')
+        return 'cpuprof';
+    return null;
+}
+function clearAutoStopTimer() {
+    if (!autoStopTimer)
+        return;
+    clearTimeout(autoStopTimer);
+    autoStopTimer = null;
+}
+function scheduleAutoStop(autoStopMs) {
+    clearAutoStopTimer();
+    autoStopTimer = setTimeout(() => {
+        autoStopTimer = null;
+        void stopCpuProfiling().then((result) => {
+            if (result instanceof Error) {
+                logger.warn('CPU profile auto-stop failed:', result.message);
+                return;
+            }
+            logger.log(`CPU profile auto-stopped: ${result.path}`);
+        });
+    }, autoStopMs);
+    autoStopTimer.unref();
+}
+async function startUnlocked({ autoStopMs, }) {
+    if (session) {
+        return new CpuProfilerError({
+            reason: 'CPU profiling is already running. Type cpuprof again to stop.',
+        });
+    }
+    const next = new inspector.Session();
+    const connected = errore.try(() => {
+        next.connect();
+    }, (e) => new CpuProfilerError({
+        reason: 'Failed to connect inspector. Type cpuprof again after a few seconds.',
+        cause: e,
+    }));
+    if (connected instanceof Error)
+        return connected;
+    const enabled = await next.post('Profiler.enable').catch((e) => new CpuProfilerError({
+        reason: 'Failed to enable profiler',
+        cause: e,
+    }));
+    if (enabled instanceof Error) {
+        next.disconnect();
+        return enabled;
+    }
+    const started = await next.post('Profiler.start').catch((e) => new CpuProfilerError({
+        reason: 'Failed to start profiler',
+        cause: e,
+    }));
+    if (started instanceof Error) {
+        await next.post('Profiler.disable').catch((e) => {
+            logger.warn('Failed to disable profiler after start error:', e);
+        });
+        next.disconnect();
+        return started;
+    }
+    session = next;
+    scheduleAutoStop(autoStopMs);
+    logger.log(`CPU profiling started. Type cpuprof again to stop, or wait ${autoStopMs / 1000}s.`);
+    return { action: 'started', autoStopMs };
+}
+async function stopUnlocked() {
+    if (!session) {
+        return new CpuProfilerError({
+            reason: 'CPU profiling is not running. Type cpuprof to start.',
+        });
+    }
+    const current = session;
+    session = null;
+    clearAutoStopTimer();
+    const stopped = await current.post('Profiler.stop').catch((e) => new CpuProfilerError({
+        reason: 'Failed to stop profiler',
+        cause: e,
+    }));
+    await current.post('Profiler.disable').catch((e) => {
+        logger.warn('Failed to disable profiler:', e);
+    });
+    current.disconnect();
+    if (stopped instanceof Error)
+        return stopped;
+    const profile = stopped.profile;
+    if (!profile) {
+        return new CpuProfilerError({
+            reason: 'Profiler stop returned no profile. Try cpuprof again.',
+        });
+    }
+    const dir = getCpuProfileDir();
+    const created = errore.try(() => {
+        fs.mkdirSync(dir, { recursive: true });
+    }, (e) => new FilesystemOperationError({
+        operation: `mkdir ${dir}`,
+        cause: e,
+    }));
+    if (created instanceof Error)
+        return created;
+    const filepath = cpuProfilePath();
+    const written = await fs.promises
+        .writeFile(filepath, JSON.stringify(profile))
+        .catch((e) => new FilesystemOperationError({
+        operation: `write ${filepath}`,
+        cause: e,
+    }));
+    if (written instanceof Error)
+        return written;
+    logger.log(`CPU profile written: ${filepath}`);
+    return { action: 'stopped', path: filepath };
+}
+export function startCpuProfiling({ autoStopMs = CPU_PROF_AUTO_STOP_MS, } = {}) {
+    return withLock(() => startUnlocked({ autoStopMs }));
+}
+export function stopCpuProfiling() {
+    return withLock(() => stopUnlocked());
+}
+export function toggleCpuProfiling({ autoStopMs = CPU_PROF_AUTO_STOP_MS, } = {}) {
+    return withLock(async () => {
+        if (session)
+            return stopUnlocked();
+        return startUnlocked({ autoStopMs });
+    });
+}
+export function flushCpuProfiling() {
+    return withLock(async () => {
+        if (!session)
+            return null;
+        return stopUnlocked();
+    });
+}
+export async function handleStdinLine(line, { autoStopMs = CPU_PROF_AUTO_STOP_MS, } = {}) {
+    if (parseStdinCommand(line) !== 'cpuprof')
+        return null;
+    return toggleCpuProfiling({ autoStopMs });
+}
+export function startStdinCpuProfListener({ stdin, autoStopMs = CPU_PROF_AUTO_STOP_MS, } = {}) {
+    if (stdinReader)
+        return;
+    const input = stdin ?? process.stdin;
+    if (!stdin) {
+        if (process.env.KIMAKI_VITEST)
+            return;
+        if (!process.stdin.isTTY)
+            return;
+    }
+    stdinReader = readline.createInterface({ input, terminal: false });
+    stdinReader.on('line', (line) => {
+        void handleStdinLine(line, { autoStopMs }).then((result) => {
+            if (result instanceof Error)
+                logger.warn(result.message);
+        }, (error) => {
+            logger.warn('CPU profile command failed:', error instanceof Error ? error.message : String(error));
+        });
+    });
+    logger.log('Type cpuprof then Enter to capture a CPU profile');
+}
+export function stopStdinCpuProfListener() {
+    if (!stdinReader)
+        return;
+    stdinReader.close();
+    stdinReader = null;
+}
+export async function _resetCpuProfilerForTests() {
+    stopStdinCpuProfListener();
+    clearAutoStopTimer();
+    await lock;
+    if (!session)
+        return;
+    const stopped = await withLock(() => stopUnlocked());
+    if (stopped instanceof Error) {
+        logger.warn('Failed to reset CPU profiler:', stopped.message);
+    }
+}

package/dist/cpu-profiler.test.js

@@ -0,0 +1,160 @@
+// Tests for live CPU profiling via stdin `cpuprof` and node:inspector.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { PassThrough } from 'node:stream';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { setDataDir } from './config.js';
+import { CPU_PROF_AUTO_STOP_MS, handleStdinLine, isCpuProfiling, parseStdinCommand, startCpuProfiling, startStdinCpuProfListener, stopCpuProfiling, stopStdinCpuProfListener, toggleCpuProfiling, flushCpuProfiling, _resetCpuProfilerForTests, } from './cpu-profiler.js';
+const tempDirs = [];
+function makeDataDir() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-cpu-profiler-'));
+    tempDirs.push(dir);
+    setDataDir(dir);
+    return dir;
+}
+function cpuProfileDir(dataDir) {
+    return path.join(dataDir, 'cpu-profiles');
+}
+function listProfiles(dataDir) {
+    const dir = cpuProfileDir(dataDir);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir).filter((name) => name.endsWith('.cpuprofile'));
+}
+function burnCpu(ms) {
+    const end = Date.now() + ms;
+    while (Date.now() < end)
+        Math.sqrt(Math.random());
+}
+async function waitUntil(predicate, timeoutMs = 2000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (predicate())
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    throw new Error('timed out waiting for condition');
+}
+beforeEach(() => {
+    makeDataDir();
+});
+afterEach(async () => {
+    await _resetCpuProfilerForTests();
+    for (const dir of tempDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('parseStdinCommand', () => {
+    test('matches cpuprof after trim, ignoring case', () => {
+        expect(parseStdinCommand('cpuprof')).toBe('cpuprof');
+        expect(parseStdinCommand('  CPUProf \n')).toBe('cpuprof');
+        expect(parseStdinCommand('cpuprof now')).toBeNull();
+        expect(parseStdinCommand('heap')).toBeNull();
+    });
+});
+describe.sequential('cpu profiler', () => {
+    test('auto-stop default is 20 seconds', () => {
+        expect(CPU_PROF_AUTO_STOP_MS).toBe(20_000);
+    });
+    test('start then stop writes a chrome cpuprofile under the data dir', async () => {
+        const dataDir = makeDataDir();
+        const started = await startCpuProfiling({ autoStopMs: 10_000 });
+        expect(started).not.toBeInstanceOf(Error);
+        expect(isCpuProfiling()).toBe(true);
+        burnCpu(50);
+        const stopped = await stopCpuProfiling();
+        expect(stopped).not.toBeInstanceOf(Error);
+        if (stopped instanceof Error)
+            return;
+        expect(isCpuProfiling()).toBe(false);
+        expect(stopped.path.startsWith(cpuProfileDir(dataDir))).toBe(true);
+        expect(stopped.path).toMatch(/cpu-.*\.cpuprofile$/);
+        expect(fs.existsSync(stopped.path)).toBe(true);
+        const profile = JSON.parse(fs.readFileSync(stopped.path, 'utf8'));
+        expect(Array.isArray(profile.nodes)).toBe(true);
+        expect(listProfiles(dataDir)).toEqual([path.basename(stopped.path)]);
+    });
+    test('start while already running returns an error', async () => {
+        const started = await startCpuProfiling({ autoStopMs: 10_000 });
+        expect(started).not.toBeInstanceOf(Error);
+        const again = await startCpuProfiling({ autoStopMs: 10_000 });
+        expect(again).toBeInstanceOf(Error);
+        expect(isCpuProfiling()).toBe(true);
+    });
+    test('stop while idle returns an error', async () => {
+        const stopped = await stopCpuProfiling();
+        expect(stopped).toBeInstanceOf(Error);
+    });
+    test('toggle starts then stops', async () => {
+        const dataDir = makeDataDir();
+        const started = await toggleCpuProfiling({ autoStopMs: 10_000 });
+        expect(started).not.toBeInstanceOf(Error);
+        if (started instanceof Error)
+            return;
+        expect(started.action).toBe('started');
+        expect(isCpuProfiling()).toBe(true);
+        burnCpu(30);
+        const stopped = await toggleCpuProfiling({ autoStopMs: 10_000 });
+        expect(stopped).not.toBeInstanceOf(Error);
+        if (stopped instanceof Error)
+            return;
+        expect(stopped.action).toBe('stopped');
+        if (stopped.action !== 'stopped')
+            return;
+        expect(fs.existsSync(stopped.path)).toBe(true);
+        expect(listProfiles(dataDir)).toHaveLength(1);
+    });
+    test('auto-stops after the timeout and writes a profile', async () => {
+        const dataDir = makeDataDir();
+        const started = await startCpuProfiling({ autoStopMs: 80 });
+        expect(started).not.toBeInstanceOf(Error);
+        await waitUntil(() => listProfiles(dataDir).length === 1);
+        expect(isCpuProfiling()).toBe(false);
+    });
+    test('flush waits for an in-flight start and writes one profile', async () => {
+        const dataDir = makeDataDir();
+        const starting = startCpuProfiling({ autoStopMs: 10_000 });
+        const flushing = flushCpuProfiling();
+        await starting;
+        const result = await flushing;
+        expect(result).not.toBeInstanceOf(Error);
+        expect(listProfiles(dataDir)).toHaveLength(1);
+        expect(isCpuProfiling()).toBe(false);
+    });
+});
+describe.sequential('stdin cpuprof', () => {
+    test('handleStdinLine starts and stops on cpuprof', async () => {
+        const dataDir = makeDataDir();
+        const first = await handleStdinLine('cpuprof', { autoStopMs: 10_000 });
+        expect(first).not.toBeInstanceOf(Error);
+        expect(first).not.toBeNull();
+        if (first instanceof Error || !first)
+            return;
+        expect(first.action).toBe('started');
+        burnCpu(30);
+        const second = await handleStdinLine('cpuprof', { autoStopMs: 10_000 });
+        expect(second).not.toBeInstanceOf(Error);
+        expect(second).not.toBeNull();
+        if (second instanceof Error || !second)
+            return;
+        expect(second.action).toBe('stopped');
+        expect(listProfiles(dataDir)).toHaveLength(1);
+    });
+    test('handleStdinLine ignores unrelated input', async () => {
+        expect(await handleStdinLine('help')).toBeNull();
+        expect(isCpuProfiling()).toBe(false);
+    });
+    test('stdin listener toggles on cpuprof lines', async () => {
+        const dataDir = makeDataDir();
+        const stdin = new PassThrough();
+        startStdinCpuProfListener({ stdin, autoStopMs: 10_000 });
+        stdin.write('cpuprof\n');
+        await waitUntil(() => isCpuProfiling());
+        burnCpu(30);
+        stdin.write('cpuprof\n');
+        await waitUntil(() => !isCpuProfiling());
+        expect(listProfiles(dataDir)).toHaveLength(1);
+        stopStdinCpuProfListener();
+    });
+});

package/dist/database.js

@@ -2,6 +2,9 @@
 // Stores thread-session mappings, bot tokens, channel directories,
 // API keys, and model preferences in <dataDir>/discord-sessions.db.
 import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as errore from 'errore';
 import * as orm from 'drizzle-orm';
 import { getDb, closeDb } from './db.js';
 import { createLogger, LogPrefix } from './logger.js';
@@ -324,6 +327,12 @@ export async function getSessionStartSourcesBySessionIds(sessionIds) {
     }
     return new Map(rows.map((row) => [row.session_id, row]));
 }
+export async function getSessionStartSource({ sessionId }) {
+    const db = await getDb();
+    return await db.query.session_start_sources.findFirst({
+        where: { session_id: sessionId },
+    }) ?? null;
+}
 export async function getChannelModel(channelId) {
     const db = await getDb();
     const row = await db.query.channel_models.findFirst({ where: { channel_id: channelId } });
@@ -792,6 +801,25 @@ export async function findChannelsByDirectory({ directory, channelType }) {
                 : undefined;
     return db.query.channel_directories.findMany({ where, columns: { channel_id: true, directory: true, channel_type: true, guild_id: true } });
 }
+function canonicalizeDirectory(directory) {
+    const resolved = path.resolve(directory);
+    const real = errore.try(() => fs.realpathSync(resolved), (e) => new Error('realpath failed', { cause: e }));
+    if (real instanceof Error)
+        return resolved;
+    return real;
+}
+export async function findRegisteredTextChannelForDirectory(directory) {
+    const wanted = canonicalizeDirectory(directory);
+    const channels = await findChannelsByDirectory({ channelType: 'text' });
+    return channels.find((ch) => canonicalizeDirectory(ch.directory) === wanted) ?? null;
+}
+export function formatProjectAlreadyRegisteredError({ channelId, directory, }) {
+    return [
+        `Channel already exists for this directory: ${directory}`,
+        `Channel ID: ${channelId}`,
+        `Remove the mapping first: kimaki project remove ${channelId}`,
+    ].join('\n');
+}
 export async function getAllTextChannelDirectories() {
     const db = await getDb();
     const rows = await db.query.channel_directories.findMany({ where: { channel_type: 'text' }, columns: { directory: true } });

package/dist/db.js

@@ -165,6 +165,17 @@ async function migrateSchema({ db, client, }) {
     for (const stmt of migrationStatements) {
         await client.execute(stmt).catch(() => undefined);
     }
+    // Existing part_messages tables never get a rewritten FK. Drop orphans.
+    // NOT EXISTS, not NOT IN: a NULL thread_sessions.thread_id would make
+    // NOT IN unknown for every row and skip the whole cleanup.
+    await client.execute(`
+    DELETE FROM part_messages
+    WHERE NOT EXISTS (
+      SELECT 1
+      FROM thread_sessions
+      WHERE thread_sessions.thread_id = part_messages.thread_id
+    )
+  `);
     await dropLegacySessionSleepsColumns(client);
     // Migrate legacy thread_worktrees rows into thread_workspaces.
     // Rows that already exist in thread_workspaces (by thread_id) are skipped.