kimaki 0.4.43 → 0.4.45

package/dist/commands/session.js

@@ -2,10 +2,9 @@
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { getDatabase } from '../database.js';
+import { getDatabase, getChannelDirectory } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
-import { extractTagsArrays } from '../xml.js';
 import { handleOpencodeSession } from '../session-handler.js';
 import { createLogger } from '../logger.js';
 import * as errore from 'errore';
@@ -21,16 +20,9 @@ export async function handleSessionCommand({ command, appId }) {
         return;
     }
     const textChannel = channel;
-    let projectDirectory;
-    let channelAppId;
-    if (textChannel.topic) {
-        const extracted = extractTagsArrays({
-            xml: textChannel.topic,
-            tags: ['kimaki.directory', 'kimaki.app'],
-        });
-        projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-        channelAppId = extracted['kimaki.app']?.[0]?.trim();
-    }
+    const channelConfig = getChannelDirectory(textChannel.id);
+    const projectDirectory = channelConfig?.directory;
+    const channelAppId = channelConfig?.appId || undefined;
     if (channelAppId && channelAppId !== appId) {
         await command.editReply('This channel is not configured for this bot');
         return;
@@ -83,22 +75,14 @@ export async function handleSessionCommand({ command, appId }) {
 async function handleAgentAutocomplete({ interaction, appId }) {
     const focusedValue = interaction.options.getFocused();
     let projectDirectory;
-    if (interaction.channel) {
-        const channel = interaction.channel;
-        if (channel.type === ChannelType.GuildText) {
-            const textChannel = channel;
-            if (textChannel.topic) {
-                const extracted = extractTagsArrays({
-                    xml: textChannel.topic,
-                    tags: ['kimaki.directory', 'kimaki.app'],
-                });
-                const channelAppId = extracted['kimaki.app']?.[0]?.trim();
-                if (channelAppId && channelAppId !== appId) {
-                    await interaction.respond([]);
-                    return;
-                }
-                projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+    if (interaction.channel && interaction.channel.type === ChannelType.GuildText) {
+        const channelConfig = getChannelDirectory(interaction.channel.id);
+        if (channelConfig) {
+            if (channelConfig.appId && channelConfig.appId !== appId) {
+                await interaction.respond([]);
+                return;
             }
+            projectDirectory = channelConfig.directory;
         }
     }
     if (!projectDirectory) {
@@ -150,22 +134,14 @@ export async function handleSessionAutocomplete({ interaction, appId, }) {
         .filter((f) => f);
     const currentQuery = (parts[parts.length - 1] || '').trim();
     let projectDirectory;
-    if (interaction.channel) {
-        const channel = interaction.channel;
-        if (channel.type === ChannelType.GuildText) {
-            const textChannel = channel;
-            if (textChannel.topic) {
-                const extracted = extractTagsArrays({
-                    xml: textChannel.topic,
-                    tags: ['kimaki.directory', 'kimaki.app'],
-                });
-                const channelAppId = extracted['kimaki.app']?.[0]?.trim();
-                if (channelAppId && channelAppId !== appId) {
-                    await interaction.respond([]);
-                    return;
-                }
-                projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+    if (interaction.channel && interaction.channel.type === ChannelType.GuildText) {
+        const channelConfig = getChannelDirectory(interaction.channel.id);
+        if (channelConfig) {
+            if (channelConfig.appId && channelConfig.appId !== appId) {
+                await interaction.respond([]);
+                return;
             }
+            projectDirectory = channelConfig.directory;
         }
     }
     if (!projectDirectory) {

package/dist/commands/user-command.js

@@ -1,11 +1,10 @@
 // User-defined OpenCode command handler.
 // Handles slash commands that map to user-configured commands in opencode.json.
 import { ChannelType } from 'discord.js';
-import { extractTagsArrays } from '../xml.js';
 import { handleOpencodeSession } from '../session-handler.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
-import { getDatabase } from '../database.js';
+import { getDatabase, getChannelDirectory } from '../database.js';
 import fs from 'node:fs';
 const userCommandLogger = createLogger('USER_CMD');
 export const handleUserCommand = async ({ command, appId }) => {
@@ -45,26 +44,18 @@ export const handleUserCommand = async ({ command, appId }) => {
             });
             return;
         }
-        if (textChannel?.topic) {
-            const extracted = extractTagsArrays({
-                xml: textChannel.topic,
-                tags: ['kimaki.directory', 'kimaki.app'],
-            });
-            projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-            channelAppId = extracted['kimaki.app']?.[0]?.trim();
+        if (textChannel) {
+            const channelConfig = getChannelDirectory(textChannel.id);
+            projectDirectory = channelConfig?.directory;
+            channelAppId = channelConfig?.appId || undefined;
         }
     }
     else {
         // Running in a text channel - will create a new thread
         textChannel = channel;
-        if (textChannel.topic) {
-            const extracted = extractTagsArrays({
-                xml: textChannel.topic,
-                tags: ['kimaki.directory', 'kimaki.app'],
-            });
-            projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-            channelAppId = extracted['kimaki.app']?.[0]?.trim();
-        }
+        const channelConfig = getChannelDirectory(textChannel.id);
+        projectDirectory = channelConfig?.directory;
+        channelAppId = channelConfig?.appId || undefined;
     }
     if (channelAppId && channelAppId !== appId) {
         await command.reply({

package/dist/commands/verbosity.js

@@ -0,0 +1,53 @@
+// /verbosity command.
+// Sets the output verbosity level for sessions in a channel.
+// 'tools-and-text' (default): shows all output including tool executions
+// 'text-only': only shows text responses (⬥ diamond parts)
+import { ChatInputCommandInteraction, ChannelType } from 'discord.js';
+import { getChannelVerbosity, setChannelVerbosity } from '../database.js';
+import { createLogger } from '../logger.js';
+const verbosityLogger = createLogger('VERBOSITY');
+/**
+ * Handle the /verbosity slash command.
+ * Sets output verbosity for the channel (applies to new sessions).
+ */
+export async function handleVerbosityCommand({ command, appId, }) {
+    verbosityLogger.log('[VERBOSITY] Command called');
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'Could not determine channel.',
+            ephemeral: true,
+        });
+        return;
+    }
+    // Get the parent channel ID (for threads, use parent; for text channels, use self)
+    const channelId = (() => {
+        if (channel.type === ChannelType.GuildText) {
+            return channel.id;
+        }
+        if (channel.type === ChannelType.PublicThread ||
+            channel.type === ChannelType.PrivateThread ||
+            channel.type === ChannelType.AnnouncementThread) {
+            return channel.parentId || channel.id;
+        }
+        return channel.id;
+    })();
+    const level = command.options.getString('level', true);
+    const currentLevel = getChannelVerbosity(channelId);
+    if (currentLevel === level) {
+        await command.reply({
+            content: `Verbosity is already set to **${level}**.`,
+            ephemeral: true,
+        });
+        return;
+    }
+    setChannelVerbosity(channelId, level);
+    verbosityLogger.log(`[VERBOSITY] Set channel ${channelId} to ${level}`);
+    const description = level === 'text-only'
+        ? 'Only text responses will be shown. Tool executions, status messages, and thinking will be hidden.'
+        : 'All output will be shown, including tool executions and status messages.';
+    await command.reply({
+        content: `Verbosity set to **${level}**.\n\n${description}\n\nThis applies to all new sessions in this channel.`,
+        ephemeral: true,
+    });
+}

package/dist/commands/worktree-settings.js

@@ -0,0 +1,88 @@
+// /enable-worktrees and /disable-worktrees commands.
+// Allows per-channel opt-in for automatic worktree creation,
+// as an alternative to the global --use-worktrees CLI flag.
+import { ChatInputCommandInteraction, ChannelType } from 'discord.js';
+import { getChannelWorktreesEnabled, setChannelWorktreesEnabled } from '../database.js';
+import { getKimakiMetadata } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const worktreeSettingsLogger = createLogger('WORKTREE_SETTINGS');
+/**
+ * Handle the /enable-worktrees slash command.
+ * Enables automatic worktree creation for new sessions in this channel.
+ */
+export async function handleEnableWorktreesCommand({ command, appId, }) {
+    worktreeSettingsLogger.log('[ENABLE_WORKTREES] Command called');
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.reply({
+            content: 'This command can only be used in text channels (not threads).',
+            ephemeral: true,
+        });
+        return;
+    }
+    const textChannel = channel;
+    const metadata = getKimakiMetadata(textChannel);
+    if (metadata.channelAppId && metadata.channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is configured for a different bot.',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!metadata.projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory.\nUse `/add-project` to set up this channel.',
+            ephemeral: true,
+        });
+        return;
+    }
+    const wasEnabled = getChannelWorktreesEnabled(textChannel.id);
+    setChannelWorktreesEnabled(textChannel.id, true);
+    worktreeSettingsLogger.log(`[ENABLE_WORKTREES] Enabled for channel ${textChannel.id}`);
+    await command.reply({
+        content: wasEnabled
+            ? `Worktrees are already enabled for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will automatically create git worktrees.`
+            : `Worktrees **enabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will now automatically create git worktrees.\n\nUse \`/disable-worktrees\` to turn this off.`,
+        ephemeral: true,
+    });
+}
+/**
+ * Handle the /disable-worktrees slash command.
+ * Disables automatic worktree creation for new sessions in this channel.
+ */
+export async function handleDisableWorktreesCommand({ command, appId, }) {
+    worktreeSettingsLogger.log('[DISABLE_WORKTREES] Command called');
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.reply({
+            content: 'This command can only be used in text channels (not threads).',
+            ephemeral: true,
+        });
+        return;
+    }
+    const textChannel = channel;
+    const metadata = getKimakiMetadata(textChannel);
+    if (metadata.channelAppId && metadata.channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is configured for a different bot.',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!metadata.projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory.\nUse `/add-project` to set up this channel.',
+            ephemeral: true,
+        });
+        return;
+    }
+    const wasEnabled = getChannelWorktreesEnabled(textChannel.id);
+    setChannelWorktreesEnabled(textChannel.id, false);
+    worktreeSettingsLogger.log(`[DISABLE_WORKTREES] Disabled for channel ${textChannel.id}`);
+    await command.reply({
+        content: wasEnabled
+            ? `Worktrees **disabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will use the main project directory.\n\nUse \`/enable-worktrees\` to turn this back on.`
+            : `Worktrees are already disabled for this channel.\n\nNew sessions will use the main project directory.`,
+        ephemeral: true,
+    });
+}

package/dist/commands/worktree.js

@@ -3,11 +3,12 @@
 // Creates thread immediately, then worktree in background so user can type
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
-import { createPendingWorktree, setWorktreeReady, setWorktreeError, } from '../database.js';
+import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadWorktree, } from '../database.js';
 import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
-import { extractTagsArrays } from '../xml.js';
 import { createLogger } from '../logger.js';
+import { createWorktreeWithSubmodules } from '../worktree-utils.js';
+import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
 const logger = createLogger('WORKTREE');
 class WorktreeError extends Error {
@@ -17,68 +18,69 @@ class WorktreeError extends Error {
     }
 }
 /**
- * Format worktree name: lowercase, spaces to dashes, remove special chars, add kimaki- prefix.
- * "My Feature" → "kimaki-my-feature"
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/kimaki- prefix.
+ * "My Feature" → "opencode/kimaki-my-feature"
+ * Returns empty string if no valid name can be extracted.
  */
-function formatWorktreeName(name) {
+export function formatWorktreeName(name) {
     const formatted = name
         .toLowerCase()
         .trim()
         .replace(/\s+/g, '-')
         .replace(/[^a-z0-9-]/g, '');
-    return `kimaki-${formatted}`;
+    if (!formatted) {
+        return '';
+    }
+    return `opencode/kimaki-${formatted}`;
+}
+/**
+ * Derive worktree name from thread name.
+ * Handles existing "⬦ worktree: opencode/kimaki-name" format or uses thread name directly.
+ */
+function deriveWorktreeNameFromThread(threadName) {
+    // Handle existing "⬦ worktree: opencode/kimaki-name" format
+    const worktreeMatch = threadName.match(/worktree:\s*(.+)$/i);
+    const extractedName = worktreeMatch?.[1]?.trim();
+    if (extractedName) {
+        // If already has opencode/kimaki- prefix, return as is
+        if (extractedName.startsWith('opencode/kimaki-')) {
+            return extractedName;
+        }
+        return formatWorktreeName(extractedName);
+    }
+    // Use thread name directly
+    return formatWorktreeName(threadName);
 }
 /**
- * Get project directory from channel topic.
+ * Get project directory from database.
  */
 function getProjectDirectoryFromChannel(channel, appId) {
-    if (!channel.topic) {
-        return new WorktreeError('This channel has no topic configured');
+    const channelConfig = getChannelDirectory(channel.id);
+    if (!channelConfig) {
+        return new WorktreeError('This channel is not configured with a project directory');
     }
-    const extracted = extractTagsArrays({
-        xml: channel.topic,
-        tags: ['kimaki.directory', 'kimaki.app'],
-    });
-    const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
-    const channelAppId = extracted['kimaki.app']?.[0]?.trim();
-    if (channelAppId && channelAppId !== appId) {
+    if (channelConfig.appId && channelConfig.appId !== appId) {
         return new WorktreeError('This channel is not configured for this bot');
     }
-    if (!projectDirectory) {
-        return new WorktreeError('This channel is not configured with a project directory');
+    if (!fs.existsSync(channelConfig.directory)) {
+        return new WorktreeError(`Directory does not exist: ${channelConfig.directory}`);
     }
-    if (!fs.existsSync(projectDirectory)) {
-        return new WorktreeError(`Directory does not exist: ${projectDirectory}`);
-    }
-    return projectDirectory;
+    return channelConfig.directory;
 }
 /**
  * Create worktree in background and update starter message when done.
  */
 async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, clientV2, }) {
-    // Create worktree using SDK v2
+    // Create worktree using SDK v2 and init submodules
     logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}`);
-    const worktreeResult = await errore.tryAsync({
-        try: async () => {
-            const response = await clientV2.worktree.create({
-                directory: projectDirectory,
-                worktreeCreateInput: {
-                    name: worktreeName,
-                },
-            });
-            if (response.error) {
-                throw new Error(`SDK error: ${JSON.stringify(response.error)}`);
-            }
-            if (!response.data) {
-                throw new Error('No worktree data returned from SDK');
-            }
-            return response.data;
-        },
-        catch: (e) => new WorktreeError('Failed to create worktree', { cause: e }),
+    const worktreeResult = await createWorktreeWithSubmodules({
+        clientV2,
+        directory: projectDirectory,
+        name: worktreeName,
     });
-    if (errore.isError(worktreeResult)) {
+    if (worktreeResult instanceof Error) {
         const errorMsg = worktreeResult.message;
-        logger.error('[NEW-WORKTREE] Error:', worktreeResult.cause);
+        logger.error('[NEW-WORKTREE] Error:', worktreeResult);
         setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
         await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
         return;
@@ -91,15 +93,30 @@ async function createWorktreeInBackground({ thread, starterMessage, worktreeName
 }
 export async function handleNewWorktreeCommand({ command, appId, }) {
     await command.deferReply({ ephemeral: false });
-    const rawName = command.options.getString('name', true);
-    const worktreeName = formatWorktreeName(rawName);
-    if (worktreeName === 'kimaki-') {
-        await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.');
+    const channel = command.channel;
+    if (!channel) {
+        await command.editReply('Cannot determine channel');
         return;
     }
-    const channel = command.channel;
-    if (!channel || channel.type !== ChannelType.GuildText) {
-        await command.editReply('This command can only be used in text channels');
+    const isThread = channel.type === ChannelType.PublicThread || channel.type === ChannelType.PrivateThread;
+    // Handle command in existing thread - attach worktree to this thread
+    if (isThread) {
+        await handleWorktreeInThread({ command, appId, thread: channel });
+        return;
+    }
+    // Handle command in text channel - create new thread with worktree (existing behavior)
+    if (channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in text channels or threads');
+        return;
+    }
+    const rawName = command.options.getString('name');
+    if (!rawName) {
+        await command.editReply('Name is required when creating a worktree from a text channel. Use `/new-worktree name:my-feature`');
+        return;
+    }
+    const worktreeName = formatWorktreeName(rawName);
+    if (!worktreeName) {
+        await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.');
         return;
     }
     const textChannel = channel;
@@ -146,7 +163,7 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
                 flags: SILENT_MESSAGE_FLAGS,
             });
             const thread = await starterMessage.startThread({
-                name: `worktree: ${worktreeName}`,
+                name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`,
                 autoArchiveDuration: 1440,
                 reason: 'Worktree session',
             });
@@ -178,3 +195,82 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
         logger.error('[NEW-WORKTREE] Background error:', e);
     });
 }
+/**
+ * Handle /new-worktree when called inside an existing thread.
+ * Attaches a worktree to the current thread, using thread name if no name provided.
+ */
+async function handleWorktreeInThread({ command, appId, thread, }) {
+    // Error if thread already has a worktree
+    if (getThreadWorktree(thread.id)) {
+        await command.editReply('This thread already has a worktree attached.');
+        return;
+    }
+    // Get worktree name from parameter or derive from thread name
+    const rawName = command.options.getString('name');
+    const worktreeName = rawName ? formatWorktreeName(rawName) : deriveWorktreeNameFromThread(thread.name);
+    if (!worktreeName) {
+        await command.editReply('Invalid worktree name. Please provide a name or rename the thread.');
+        return;
+    }
+    // Get parent channel for project directory
+    const parent = thread.parent;
+    if (!parent || parent.type !== ChannelType.GuildText) {
+        await command.editReply('Cannot determine parent channel');
+        return;
+    }
+    const projectDirectory = getProjectDirectoryFromChannel(parent, appId);
+    if (errore.isError(projectDirectory)) {
+        await command.editReply(projectDirectory.message);
+        return;
+    }
+    // Initialize opencode
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (errore.isError(getClient)) {
+        await command.editReply(`Failed to initialize OpenCode: ${getClient.message}`);
+        return;
+    }
+    const clientV2 = getOpencodeClientV2(projectDirectory);
+    if (!clientV2) {
+        await command.editReply('Failed to get OpenCode client');
+        return;
+    }
+    // Check if worktree with this name already exists
+    const listResult = await errore.tryAsync({
+        try: async () => {
+            const response = await clientV2.worktree.list({ directory: projectDirectory });
+            return response.data || [];
+        },
+        catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
+    });
+    if (errore.isError(listResult)) {
+        await command.editReply(listResult.message);
+        return;
+    }
+    const existingWorktreePath = listResult.find((dir) => dir.endsWith(`/${worktreeName}`));
+    if (existingWorktreePath) {
+        await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``);
+        return;
+    }
+    // Store pending worktree in database for this existing thread
+    createPendingWorktree({
+        threadId: thread.id,
+        worktreeName,
+        projectDirectory,
+    });
+    // Send status message in thread
+    const statusMessage = await thread.send({
+        content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`);
+    // Create worktree in background
+    createWorktreeInBackground({
+        thread,
+        starterMessage: statusMessage,
+        worktreeName,
+        projectDirectory,
+        clientV2,
+    }).catch((e) => {
+        logger.error('[NEW-WORKTREE] Background error:', e);
+    });
+}

package/dist/database.js

@@ -90,6 +90,8 @@ export function getDatabase() {
       )
     `);
         runModelMigrations(db);
+        runWorktreeSettingsMigrations(db);
+        runVerbosityMigrations(db);
     }
     return db;
 }
@@ -250,6 +252,89 @@ export function deleteThreadWorktree(threadId) {
     const db = getDatabase();
     db.prepare('DELETE FROM thread_worktrees WHERE thread_id = ?').run(threadId);
 }
+/**
+ * Run migrations for channel worktree settings table.
+ * Called on startup. Allows per-channel opt-in for automatic worktree creation.
+ */
+export function runWorktreeSettingsMigrations(database) {
+    const targetDb = database || getDatabase();
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_worktrees (
+      channel_id TEXT PRIMARY KEY,
+      enabled INTEGER NOT NULL DEFAULT 0,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    dbLogger.log('Channel worktree settings migrations complete');
+}
+export function runVerbosityMigrations(database) {
+    const targetDb = database || getDatabase();
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_verbosity (
+      channel_id TEXT PRIMARY KEY,
+      verbosity TEXT NOT NULL DEFAULT 'tools-and-text',
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    dbLogger.log('Channel verbosity settings migrations complete');
+}
+/**
+ * Get the verbosity setting for a channel.
+ * @returns 'tools-and-text' (default) or 'text-only'
+ */
+export function getChannelVerbosity(channelId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT verbosity FROM channel_verbosity WHERE channel_id = ?')
+        .get(channelId);
+    return row?.verbosity || 'tools-and-text';
+}
+/**
+ * Set the verbosity setting for a channel.
+ */
+export function setChannelVerbosity(channelId, verbosity) {
+    const db = getDatabase();
+    db.prepare(`INSERT INTO channel_verbosity (channel_id, verbosity, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET verbosity = ?, updated_at = CURRENT_TIMESTAMP`).run(channelId, verbosity, verbosity);
+}
+/**
+ * Check if automatic worktree creation is enabled for a channel.
+ */
+export function getChannelWorktreesEnabled(channelId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT enabled FROM channel_worktrees WHERE channel_id = ?')
+        .get(channelId);
+    return row?.enabled === 1;
+}
+/**
+ * Enable or disable automatic worktree creation for a channel.
+ */
+export function setChannelWorktreesEnabled(channelId, enabled) {
+    const db = getDatabase();
+    db.prepare(`INSERT INTO channel_worktrees (channel_id, enabled, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET enabled = ?, updated_at = CURRENT_TIMESTAMP`).run(channelId, enabled ? 1 : 0, enabled ? 1 : 0);
+}
+/**
+ * Get the directory and app_id for a channel from the database.
+ * This is the single source of truth for channel-project mappings.
+ */
+export function getChannelDirectory(channelId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT directory, app_id FROM channel_directories WHERE channel_id = ?')
+        .get(channelId);
+    if (!row) {
+        return undefined;
+    }
+    return {
+        directory: row.directory,
+        appId: row.app_id,
+    };
+}
 export function closeDatabase() {
     if (db) {
         db.close();