kimaki 0.4.35 → 0.4.37

package/src/cli.ts

@@ -41,7 +41,6 @@ import {
 import path from 'node:path'
 import fs from 'node:fs'
 
-
 import { createLogger } from './logger.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 import http from 'node:http'
@@ -60,11 +59,22 @@ async function killProcessOnPort(port: number): Promise<boolean> {
   try {
     if (isWindows) {
       // Windows: find PID using netstat, then kill
-      const result = spawnSync('cmd', ['/c', `for /f "tokens=5" %a in ('netstat -ano ^| findstr :${port} ^| findstr LISTENING') do @echo %a`], {
-        shell: false,
-        encoding: 'utf-8',
-      })
-      const pids = result.stdout?.trim().split('\n').map((p) => p.trim()).filter((p) => /^\d+$/.test(p))
+      const result = spawnSync(
+        'cmd',
+        [
+          '/c',
+          `for /f "tokens=5" %a in ('netstat -ano ^| findstr :${port} ^| findstr LISTENING') do @echo %a`,
+        ],
+        {
+          shell: false,
+          encoding: 'utf-8',
+        },
+      )
+      const pids = result.stdout
+        ?.trim()
+        .split('\n')
+        .map((p) => p.trim())
+        .filter((p) => /^\d+$/.test(p))
       // Filter out our own PID and take the first (oldest)
       const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid)
       if (targetPid) {
@@ -78,7 +88,11 @@ async function killProcessOnPort(port: number): Promise<boolean> {
         shell: false,
         encoding: 'utf-8',
       })
-      const pids = result.stdout?.trim().split('\n').map((p) => p.trim()).filter((p) => /^\d+$/.test(p))
+      const pids = result.stdout
+        ?.trim()
+        .split('\n')
+        .map((p) => p.trim())
+        .filter((p) => /^\d+$/.test(p))
       // Filter out our own PID and take the first (oldest)
       const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid)
       if (targetPid) {
@@ -104,7 +118,9 @@ async function checkSingleInstance(): Promise<void> {
       cliLogger.log(`Another kimaki instance detected for data dir: ${getDataDir()}`)
       await killProcessOnPort(lockPort)
       // Wait a moment for port to be released
-      await new Promise((resolve) => { setTimeout(resolve, 500) })
+      await new Promise((resolve) => {
+        setTimeout(resolve, 500)
+      })
     }
   } catch {
     cliLogger.debug('No other kimaki instance detected on lock port')
@@ -127,7 +143,9 @@ async function startLockServer(): Promise<void> {
       if (err.code === 'EADDRINUSE') {
         cliLogger.log('Port still in use, retrying...')
         await killProcessOnPort(lockPort)
-        await new Promise((r) => { setTimeout(r, 500) })
+        await new Promise((r) => {
+          setTimeout(r, 500)
+        })
         // Retry once
         server.listen(lockPort, '127.0.0.1')
       } else {
@@ -137,8 +155,6 @@ async function startLockServer(): Promise<void> {
   })
 }
 
-
-
 const EXIT_NO_RESTART = 64
 
 type Project = {
@@ -160,7 +176,11 @@ type CliOptions = {
 // Commands to skip when registering user commands (reserved names)
 const SKIP_USER_COMMANDS = ['init']
 
-async function registerCommands(token: string, appId: string, userCommands: OpencodeCommand[] = []) {
+async function registerCommands(
+  token: string,
+  appId: string,
+  userCommands: OpencodeCommand[] = [],
+) {
   const commands = [
     new SlashCommandBuilder()
       .setName('resume')
@@ -179,19 +199,14 @@ async function registerCommands(token: string, appId: string, userCommands: Open
       .setName('session')
       .setDescription('Start a new OpenCode session')
       .addStringOption((option) => {
-        option
-          .setName('prompt')
-          .setDescription('Prompt content for the session')
-          .setRequired(true)
+        option.setName('prompt').setDescription('Prompt content for the session').setRequired(true)
 
         return option
       })
       .addStringOption((option) => {
         option
           .setName('files')
-          .setDescription(
-            'Files to mention (comma or space separated; autocomplete)',
-          )
+          .setDescription('Files to mention (comma or space separated; autocomplete)')
           .setAutocomplete(true)
           .setMaxLength(6000)
 
@@ -220,13 +235,23 @@ async function registerCommands(token: string, appId: string, userCommands: Open
       })
       .toJSON(),
     new SlashCommandBuilder()
-      .setName('create-new-project')
-      .setDescription('Create a new project folder, initialize git, and start a session')
+      .setName('remove-project')
+      .setDescription('Remove Discord channels for a project')
       .addStringOption((option) => {
         option
-          .setName('name')
-          .setDescription('Name for the new project folder')
+          .setName('project')
+          .setDescription('Select a project to remove')
           .setRequired(true)
+          .setAutocomplete(true)
+
+        return option
+      })
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('create-new-project')
+      .setDescription('Create a new project folder, initialize git, and start a session')
+      .addStringOption((option) => {
+        option.setName('name').setDescription('Name for the new project folder').setRequired(true)
 
         return option
       })
@@ -259,10 +284,7 @@ async function registerCommands(token: string, appId: string, userCommands: Open
       .setName('queue')
       .setDescription('Queue a message to be sent after the current response finishes')
       .addStringOption((option) => {
-        option
-          .setName('message')
-          .setDescription('The message to queue')
-          .setRequired(true)
+        option.setName('message').setDescription('The message to queue').setRequired(true)
 
         return option
       })
@@ -294,7 +316,7 @@ async function registerCommands(token: string, appId: string, userCommands: Open
 
     commands.push(
       new SlashCommandBuilder()
-        .setName(commandName)
+        .setName(commandName.slice(0, 32)) // Discord limits to 32 chars
         .setDescription(description.slice(0, 100)) // Discord limits to 100 chars
         .addStringOption((option) => {
           option
@@ -314,19 +336,13 @@ async function registerCommands(token: string, appId: string, userCommands: Open
       body: commands,
     })) as any[]
 
-    cliLogger.info(
-      `COMMANDS: Successfully registered ${data.length} slash commands`,
-    )
+    cliLogger.info(`COMMANDS: Successfully registered ${data.length} slash commands`)
   } catch (error) {
-    cliLogger.error(
-      'COMMANDS: Failed to register slash commands: ' + String(error),
-    )
+    cliLogger.error('COMMANDS: Failed to register slash commands: ' + String(error))
     throw error
   }
 }
 
-
-
 async function run({ restart, addChannels }: CliOptions) {
   const forceSetup = Boolean(restart)
 
@@ -336,10 +352,7 @@ async function run({ restart, addChannels }: CliOptions) {
   const opencodeCheck = spawnSync('which', ['opencode'], { shell: true })
 
   if (opencodeCheck.status !== 0) {
-    note(
-      'OpenCode CLI is required but not found in your PATH.',
-      '⚠️  OpenCode Not Found',
-    )
+    note('OpenCode CLI is required but not found in your PATH.', '⚠️  OpenCode Not Found')
 
     const shouldInstall = await confirm({
       message: 'Would you like to install OpenCode right now?',
@@ -391,10 +404,7 @@ async function run({ restart, addChannels }: CliOptions) {
       process.env.OPENCODE_PATH = installedPath
     } catch (error) {
       s.stop('Failed to install OpenCode CLI')
-      cliLogger.error(
-        'Installation error:',
-        error instanceof Error ? error.message : String(error),
-      )
+      cliLogger.error('Installation error:', error instanceof Error ? error.message : String(error))
       process.exit(EXIT_NO_RESTART)
     }
   }
@@ -404,13 +414,10 @@ async function run({ restart, addChannels }: CliOptions) {
   let token: string
 
   const existingBot = db
-    .prepare(
-      'SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1',
-    )
+    .prepare('SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
     .get() as { app_id: string; token: string } | undefined
 
-  const shouldAddChannels =
-    !existingBot?.token || forceSetup || Boolean(addChannels)
+  const shouldAddChannels = !existingBot?.token || forceSetup || Boolean(addChannels)
 
   if (existingBot && !forceSetup) {
     appId = existingBot.app_id
@@ -481,8 +488,7 @@ async function run({ restart, addChannels }: CliOptions) {
       'Step 3: Get Bot Token',
     )
     const tokenInput = await password({
-      message:
-        'Enter your Discord Bot Token (from "Bot" section - click "Reset Token" if needed):',
+      message: 'Enter your Discord Bot Token (from "Bot" section - click "Reset Token" if needed):',
       validate(value) {
         if (!value) return 'Bot token is required'
         if (value.length < 50) return 'Invalid token format (too short)'
@@ -495,10 +501,7 @@ async function run({ restart, addChannels }: CliOptions) {
     }
     token = tokenInput
 
-    note(
-      `You can get a Gemini api Key at https://aistudio.google.com/apikey`,
-      `Gemini API Key`,
-    )
+    note(`You can get a Gemini api Key at https://aistudio.google.com/apikey`, `Gemini API Key`)
 
     const geminiApiKey = await password({
       message:
@@ -516,9 +519,10 @@ async function run({ restart, addChannels }: CliOptions) {
 
     // Store API key in database
     if (geminiApiKey) {
-      db.prepare(
-        'INSERT OR REPLACE INTO bot_api_keys (app_id, gemini_api_key) VALUES (?, ?)',
-      ).run(appId, geminiApiKey || null)
+      db.prepare('INSERT OR REPLACE INTO bot_api_keys (app_id, gemini_api_key) VALUES (?, ?)').run(
+        appId,
+        geminiApiKey || null,
+      )
       note('API key saved successfully', 'API Key Stored')
     }
 
@@ -565,9 +569,7 @@ async function run({ restart, addChannels }: CliOptions) {
             guild.roles
               .fetch()
               .then(async (roles) => {
-                const existingRole = roles.find(
-                  (role) => role.name.toLowerCase() === 'kimaki',
-                )
+                const existingRole = roles.find((role) => role.name.toLowerCase() === 'kimaki')
                 if (existingRole) {
                   // Move to bottom if not already there
                   if (existingRole.position > 1) {
@@ -596,8 +598,7 @@ async function run({ restart, addChannels }: CliOptions) {
 
             const channels = await getChannelsWithDescriptions(guild)
             const kimakiChans = channels.filter(
-              (ch) =>
-                ch.kimakiDirectory && (!ch.kimakiApp || ch.kimakiApp === appId),
+              (ch) => ch.kimakiDirectory && (!ch.kimakiApp || ch.kimakiApp === appId),
             )
 
             return { guild, channels: kimakiChans }
@@ -622,31 +623,26 @@ async function run({ restart, addChannels }: CliOptions) {
     s.stop('Connected to Discord!')
   } catch (error) {
     s.stop('Failed to connect to Discord')
-    cliLogger.error(
-      'Error: ' + (error instanceof Error ? error.message : String(error)),
-    )
+    cliLogger.error('Error: ' + (error instanceof Error ? error.message : String(error)))
     process.exit(EXIT_NO_RESTART)
   }
-  db.prepare(
-    'INSERT OR REPLACE INTO bot_tokens (app_id, token) VALUES (?, ?)',
-  ).run(appId, token)
+  db.prepare('INSERT OR REPLACE INTO bot_tokens (app_id, token) VALUES (?, ?)').run(appId, token)
 
   for (const { guild, channels } of kimakiChannels) {
     for (const channel of channels) {
       if (channel.kimakiDirectory) {
         db.prepare(
-          'INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
-        ).run(channel.id, channel.kimakiDirectory, 'text')
+          'INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)',
+        ).run(channel.id, channel.kimakiDirectory, 'text', channel.kimakiApp || null)
 
         const voiceChannel = guild.channels.cache.find(
-          (ch) =>
-            ch.type === ChannelType.GuildVoice && ch.name === channel.name,
+          (ch) => ch.type === ChannelType.GuildVoice && ch.name === channel.name,
         )
 
         if (voiceChannel) {
           db.prepare(
-            'INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
-          ).run(voiceChannel.id, channel.kimakiDirectory, 'voice')
+            'INSERT OR IGNORE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)',
+          ).run(voiceChannel.id, channel.kimakiDirectory, 'voice', channel.kimakiApp || null)
         }
       }
     }
@@ -657,11 +653,7 @@ async function run({ restart, addChannels }: CliOptions) {
       .flatMap(({ guild, channels }) =>
         channels.map((ch) => {
           const appInfo =
-            ch.kimakiApp === appId
-              ? ' (this bot)'
-              : ch.kimakiApp
-                ? ` (app: ${ch.kimakiApp})`
-                : ''
+            ch.kimakiApp === appId ? ' (this bot)' : ch.kimakiApp ? ` (app: ${ch.kimakiApp})` : ''
           return `#${ch.name} in ${guild.name}: ${ch.kimakiDirectory}${appInfo}`
         }),
       )
@@ -679,13 +671,19 @@ async function run({ restart, addChannels }: CliOptions) {
 
   // Fetch projects and commands in parallel
   const [projects, allUserCommands] = await Promise.all([
-    getClient().project.list({}).then((r) => r.data || []).catch((error) => {
-      s.stop('Failed to fetch projects')
-      cliLogger.error('Error:', error instanceof Error ? error.message : String(error))
-      discordClient.destroy()
-      process.exit(EXIT_NO_RESTART)
-    }),
-    getClient().command.list({ query: { directory: currentDir } }).then((r) => r.data || []).catch(() => []),
+    getClient()
+      .project.list({})
+      .then((r) => r.data || [])
+      .catch((error) => {
+        s.stop('Failed to fetch projects')
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error))
+        discordClient.destroy()
+        process.exit(EXIT_NO_RESTART)
+      }),
+    getClient()
+      .command.list({ query: { directory: currentDir } })
+      .then((r) => r.data || [])
+      .catch(() => []),
   ])
 
   s.stop(`Found ${projects.length} OpenCode project(s)`)
@@ -711,16 +709,10 @@ async function run({ restart, addChannels }: CliOptions) {
   )
 
   if (availableProjects.length === 0) {
-    note(
-      'All OpenCode projects already have Discord channels',
-      'No New Projects',
-    )
+    note('All OpenCode projects already have Discord channels', 'No New Projects')
   }
 
-  if (
-    (!existingDirs?.length && availableProjects.length > 0) ||
-    shouldAddChannels
-  ) {
+  if ((!existingDirs?.length && availableProjects.length > 0) || shouldAddChannels) {
     const selectedProjects = await multiselect({
       message: 'Select projects to create Discord channels for:',
       options: availableProjects.map((project) => ({
@@ -781,17 +773,17 @@ async function run({ restart, addChannels }: CliOptions) {
             guildId: targetGuild.id,
           })
         } catch (error) {
-          cliLogger.error(`Failed to create channels for ${path.basename(project.worktree)}:`, error)
+          cliLogger.error(
+            `Failed to create channels for ${path.basename(project.worktree)}:`,
+            error,
+          )
         }
       }
 
       s.stop(`Created ${createdChannels.length} channel(s)`)
 
       if (createdChannels.length > 0) {
-        note(
-          createdChannels.map((ch) => `#${ch.name}`).join('\n'),
-          'Created Channels',
-        )
+        note(createdChannels.map((ch) => `#${ch.name}`).join('\n'), 'Created Channels')
       }
     }
   }
@@ -850,10 +842,7 @@ async function run({ restart, addChannels }: CliOptions) {
 
   if (allChannels.length > 0) {
     const channelLinks = allChannels
-      .map(
-        (ch) =>
-          `• #${ch.name}: https://discord.com/channels/${ch.guildId}/${ch.id}`,
-      )
+      .map((ch) => `• #${ch.name}: https://discord.com/channels/${ch.guildId}/${ch.id}`)
       .join('\n')
 
     note(
@@ -862,63 +851,62 @@ async function run({ restart, addChannels }: CliOptions) {
     )
   }
 
-  outro('✨ Setup complete!')
+  note(
+    'Leave this process running to keep the bot active.\n\nIf you close this process or restart your machine, run `npx kimaki` again to start the bot.',
+    '⚠️  Keep Running',
+  )
+
+  outro('✨ Setup complete! Listening for new messages... do not close this process.')
 }
 
 cli
   .command('', 'Set up and run the Kimaki Discord bot')
   .option('--restart', 'Prompt for new credentials even if saved')
-  .option(
-    '--add-channels',
-    'Select OpenCode projects to create Discord channels before starting',
-  )
-  .option(
-    '--data-dir <path>',
-    'Data directory for config and database (default: ~/.kimaki)',
-  )
+  .option('--add-channels', 'Select OpenCode projects to create Discord channels before starting')
+  .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
   .option('--install-url', 'Print the bot install URL and exit')
-  .action(async (options: { restart?: boolean; addChannels?: boolean; dataDir?: string; installUrl?: boolean }) => {
-    try {
-      // Set data directory early, before any database access
-      if (options.dataDir) {
-        setDataDir(options.dataDir)
-        cliLogger.log(`Using data directory: ${getDataDir()}`)
-      }
+  .action(
+    async (options: {
+      restart?: boolean
+      addChannels?: boolean
+      dataDir?: string
+      installUrl?: boolean
+    }) => {
+      try {
+        // Set data directory early, before any database access
+        if (options.dataDir) {
+          setDataDir(options.dataDir)
+          cliLogger.log(`Using data directory: ${getDataDir()}`)
+        }
 
-      if (options.installUrl) {
-        const db = getDatabase()
-        const existingBot = db
-          .prepare(
-            'SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1',
-          )
-          .get() as { app_id: string } | undefined
+        if (options.installUrl) {
+          const db = getDatabase()
+          const existingBot = db
+            .prepare('SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+            .get() as { app_id: string } | undefined
 
-        if (!existingBot) {
-          cliLogger.error('No bot configured yet. Run `kimaki` first to set up.')
-          process.exit(EXIT_NO_RESTART)
+          if (!existingBot) {
+            cliLogger.error('No bot configured yet. Run `kimaki` first to set up.')
+            process.exit(EXIT_NO_RESTART)
+          }
+
+          console.log(generateBotInstallUrl({ clientId: existingBot.app_id }))
+          process.exit(0)
         }
 
-        console.log(generateBotInstallUrl({ clientId: existingBot.app_id }))
-        process.exit(0)
+        await checkSingleInstance()
+        await startLockServer()
+        await run({
+          restart: options.restart,
+          addChannels: options.addChannels,
+          dataDir: options.dataDir,
+        })
+      } catch (error) {
+        cliLogger.error('Unhandled error:', error instanceof Error ? error.message : String(error))
+        process.exit(EXIT_NO_RESTART)
       }
-      
-      await checkSingleInstance()
-      await startLockServer()
-      await run({
-        restart: options.restart,
-        addChannels: options.addChannels,
-        dataDir: options.dataDir,
-      })
-    } catch (error) {
-      cliLogger.error(
-        'Unhandled error:',
-        error instanceof Error ? error.message : String(error),
-      )
-      process.exit(EXIT_NO_RESTART)
-    }
-  })
-
-
+    },
+  )
 
 cli
   .command('upload-to-discord [...files]', 'Upload files to a Discord thread for a session')
@@ -957,9 +945,7 @@ cli
       }
 
       const botRow = db
-        .prepare(
-          'SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1',
-        )
+        .prepare('SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
         .get() as { app_id: string; token: string } | undefined
 
       if (!botRow) {
@@ -974,9 +960,12 @@ cli
         const buffer = fs.readFileSync(file)
 
         const formData = new FormData()
-        formData.append('payload_json', JSON.stringify({
-          attachments: [{ id: 0, filename: path.basename(file) }]
-        }))
+        formData.append(
+          'payload_json',
+          JSON.stringify({
+            attachments: [{ id: 0, filename: path.basename(file) }],
+          }),
+        )
         formData.append('files[0]', new Blob([buffer]), path.basename(file))
 
         const response = await fetch(
@@ -984,10 +973,10 @@ cli
           {
             method: 'POST',
             headers: {
-              'Authorization': `Bot ${botRow.token}`,
+              Authorization: `Bot ${botRow.token}`,
             },
             body: formData,
-          }
+          },
         )
 
         if (!response.ok) {
@@ -1005,38 +994,61 @@ cli
 
       process.exit(0)
     } catch (error) {
-      cliLogger.error(
-        'Error:',
-        error instanceof Error ? error.message : String(error),
-      )
+      cliLogger.error('Error:', error instanceof Error ? error.message : String(error))
       process.exit(EXIT_NO_RESTART)
     }
   })
 
-
 // Magic prefix used to identify bot-initiated sessions.
 // The running bot will recognize this prefix and start a session.
 const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**'
+// Notify-only prefix - bot won't start a session, just creates thread for notifications.
+// Reply to the thread to start a session with the notification as context.
+const BOT_NOTIFY_PREFIX = '📢 **Notification**'
 
 cli
-  .command('start-session', 'Start a new session in a Discord channel (creates thread, bot handles the rest)')
+  .command(
+    'send',
+    'Send a message to Discord channel, creating a thread. Use --notify-only to skip AI session.',
+  )
+  .alias('start-session') // backwards compatibility
   .option('-c, --channel <channelId>', 'Discord channel ID')
-  .option('-p, --prompt <prompt>', 'Initial prompt for the session')
+  .option('-d, --project <path>', 'Project directory (alternative to --channel)')
+  .option('-p, --prompt <prompt>', 'Message content')
   .option('-n, --name [name]', 'Thread name (optional, defaults to prompt preview)')
   .option('-a, --app-id [appId]', 'Bot application ID (required if no local database)')
-  .action(async (options: { channel?: string; prompt?: string; name?: string; appId?: string }) => {
-    try {
-      const { channel: channelId, prompt, name, appId: optionAppId } = options
+  .option('--notify-only', 'Create notification thread without starting AI session')
+  .action(
+    async (options: {
+      channel?: string
+      project?: string
+      prompt?: string
+      name?: string
+      appId?: string
+      notifyOnly?: boolean
+    }) => {
+      try {
+        let { channel: channelId, prompt, name, appId: optionAppId, notifyOnly } = options
+        const { project: projectPath } = options
+        
+        // Get raw channel ID from argv to prevent JS number precision loss on large Discord IDs
+        // cac parses large numbers and loses precision, so we extract the original string value
+        if (channelId) {
+          const channelArgIndex = process.argv.findIndex((arg) => arg === '--channel' || arg === '-c')
+          if (channelArgIndex !== -1 && process.argv[channelArgIndex + 1]) {
+            channelId = process.argv[channelArgIndex + 1]
+          }
+        }
 
-      if (!channelId) {
-        cliLogger.error('Channel ID is required. Use --channel <channelId>')
-        process.exit(EXIT_NO_RESTART)
-      }
+        if (!channelId && !projectPath) {
+          cliLogger.error('Either --channel or --project is required')
+          process.exit(EXIT_NO_RESTART)
+        }
 
-      if (!prompt) {
-        cliLogger.error('Prompt is required. Use --prompt <prompt>')
-        process.exit(EXIT_NO_RESTART)
-      }
+        if (!prompt) {
+          cliLogger.error('Prompt is required. Use --prompt <prompt>')
+          process.exit(EXIT_NO_RESTART)
+        }
 
       // Get bot token from env var or database
       const envToken = process.env.KIMAKI_BOT_TOKEN
@@ -1076,22 +1088,137 @@ cli
       }
 
       if (!botToken) {
-        cliLogger.error('No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.')
+        cliLogger.error(
+          'No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.',
+        )
         process.exit(EXIT_NO_RESTART)
       }
 
       const s = spinner()
+
+      // If --project provided, resolve to channel ID
+      if (projectPath) {
+        const absolutePath = path.resolve(projectPath)
+
+        if (!fs.existsSync(absolutePath)) {
+          cliLogger.error(`Directory does not exist: ${absolutePath}`)
+          process.exit(EXIT_NO_RESTART)
+        }
+
+        s.start('Looking up channel for project...')
+
+        // Check if channel already exists for this directory or a parent directory
+        // This allows running from subfolders of a registered project
+        try {
+          const db = getDatabase()
+          
+          // Helper to find channel for a path (prefers current bot's channel)
+          const findChannelForPath = (dirPath: string): { channel_id: string; directory: string } | undefined => {
+            const withAppId = db
+              .prepare(
+                'SELECT channel_id, directory FROM channel_directories WHERE directory = ? AND channel_type = ? AND app_id = ?',
+              )
+              .get(dirPath, 'text', appId) as { channel_id: string; directory: string } | undefined
+            if (withAppId) return withAppId
+            
+            return db
+              .prepare(
+                'SELECT channel_id, directory FROM channel_directories WHERE directory = ? AND channel_type = ?',
+              )
+              .get(dirPath, 'text') as { channel_id: string; directory: string } | undefined
+          }
+          
+          // Try exact match first, then walk up parent directories
+          let existingChannel: { channel_id: string; directory: string } | undefined
+          let searchPath = absolutePath
+          while (searchPath !== path.dirname(searchPath)) {
+            existingChannel = findChannelForPath(searchPath)
+            if (existingChannel) break
+            searchPath = path.dirname(searchPath)
+          }
+
+          if (existingChannel) {
+            channelId = existingChannel.channel_id
+            if (existingChannel.directory !== absolutePath) {
+              s.message(`Found parent project channel: ${existingChannel.directory}`)
+            } else {
+              s.message(`Found existing channel: ${channelId}`)
+            }
+          } else {
+            // Need to create a new channel
+            s.message('Creating new channel...')
+
+            if (!appId) {
+              s.stop('Missing app ID')
+              cliLogger.error(
+                'App ID is required to create channels. Use --app-id or run `kimaki` first.',
+              )
+              process.exit(EXIT_NO_RESTART)
+            }
+
+            const client = await createDiscordClient()
+
+            await new Promise<void>((resolve, reject) => {
+              client.once(Events.ClientReady, () => {
+                resolve()
+              })
+              client.once(Events.Error, reject)
+              client.login(botToken)
+            })
+
+            // Get guild from existing channels or first available
+            const guild = await (async () => {
+              // Try to find a guild from existing channels belonging to this bot
+              const existingChannelRow = db
+                .prepare(
+                  'SELECT channel_id FROM channel_directories WHERE app_id = ? ORDER BY created_at DESC LIMIT 1',
+                )
+                .get(appId) as { channel_id: string } | undefined
+
+              if (existingChannelRow) {
+                try {
+                  const ch = await client.channels.fetch(existingChannelRow.channel_id)
+                  if (ch && 'guild' in ch && ch.guild) {
+                    return ch.guild
+                  }
+                } catch {
+                  // Channel might be deleted, continue
+                }
+              }
+              // Fall back to first guild the bot is in
+              const firstGuild = client.guilds.cache.first()
+              if (!firstGuild) {
+                throw new Error('No guild found. Add the bot to a server first.')
+              }
+              return firstGuild
+            })()
+
+            const { textChannelId } = await createProjectChannels({
+              guild,
+              projectDirectory: absolutePath,
+              appId,
+              botName: client.user?.username,
+            })
+
+            channelId = textChannelId
+            s.message(`Created channel: ${channelId}`)
+
+            client.destroy()
+          }
+        } catch (e) {
+          s.stop('Failed to resolve project')
+          throw e
+        }
+      }
+
       s.start('Fetching channel info...')
 
       // Get channel info to extract directory from topic
-      const channelResponse = await fetch(
-        `https://discord.com/api/v10/channels/${channelId}`,
-        {
-          headers: {
-            'Authorization': `Bot ${botToken}`,
-          },
-        }
-      )
+      const channelResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}`, {
+        headers: {
+          Authorization: `Bot ${botToken}`,
+        },
+      })
 
       if (!channelResponse.ok) {
         const error = await channelResponse.text()
@@ -1099,7 +1226,7 @@ cli
         throw new Error(`Discord API error: ${channelResponse.status} - ${error}`)
       }
 
-      const channelData = await channelResponse.json() as {
+      const channelData = (await channelResponse.json()) as {
         id: string
         name: string
         topic?: string
@@ -1108,7 +1235,9 @@ cli
 
       if (!channelData.topic) {
         s.stop('Channel has no topic')
-        throw new Error(`Channel #${channelData.name} has no topic. It must have a <kimaki.directory> tag.`)
+        throw new Error(
+          `Channel #${channelData.name} has no topic. It must have a <kimaki.directory> tag.`,
+        )
       }
 
       const extracted = extractTagsArrays({
@@ -1127,25 +1256,28 @@ cli
       // Verify app ID matches if both are present
       if (channelAppId && appId && channelAppId !== appId) {
         s.stop('Channel belongs to different bot')
-        throw new Error(`Channel belongs to a different bot (expected: ${appId}, got: ${channelAppId})`)
+        throw new Error(
+          `Channel belongs to a different bot (expected: ${appId}, got: ${channelAppId})`,
+        )
       }
 
       s.message('Creating starter message...')
 
       // Create starter message with magic prefix
-      // The full prompt goes in the message so the bot can read it
+      // BOT_SESSION_PREFIX triggers AI session, BOT_NOTIFY_PREFIX is notification-only
+      const messagePrefix = notifyOnly ? BOT_NOTIFY_PREFIX : BOT_SESSION_PREFIX
       const starterMessageResponse = await fetch(
         `https://discord.com/api/v10/channels/${channelId}/messages`,
         {
           method: 'POST',
           headers: {
-            'Authorization': `Bot ${botToken}`,
+            Authorization: `Bot ${botToken}`,
             'Content-Type': 'application/json',
           },
           body: JSON.stringify({
-            content: `${BOT_SESSION_PREFIX}\n${prompt}`,
+            content: `${messagePrefix}\n${prompt}`,
           }),
-        }
+        },
       )
 
       if (!starterMessageResponse.ok) {
@@ -1154,7 +1286,7 @@ cli
         throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`)
       }
 
-      const starterMessage = await starterMessageResponse.json() as { id: string }
+      const starterMessage = (await starterMessageResponse.json()) as { id: string }
 
       s.message('Creating thread...')
 
@@ -1165,14 +1297,14 @@ cli
         {
           method: 'POST',
           headers: {
-            'Authorization': `Bot ${botToken}`,
+            Authorization: `Bot ${botToken}`,
             'Content-Type': 'application/json',
           },
           body: JSON.stringify({
             name: threadName.slice(0, 100),
             auto_archive_duration: 1440, // 1 day
           }),
-        }
+        },
       )
 
       if (!threadResponse.ok) {
@@ -1181,29 +1313,26 @@ cli
         throw new Error(`Discord API error: ${threadResponse.status} - ${error}`)
       }
 
-      const threadData = await threadResponse.json() as { id: string; name: string }
+      const threadData = (await threadResponse.json()) as { id: string; name: string }
 
       s.stop('Thread created!')
 
       const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`
 
-      note(
-        `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`,
-        '✅ Thread Created',
-      )
+      const successMessage = notifyOnly
+        ? `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nNotification created. Reply to start a session.\n\nURL: ${threadUrl}`
+        : `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`
+
+      note(successMessage, '✅ Thread Created')
 
       console.log(threadUrl)
 
       process.exit(0)
     } catch (error) {
-      cliLogger.error(
-        'Error:',
-        error instanceof Error ? error.message : String(error),
-      )
+      cliLogger.error('Error:', error instanceof Error ? error.message : String(error))
       process.exit(EXIT_NO_RESTART)
     }
   })
 
-
 cli.help()
 cli.parse()