kimaki 0.20.1 → 0.22.0

package/src/interaction-handler.ts

@@ -195,26 +195,14 @@ export function registerInteractionHandler({
         // Multi-machine routing: only handle interactions for channels owned
         // by this machine (have a project directory configured in local db).
         // If not owned, silently return so the other machine handles it.
+        // Setup commands (create-new-project, add-project) bypass this check
+        // because they are designed to run from any channel — they create new
+        // project channels rather than requiring one to already exist.
+        const isSetupCommand =
+          interaction.isChatInputCommand() &&
+          SETUP_COMMANDS.has(interaction.commandName)
         const owned = await isInteractionOwnedByThisMachine(interaction)
-        if (!owned) {
-          // Setup commands get a helpful reply instead of silent ignore.
-          // Both machines may race to reply; one wins, the other silently
-          // fails (interaction tokens are single-use). The message is the
-          // same from either machine so the race is harmless.
-          if (
-            interaction.isChatInputCommand() &&
-            SETUP_COMMANDS.has(interaction.commandName)
-          ) {
-            await interaction.reply({
-              content:
-                'Run this command in an existing Kimaki project channel.\nTo add a new project channel from the terminal, run:\n```\nkimaki project add /path/to/folder\n```',
-              flags: MessageFlags.Ephemeral,
-            }).catch(() => {
-              // Another machine already responded, safe to ignore
-            })
-            return
-          }
-
+        if (!owned && !isSetupCommand) {
           interactionLogger.log(
             `[IGNORED] Channel ${interaction.channelId} has no project directory configured, skipping interaction`,
           )

package/src/message-preprocessing.ts

@@ -390,10 +390,18 @@ export async function preprocessNewSessionMessage({
   }
 
   const qs = extractQueueSuffix(prompt)
+
+  const fileAttachments = await getFileAttachments(message)
+  const textAttachmentsContent = await getTextAttachments(message)
+  const finalPrompt = textAttachmentsContent
+    ? `${qs.prompt}\n\n${textAttachmentsContent}`
+    : qs.prompt
+
   if (
     shouldSkipEmptyPrompt({
       message,
-      prompt: qs.prompt,
+      prompt: finalPrompt,
+      images: fileAttachments,
       hasVoiceAttachment,
     })
   ) {
@@ -401,7 +409,8 @@ export async function preprocessNewSessionMessage({
   }
 
   return {
-    prompt: qs.prompt,
+    prompt: finalPrompt,
+    images: fileAttachments.length > 0 ? fileAttachments : undefined,
     repliedMessage,
     permissionRules,
     mode: qs.forceQueue || voiceResult?.queueMessage ? 'local-queue' : 'opencode',

package/src/queue-advanced-e2e-setup.ts

@@ -127,6 +127,28 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
     },
   }
 
+  const slowBusyMatcher: DeterministicMatcher = {
+    id: 'slow-busy-reply',
+    priority: 100,
+    when: {
+      latestUserTextIncludes: 'SLOW_BUSY_MARKER',
+    },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'slow-busy' },
+        { type: 'text-delta', id: 'slow-busy', delta: 'slow-busy-reply' },
+        { type: 'text-end', id: 'slow-busy' },
+        {
+          type: 'finish',
+          finishReason: 'stop',
+          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+        },
+      ],
+      partDelaysMs: [0, 0, 0, 2_000, 0],
+    },
+  }
+
   const toolFollowupMatcher: DeterministicMatcher = {
     id: 'tool-followup',
     priority: 50,
@@ -755,6 +777,7 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
 
   return [
     slowAbortMatcher,
+    slowBusyMatcher,
     typingRepulseMatcher,
     pluginTimeoutSleepMatcher,
     actionButtonClickFollowupMatcher,

package/src/queue-delete-message.e2e.test.ts

@@ -0,0 +1,102 @@
+// E2e tests for deleting queued Discord messages.
+// Covers the MessageDelete path that removes pending local queue items before drain.
+
+import { describe, test, expect } from 'vitest'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  waitForBotMessageContaining,
+  waitForFooterMessage,
+  waitForThreadState,
+} from './test-utils.js'
+
+const TEXT_CHANNEL_ID = '200000000000001071'
+
+const e2eTest = describe
+
+e2eTest('queue delete message', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'queue-delete-message-e2e',
+    dirName: 'queue-delete-message-e2e',
+    username: 'queue-delete-tester',
+  })
+
+  test(
+    'deleting a queued Discord message removes it from queue',
+    async () => {
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'SLOW_BUSY_MARKER Reply with exactly: delete-queue-setup',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'SLOW_BUSY_MARKER Reply with exactly: delete-queue-setup'
+        },
+      })
+      const th = ctx.discord.thread(thread.id)
+
+      await th.waitForBotReply({ timeout: 4_000 })
+
+      const queuedMsg = await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: deleted-queue. queue',
+      })
+
+      await waitForThreadState({
+        threadId: thread.id,
+        predicate: (state) => {
+          return state.queueItems.some((item) => {
+            return item.sourceMessageId === queuedMsg.id
+          })
+        },
+        timeout: 4_000,
+        description: 'queue has item to delete',
+      })
+
+      await th.user(TEST_USER_ID).deleteMessage({ messageId: queuedMsg.id })
+
+      await waitForThreadState({
+        threadId: thread.id,
+        predicate: (state) => {
+          return !state.queueItems.some((item) => {
+            return item.sourceMessageId === queuedMsg.id
+          })
+        },
+        timeout: 4_000,
+        description: 'queued item removed after Discord delete',
+      })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: 'removed message from queue',
+        timeout: 4_000,
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 8_000,
+      })
+
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-delete-tester)
+        SLOW_BUSY_MARKER Reply with exactly: delete-queue-setup
+        --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
+        Queued at position 1. Edit or delete your message to update the queue
+        ⬦ **queue-delete-tester** removed message from queue
+        ⬥ slow-busy-reply
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+      const finalText = await th.text()
+      expect(finalText).not.toContain(
+        '» **queue-delete-tester:** Reply with exactly: deleted-queue',
+      )
+    },
+    12_000,
+  )
+})

package/src/schema.sql

@@ -168,6 +168,7 @@ CREATE TABLE IF NOT EXISTS `thread_sessions` (
 	`session_id` text NOT NULL,
 	`source` text DEFAULT 'kimaki' NOT NULL,
 	`last_synced_name` text,
+	`parent_session_id` text,
 	`created_at` datetime DEFAULT CURRENT_TIMESTAMP
 );
 

package/src/schema.ts

@@ -29,6 +29,9 @@ export const thread_sessions = sqliteCore.sqliteTable('thread_sessions', {
   session_id: sqliteCore.text('session_id').notNull(),
   source: sqliteCore.text('source', { enum: ['kimaki', 'external_poll'] }).notNull().default('kimaki'),
   last_synced_name: sqliteCore.text('last_synced_name'),
+  // Parent OpenCode session that spawned this thread via kimaki send --parent-session.
+  // Survives bot restarts so child multi-turn system prompts keep the parent ID.
+  parent_session_id: sqliteCore.text('parent_session_id'),
   created_at: datetime('created_at').default(orm.sql`CURRENT_TIMESTAMP`),
 })
 

package/src/session-handler/thread-runtime-state.ts

@@ -51,6 +51,10 @@ export type QueuedMessage = {
   // Written to a temp config file after session creation so the plugin
   // can check per-session whether to scan tool outputs.
   injectionGuardPatterns?: string[]
+  // Parent OpenCode session ID from `kimaki send --parent-session`.
+  // Applied once on first session create so the child system message can
+  // expose how to message the parent when the user asks.
+  parentSessionId?: string
   // Discord message ID and thread ID of the source message. Embedded in
   // <discord-user> synthetic context so the external sync loop can detect
   // messages that originated from Discord and skip re-mirroring them.
@@ -82,6 +86,11 @@ export type ThreadRunState = {
   sessionUsername: string | undefined
   sessionUserId: string | undefined
 
+  // Parent OpenCode session that spawned this thread via
+  // `kimaki send --parent-session`. Set once on first ingress and reused for
+  // the session-stable system prompt.
+  parentSessionId: string | undefined
+
   // FIFO queue of pending inputs waiting for kimaki-local dispatch.
   // Normal user messages default to opencode queue mode; this queue is
   // for explicit local-queue flows (for example /queue).
@@ -107,6 +116,7 @@ export function initialThreadState(): ThreadRunState {
     sessionId: undefined,
     sessionUsername: undefined,
     sessionUserId: undefined,
+    parentSessionId: undefined,
     queueItems: [],
     sentPartIds: new Set(),
   }
@@ -180,6 +190,15 @@ export function setSessionUserId(threadId: string, userId: string): void {
   })
 }
 
+export function setParentSessionId(threadId: string, parentSessionId: string): void {
+  updateThread(threadId, (t) => {
+    if (t.parentSessionId) {
+      return t
+    }
+    return { ...t, parentSessionId }
+  })
+}
+
 export function enqueueItem(threadId: string, item: QueuedMessage): void {
   updateThread(threadId, (t) => ({
     ...t,

package/src/session-handler/thread-session-runtime.ts

@@ -50,6 +50,8 @@ import {
   setPartMessage,
   getThreadSession,
   setThreadSession,
+  getThreadParentSessionId,
+  setThreadParentSessionId,
   getThreadWorktreeOrWorkspace,
   setSessionAgent,
   clearSessionModel,
@@ -557,6 +559,12 @@ export type IngressInput = {
   permissions?: string[]
   permissionRules?: PermissionRuleset
   injectionGuardPatterns?: string[]
+  /**
+   * Parent OpenCode session ID from explicit `kimaki send --parent-session` only.
+   * Stored once on first ingress and injected into the child system message.
+   * Never set for /btw, /fork, or task/subagent children (keeps system prompt cache).
+   */
+  parentSessionId?: string
   sessionStartSource?: { scheduleKind: 'at' | 'cron'; scheduledTaskId?: number }
   /** Optional guard for retries: skip enqueue when session has changed. */
   expectedSessionId?: string
@@ -3079,6 +3087,7 @@ export class ThreadSessionRuntime {
           agents: availableAgents,
           username: this.state?.sessionUsername || input.username,
           userId: this.state?.sessionUserId || input.userId,
+          parentSessionId: this.state?.parentSessionId || input.parentSessionId,
         }),
         ...(resolvedAgent ? { agent: resolvedAgent } : {}),
         ...(modelField ? { model: modelField } : {}),
@@ -3132,6 +3141,7 @@ export class ThreadSessionRuntime {
       permissions: input.permissions,
       permissionRules: input.permissionRules,
       injectionGuardPatterns: input.injectionGuardPatterns,
+      parentSessionId: input.parentSessionId,
       sourceMessageId: input.sourceMessageId,
       sourceThreadId: input.sourceThreadId,
       repliedMessage: input.repliedMessage,
@@ -3182,6 +3192,9 @@ export class ThreadSessionRuntime {
   async enqueueIncoming(input: IngressInput): Promise<EnqueueResult> {
     threadState.setSessionUsername(this.threadId, input.username)
     threadState.setSessionUserId(this.threadId, input.userId)
+    await this.ensureParentSessionId({
+      parentSessionId: input.parentSessionId,
+    })
 
     // When a preprocessor is provided, we must resolve it inside
     // dispatchAction before we know the final mode for routing.
@@ -3204,6 +3217,43 @@ export class ThreadSessionRuntime {
     return this.submitViaOpencodeQueue(input)
   }
 
+  /**
+   * Resolve parent session ID for child system prompts.
+   * Prefer in-memory state, then SQLite, then the ingress marker.
+   * Persist once so multi-turn child sessions keep the parent after restart.
+   */
+  private async ensureParentSessionId({
+    parentSessionId,
+  }: {
+    parentSessionId?: string
+  }) {
+    if (this.state?.parentSessionId) {
+      return
+    }
+
+    const storedParentSessionId = await getThreadParentSessionId(this.threadId)
+    if (storedParentSessionId) {
+      threadState.setParentSessionId(this.threadId, storedParentSessionId)
+      return
+    }
+
+    if (!parentSessionId) {
+      return
+    }
+
+    threadState.setParentSessionId(this.threadId, parentSessionId)
+    // Row may not exist yet on first ingress before ensureSession creates it.
+    // Best-effort write; ensureSession path also persists after setThreadSession.
+    await setThreadParentSessionId({
+      threadId: this.threadId,
+      parentSessionId,
+    }).catch((error) => {
+      logger.warn(
+        `[PARENT SESSION] Failed to persist parent session for thread ${this.threadId}: ${error instanceof Error ? error.message : String(error)}`,
+      )
+    })
+  }
+
   /**
    * Serialize the preprocess callback via a lightweight promise chain, then
    * route the resolved input through the normal enqueue paths.
@@ -3466,6 +3516,17 @@ export class ThreadSessionRuntime {
     return { found: true, removed: false }
   }
 
+  /** Remove a queued message identified by its Discord source message ID. */
+  removeQueuedMessage(
+    sourceMessageId: string,
+  ): threadState.QueuedMessage | undefined {
+    return threadState.updateQueueItemBySourceMessageId(
+      this.threadId,
+      sourceMessageId,
+      () => null,
+    )
+  }
+
   // ── Queue Drain ─────────────────────────────────────────────
 
   /**
@@ -3924,6 +3985,7 @@ export class ThreadSessionRuntime {
         agents: earlyAvailableAgents,
         username: this.state?.sessionUsername || input.username,
         userId: this.state?.sessionUserId || input.userId,
+        parentSessionId: this.state?.parentSessionId || input.parentSessionId,
       }),
       model: earlyModelParam,
       agent: earlyAgentPreference,
@@ -4125,6 +4187,19 @@ export class ThreadSessionRuntime {
     // Store session in DB and thread state
     await setThreadSession(this.thread.id, session.id)
     threadState.setSessionId(this.threadId, session.id)
+    // Parent may have been set on ingress before the thread_sessions row
+    // existed; write it now that the row is guaranteed.
+    const parentSessionId = this.state?.parentSessionId
+    if (parentSessionId) {
+      await setThreadParentSessionId({
+        threadId: this.thread.id,
+        parentSessionId,
+      }).catch((error) => {
+        logger.warn(
+          `[PARENT SESSION] Failed to persist parent session for thread ${this.threadId}: ${error instanceof Error ? error.message : String(error)}`,
+        )
+      })
+    }
     await this.hydrateSessionEventsFromDatabase({ sessionId: session.id })
 
     // Store session start source for scheduled tasks