kimaki 0.27.0 → 0.28.0

package/src/message-formatting.ts

@@ -20,12 +20,19 @@ import { getDataDir } from './config.js'
 
 // Generic message type compatible with both v1 and v2 SDK
 type GenericSessionMessage = {
-  info: { role: string; id?: string }
+  info: { role: string; id?: string; parentID?: string }
   parts: Part[]
 }
 
 const logger = createLogger(LogPrefix.FORMATTING)
 
+export const TOOL_PREFIX = '┣ '
+export const FILE_EDIT_PREFIX = '◼︎ '
+export const THINKING_PREFIX = '┣ '
+export const STATUS_PREFIX = '⬦ '
+export const QUEUE_PREFIX = '» '
+export const WORKTREE_PREFIX = STATUS_PREFIX
+
 /**
  * Serialize Discord embeds into plain text so the AI model can read them.
  * Each embed becomes an <embed> XML block with title, author, description,
@@ -166,11 +173,165 @@ function normalizeWhitespace(text: string): string {
   return text.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ')
 }
 
+export type SessionPartKind = 'text' | 'tool'
+
+export function sessionPartKind(part: { type: string }): SessionPartKind {
+  return part.type === 'text' ? 'text' : 'tool'
+}
+
+export function shouldLeadWithBlankLine({
+  previousKind,
+  nextKind,
+}: {
+  previousKind: SessionPartKind | undefined
+  nextKind: SessionPartKind
+}): boolean {
+  if (!previousKind) return false
+  return previousKind !== nextKind
+}
+
+export function sessionPartContent({
+  content,
+  leadWithBlankLine,
+}: {
+  content: string
+  leadWithBlankLine: boolean
+}): string {
+  if (!leadWithBlankLine) return content
+  return `\n${content}`
+}
+
+export function asDiscordQuote(text: string): string {
+  const lead = text.startsWith('\n') ? '\n' : ''
+  const body = lead ? text.slice(1) : text
+  return lead + body.split('\n').map((line) => {
+    if (line.startsWith('>')) return line
+    return `> ${line}`
+  }).join('\n')
+}
+
+function isNonEmptyTextPart(part: { type: string; text?: string }): boolean {
+  return part.type === 'text' && Boolean(part.text?.trim())
+}
+
+function isRenderableTurnPart(part: { type: string; text?: string }): boolean {
+  return isNonEmptyTextPart(part) || part.type === 'tool'
+}
+
+function nextToolNameAfter({
+  parts,
+  fromIndex,
+}: {
+  parts: Array<{ type: string; tool?: string; text?: string }>
+  fromIndex: number
+}): string | undefined {
+  for (const part of parts.slice(fromIndex + 1)) {
+    if (isNonEmptyTextPart(part)) return undefined
+    if (part.type === 'tool' && part.tool) return part.tool
+  }
+}
+
+export function shouldQuoteIntermediateTextPart({
+  part,
+  isLastInTurn,
+  nextToolName,
+}: {
+  part: { type: string; text?: string }
+  isLastInTurn: boolean
+  nextToolName?: string
+}): boolean {
+  if (!isNonEmptyTextPart(part) || isLastInTurn) return false
+  const text = part.text ?? ''
+  if (text.includes('<callout')) return false
+  if (text.trim().split('\n').length > 2) return false
+  if (
+    nextToolName === 'question'
+    || nextToolName?.endsWith('kimaki_sleep')
+    || nextToolName?.endsWith('kimaki_action_buttons')
+  ) {
+    return false
+  }
+  return true
+}
+
+export type AssistantTurnFlushMode = 'progress' | 'interactive' | 'final'
+
+export type PlannedAssistantTurnPart<T extends { id: string; type: string; text?: string }> = {
+  part: T
+  quoteText: boolean
+}
+
+export function planAssistantTurnFlush<T extends {
+  id: string
+  type: string
+  text?: string
+  tool?: string
+  time?: { end?: number; created?: number }
+}>({
+  parts,
+  mode,
+  throughPartId,
+}: {
+  parts: T[]
+  mode: AssistantTurnFlushMode
+  throughPartId?: string
+}): {
+  send: Array<{ id: string; quoteText: boolean }>
+  hold: Array<{ id: string; quoteText: boolean }>
+  sendParts: Array<PlannedAssistantTurnPart<T>>
+} {
+  const lastText = parts.filter(isNonEmptyTextPart).at(-1)
+  const lastTextIndex = lastText
+    ? parts.findLastIndex((part) => part.id === lastText.id)
+    : -1
+  const throughIndex = throughPartId
+    ? parts.findIndex((part) => part.id === throughPartId)
+    : -1
+
+  const sendUntil = (() => {
+    if (mode === 'final') return parts.length
+    if (mode === 'interactive') {
+      if (throughIndex >= 0) return throughIndex + 1
+      return parts.length
+    }
+    if (!lastText) return parts.length
+    // Hold unfinished last text and anything after it so tool order stays intact.
+    if (!lastText.time?.end) return lastTextIndex
+    return parts.length
+  })()
+
+  const sendParts: Array<PlannedAssistantTurnPart<T>> = []
+  const holdParts: T[] = []
+  for (const [index, part] of parts.entries()) {
+    if (index < sendUntil) {
+      sendParts.push({
+        part,
+        quoteText: shouldQuoteIntermediateTextPart({
+          part,
+          isLastInTurn:
+            mode !== 'progress'
+            && parts.filter(isRenderableTurnPart).at(-1)?.id === part.id,
+          nextToolName: nextToolNameAfter({ parts, fromIndex: index }),
+        }),
+      })
+      continue
+    }
+    holdParts.push(part)
+  }
+
+  return {
+    send: sendParts.map((entry) => ({ id: entry.part.id, quoteText: entry.quoteText })),
+    hold: holdParts.map((part) => ({ id: part.id, quoteText: false })),
+    sendParts,
+  }
+}
+
 // A chunk of formatted content with associated part IDs, ready to be
 // batched into as few Discord messages as possible.
 export type SessionChunk = {
   partIds: string[]
   content: string
+  kind: SessionPartKind
 }
 
 /**
@@ -206,7 +367,19 @@ export function collectSessionChunks({
       if (!content.trim()) {
         continue
       }
-      allChunks.push({ partIds: [part.id], content: content.trimEnd() })
+      const quote = shouldQuoteIntermediateTextPart({
+        part,
+        isLastInTurn: false,
+        nextToolName: nextToolNameAfter({
+          parts: message.parts,
+          fromIndex: message.parts.indexOf(part),
+        }),
+      })
+      allChunks.push({
+        partIds: [part.id],
+        content: (quote ? asDiscordQuote(content) : content).trimEnd(),
+        kind: sessionPartKind(part),
+      })
     }
   }
 
@@ -228,19 +401,37 @@ export function batchChunksForDiscord(chunks: SessionChunk[]): SessionChunk[] {
     return []
   }
   const batched: SessionChunk[] = []
-  let current: SessionChunk = { partIds: [...chunks[0]!.partIds], content: chunks[0]!.content }
+  let current: SessionChunk = {
+    partIds: [...chunks[0]!.partIds],
+    content: chunks[0]!.content,
+    kind: chunks[0]!.kind,
+  }
 
   for (let i = 1; i < chunks.length; i++) {
     const next = chunks[i]!
+    if (next.kind !== current.kind) {
+      batched.push(current)
+      current = {
+        partIds: [...next.partIds],
+        content: next.content,
+        kind: next.kind,
+      }
+      continue
+    }
     const merged = current.content + '\n' + next.content
     if (merged.length <= DISCORD_BATCH_MAX_LENGTH) {
       current = {
         partIds: [...current.partIds, ...next.partIds],
         content: merged,
+        kind: current.kind,
       }
     } else {
       batched.push(current)
-      current = { partIds: [...next.partIds], content: next.content }
+      current = {
+        partIds: [...next.partIds],
+        content: next.content,
+        kind: next.kind,
+      }
     }
   }
   batched.push(current)
@@ -419,31 +610,23 @@ export async function getFileAttachments(
   return results.filter((r) => r !== null) as DiscordFileAttachment[]
 }
 
-const MAX_BASH_COMMAND_INLINE_LENGTH = 100
+const MAX_BASH_COMMAND_INLINE_LENGTH = 50
 
-/**
- * Format the inline title for a bash tool part. Handles three cases:
- * 1. Short single-line command → show full command
- * 2. Long/multiline command with description → show description
- * 3. Long/multiline command without description → truncate first line of command
- *
- * The description field was removed from the opencode v2 bash tool schema but
- * kimaki's system prompt instructs models to always send it as an extra field.
- * Case 3 is the fallback when a model omits it.
- */
 export function formatBashToolTitle({
   command,
   description,
+  summary,
   stateTitle,
 }: {
   command: string
   description?: string
+  summary?: string
   stateTitle?: string
 }): string {
-  if (!command && !description && !stateTitle) return ''
+  const label = description || summary
+  if (!command && !label && !stateTitle) return ''
 
   const isSingleLine = !command.includes('\n')
-  // Find first non-empty line to handle commands with leading blank lines
   const firstMeaningfulLine =
     command
       .split('\n')
@@ -453,8 +636,8 @@ export function formatBashToolTitle({
   if (command && isSingleLine && command.length <= MAX_BASH_COMMAND_INLINE_LENGTH) {
     return ` _${escapeInlineMarkdown(command)}_`
   }
-  if (description) {
-    return ` _${escapeInlineMarkdown(description)}_`
+  if (label) {
+    return ` _${escapeInlineMarkdown(label)}_`
   }
   if (firstMeaningfulLine.length > 0) {
     const needsTruncation = firstMeaningfulLine.length > MAX_BASH_COMMAND_INLINE_LENGTH
@@ -613,14 +796,10 @@ export function formatTodoList(part: Part): string {
   })
   const activeTodo = todos[activeIndex]
   if (activeIndex === -1 || !activeTodo) return ''
-  // digit-with-period ⒈-⒛ for 1-20, fallback to regular number for 21+
-  const digitWithPeriod = '⒈⒉⒊⒋⒌⒍⒎⒏⒐⒑⒒⒓⒔⒕⒖⒗⒘⒙⒚⒛'
   const todoNumber = activeIndex + 1
-  const num =
-    todoNumber <= 20 ? digitWithPeriod[todoNumber - 1] : `${todoNumber}.`
   const content =
     activeTodo.content.charAt(0).toLowerCase() + activeTodo.content.slice(1)
-  return `${num} **${escapeInlineMarkdown(content)}**`
+  return `${todoNumber}.  **${escapeInlineMarkdown(content)}**`
 }
 
 export function formatTaskToolTitle(part: Extract<Part, { type: 'tool' }>): string {
@@ -638,7 +817,7 @@ export function formatTaskToolTitle(part: Extract<Part, { type: 'tool' }>): stri
 
   const subagentType = part.state.input?.subagent_type
   const agent = typeof subagentType === 'string' ? subagentType : 'task'
-  return `┣ ${escapeInlineMarkdown(agent)} **${escapeInlineMarkdown(title)}**`
+  return `${TOOL_PREFIX}${escapeInlineMarkdown(agent)} **${escapeInlineMarkdown(title)}**`
 }
 
 export function formatPart(part: Part, prefix?: string): string {
@@ -647,25 +826,15 @@ export function formatPart(part: Part, prefix?: string): string {
   if (part.type === 'text') {
     const text = part.text?.trim()
     if (!text) return ''
-    // For subtask text, always use bullet with prefix
     if (prefix) {
-      return `⬥ ${pfx}${text}`
-    }
-    const firstChar = text[0] || ''
-    const markdownStarters = ['#', '*', '_', '-', '>', '`', '[', '|']
-    const startsWithMarkdown =
-      markdownStarters.includes(firstChar) ||
-      /^\d+\./.test(text) ||
-      /^<callout[\s>]/i.test(text)
-    if (startsWithMarkdown) {
-      return `\n${text}`
+      return `${pfx}${text}`
     }
-    return `⬥ ${text}`
+    return text
   }
 
   if (part.type === 'reasoning') {
     if (!part.text?.trim()) return ''
-    return `┣ ${pfx}thinking`
+    return `${THINKING_PREFIX}${pfx}thinking`
   }
 
   if (part.type === 'file') {
@@ -677,23 +846,24 @@ export function formatPart(part: Part, prefix?: string): string {
   if (
     part.type === 'step-start' ||
     part.type === 'step-finish' ||
-    part.type === 'patch'
+    part.type === 'patch' ||
+    part.type === 'compaction'
   ) {
     return ''
   }
 
   if (part.type === 'agent') {
-    return `┣ ${pfx}agent ${part.id}`
+    return `${TOOL_PREFIX}${pfx}agent ${part.id}`
   }
 
   if (part.type === 'snapshot') {
-    return `┣ ${pfx}snapshot ${part.snapshot}`
+    return `${TOOL_PREFIX}${pfx}snapshot ${part.snapshot}`
   }
 
   if (part.type === 'tool') {
     if (part.tool === 'todowrite') {
       const formatted = formatTodoList(part)
-      return prefix && formatted ? `┣ ${pfx}${formatted}` : formatted
+      return prefix && formatted ? `${TOOL_PREFIX}${pfx}${formatted}` : formatted
     }
 
     // Question tool is handled via Discord dropdowns, not text
@@ -722,11 +892,13 @@ export function formatPart(part: Part, prefix?: string): string {
       }
       const command = (part.state.input?.command as string) || ''
       const description = (part.state.input?.description as string) || ''
+      const summary = (part.state.input?.summary as string) || ''
       const toolTitle = formatBashToolTitle({
         command,
         description,
+        summary,
       })
-      return `┣ ${pfx}bash${toolTitle}`
+      return `${TOOL_PREFIX}${pfx}bash${toolTitle}`
     }
 
     const summaryText = getToolSummaryText(part)
@@ -738,9 +910,11 @@ export function formatPart(part: Part, prefix?: string): string {
     } else if (part.tool === 'bash') {
       const command = (part.state.input?.command as string) || ''
       const description = (part.state.input?.description as string) || ''
+      const summary = (part.state.input?.summary as string) || ''
       const formatted = formatBashToolTitle({
         command,
         description,
+        summary,
         stateTitle,
       })
       toolTitle = formatted.startsWith(' ') ? formatted.slice(1) : formatted
@@ -757,14 +931,17 @@ export function formatPart(part: Part, prefix?: string): string {
         part.tool === 'write' ||
         part.tool === 'apply_patch'
       ) {
-        return '◼︎'
+        return FILE_EDIT_PREFIX
       }
-      return '┣'
+      return TOOL_PREFIX
     })()
     const toolParts = [part.tool, toolTitle, summaryText]
       .filter(Boolean)
       .join(' ')
-    return `${icon} ${pfx}${toolParts}`
+    if (icon === '⨯') {
+      return `${icon} ${pfx}${toolParts}`
+    }
+    return `${icon}${pfx}${toolParts}`
   }
 
   logger.warn('Unknown part type:', part)

package/src/message-preprocessing.ts

@@ -1,6 +1,7 @@
 // Message pre-processing pipeline for incoming Discord messages.
 // Extracts prompt text, voice transcription, file/text attachments, and
 // session context from a Discord Message before handing off to the runtime.
+// Voice side/fresh-chat requests dispatch to separate threads instead.
 //
 // This module exists so discord-bot.ts stays a thin event router and the
 // expensive async work (voice transcription, context fetch, attachment
@@ -11,6 +12,7 @@ import type { Message, ThreadChannel } from 'discord.js'
 import { DiscordOperationError, OpenCodeSdkError } from './errors.js'
 import type { DiscordFileAttachment } from './message-formatting.js'
 import type { PreprocessResult } from './session-handler/thread-session-runtime.js'
+import { getOrCreateRuntime } from './session-handler/thread-session-runtime.js'
 import type { AgentInfo, RepliedMessageContext } from './system-message.js'
 import {
   resolveMentions,
@@ -21,7 +23,11 @@ import { processVoiceAttachment } from './voice-handler.js'
 import { isVoiceAttachment } from './voice-attachment.js'
 import { initializeOpencodeForDirectory } from './opencode.js'
 import { getCompactSessionContext, getLastSessionId } from './markdown.js'
-import { getThreadSession } from './database.js'
+import { getThreadSession, getThreadWorktreeOrWorkspace } from './database.js'
+import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage } from './discord-utils.js'
+import { forkSessionToBtwThread } from './commands/btw.js'
+import { createNewSessionThread } from './commands/session.js'
+import type { TranscriptionResult } from './voice.js'
 import * as errore from 'errore'
 import { createLogger, LogPrefix } from './logger.js'
 import { notifyError } from './sentry.js'
@@ -32,6 +38,96 @@ const voiceLogger = createLogger(LogPrefix.VOICE)
 export const VOICE_MESSAGE_TRANSCRIPTION_PREFIX =
   'Voice message transcription from Discord user:\n'
 
+// Dispatch before returning a prompt so the source runtime never receives the side request.
+async function routeVoiceSession({
+  voiceResult,
+  message,
+  thread,
+  appId,
+}: {
+  voiceResult: TranscriptionResult | null
+  message: Message
+  thread: ThreadChannel
+  appId?: string
+}): Promise<boolean> {
+  if (!voiceResult?.sessionAction) return false
+  const resolved = await resolveWorkingDirectory({ channel: thread })
+  if (!resolved) {
+    await sendThreadMessage(thread, 'Could not determine project directory. Use /add-project to configure it, then retry.')
+    return true
+  }
+  const images = await getFileAttachments(message)
+  const textAttachments = await getTextAttachments(message)
+  const caption = resolveMentions(message).trim()
+  const prompt = [caption, voiceResult.transcription, textAttachments]
+    .filter((part) => part?.trim())
+    .join('\n\n')
+  const modelPrompt = [caption, `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`, textAttachments]
+    .filter((part) => part?.trim())
+    .join('\n\n')
+  if (voiceResult.sessionAction === 'btw') {
+    const result = await forkSessionToBtwThread({
+      sourceThread: thread,
+      projectDirectory: resolved.projectDirectory,
+      sdkDirectory: resolved.workingDirectory,
+      prompt,
+      modelPrompt,
+      images,
+      agent: voiceResult.agent,
+      userId: message.author.id,
+      username: message.member?.displayName || message.author.displayName,
+      appId,
+    })
+      .catch((cause) => new DiscordOperationError({ operation: 'forkVoiceSession', cause }))
+    if (result instanceof Error) {
+      logger.error('Voice side chat failed:', result)
+      await sendThreadMessage(thread, `${result.message}. Start a session first, then retry with /btw.`)
+      return true
+    }
+    await sendThreadMessage(thread, `Session forked! Continue in ${result.thread.toString()}`)
+    return true
+  }
+  const textChannel = await resolveTextChannel(thread)
+  if (!textChannel) {
+    await sendThreadMessage(thread, 'Could not resolve parent text channel. Retry /new-session in the project channel.')
+    return true
+  }
+  const result = await createNewSessionThread({
+    textChannel,
+    projectDirectory: resolved.projectDirectory,
+    prompt,
+    userId: message.author.id,
+    sourceWorkspace: await getThreadWorktreeOrWorkspace(thread.id),
+  }).catch((cause) => new DiscordOperationError({ operation: 'createVoiceSessionThread', cause }))
+  if (result instanceof Error) {
+    logger.error('Voice new session failed:', result)
+    await sendThreadMessage(thread, `${result.message}. Retry with /new-session.`)
+    return true
+  }
+  await sendThreadMessage(thread, `Created new session in ${result.toString()}`)
+  const runtime = getOrCreateRuntime({
+    threadId: result.id,
+    thread: result,
+    projectDirectory: resolved.projectDirectory,
+    sdkDirectory: resolved.workingDirectory,
+    channelId: textChannel.id,
+    appId,
+  })
+  await runtime.enqueueIncoming({
+    prompt: modelPrompt,
+    images,
+    agent: voiceResult.agent,
+    userId: message.author.id,
+    username: message.member?.displayName || message.author.displayName,
+    appId,
+    mode: 'opencode',
+  }).catch(async (error) => {
+    logger.error('Voice session dispatch failed:', error)
+    await sendThreadMessage(result, 'Could not send the request to OpenCode. Send your request again in this thread.')
+  })
+  return true
+}
+
 /** Fetch available agents from OpenCode for voice transcription agent selection. */
 async function fetchAvailableAgents(
   getClient: Awaited<ReturnType<typeof initializeOpencodeForDirectory>>,
@@ -245,7 +341,15 @@ export async function preprocessExistingThreadMessage({
     currentSessionContext,
     lastSessionContext,
     agents,
+    canForkSession: true,
   })
+  if (voiceResult instanceof Error) {
+    voiceLogger.warn('Voice request not dispatched:', voiceResult)
+    return { prompt: '', mode: 'opencode', skip: true }
+  }
+  if (await routeVoiceSession({ voiceResult, message, thread, appId })) {
+    return { prompt: '', mode: 'opencode', skip: true }
+  }
   if (voiceResult) {
     messageContent = `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`
   }
@@ -327,6 +431,13 @@ export async function preprocessNewSessionMessage({
     appId,
     agents,
   })
+  if (voiceResult instanceof Error) {
+    voiceLogger.warn('Voice request not dispatched:', voiceResult)
+    return { prompt: '', mode: 'opencode', skip: true }
+  }
+  if (await routeVoiceSession({ voiceResult, message, thread, appId })) {
+    return { prompt: '', mode: 'opencode', skip: true }
+  }
   if (voiceResult) {
     prompt = `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`
   }
@@ -424,6 +535,10 @@ export async function preprocessNewThreadMessage({
     appId,
     agents,
   })
+  if (voiceResult instanceof Error) {
+    voiceLogger.warn('Voice request not dispatched:', voiceResult)
+    return { prompt: '', mode: 'opencode', skip: true }
+  }
   if (voiceResult) {
     messageContent = `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`
   }

package/src/opencode-command.test.ts

@@ -7,11 +7,70 @@ import path from 'node:path'
 import { afterEach, beforeEach, describe, expect, test } from 'vitest'
 import {
   ensureKimakiCommandShim,
+  getIncompatibleOpencodeVersionError,
   getSpawnCommandAndArgs,
+  INCOMPATIBLE_OPENCODE_MAJOR_VERSION,
+  isIncompatibleOpencodeMajor,
+  parseOpencodeVersion,
   sanitizeShimExecArgv,
   selectResolvedCommand,
   splitCommandLookupOutput,
 } from './opencode-command.js'
+import { OpencodeIncompatibleVersionError } from './errors.js'
+
+describe('parseOpencodeVersion', () => {
+  test('extracts major.minor.patch from opencode --version output', () => {
+    expect(parseOpencodeVersion('1.2.3')).toEqual({
+      major: 1,
+      minor: 2,
+      patch: 3,
+      raw: '1.2.3',
+    })
+    expect(parseOpencodeVersion('opencode 2.0.0\n')).toEqual({
+      major: 2,
+      minor: 0,
+      patch: 0,
+      raw: '2.0.0',
+    })
+    expect(parseOpencodeVersion('v2.1.0-beta.1')).toEqual({
+      major: 2,
+      minor: 1,
+      patch: 0,
+      raw: '2.1.0',
+    })
+  })
+
+  test('returns null when output has no three-part version', () => {
+    expect(parseOpencodeVersion('')).toBeNull()
+    expect(parseOpencodeVersion('opencode')).toBeNull()
+    expect(parseOpencodeVersion('2.0')).toBeNull()
+  })
+})
+
+describe('isIncompatibleOpencodeMajor', () => {
+  test('rejects the incompatible major and allows every other major', () => {
+    expect(INCOMPATIBLE_OPENCODE_MAJOR_VERSION).toBe(2)
+    expect(isIncompatibleOpencodeMajor({ major: 2 })).toBe(true)
+    expect(isIncompatibleOpencodeMajor({ major: 1 })).toBe(false)
+    expect(isIncompatibleOpencodeMajor({ major: 0 })).toBe(false)
+    expect(isIncompatibleOpencodeMajor({ major: 3 })).toBe(false)
+  })
+})
+
+describe('getIncompatibleOpencodeVersionError', () => {
+  test('returns a tagged error for OpenCode 2.x', () => {
+    const error = getIncompatibleOpencodeVersionError('2.0.0')
+    expect(error).toBeInstanceOf(OpencodeIncompatibleVersionError)
+    expect(error?.message).toMatchInlineSnapshot(
+      `"Kimaki is not compatible with OpenCode version 2.0.0. Install an OpenCode 1.x release."`,
+    )
+  })
+
+  test('allows 1.x and unparseable output', () => {
+    expect(getIncompatibleOpencodeVersionError('1.4.0')).toBeNull()
+    expect(getIncompatibleOpencodeVersionError('opencode')).toBeNull()
+  })
+})
 
 describe('splitCommandLookupOutput', () => {
   test('splits windows command lookup output into trimmed lines', () => {