kimaki 0.26.0 → 0.28.0

package/src/commands/new-worktree.ts

@@ -9,6 +9,7 @@ import {
   type ThreadChannel,
   type Message,
 } from 'discord.js'
+import crypto from 'node:crypto'
 import fs from 'node:fs'
 import { OpenCodeSdkError } from '../errors.js'
 import type { CommandContext } from './types.js'
@@ -18,7 +19,6 @@ import {
   setWorkspaceError,
   getChannelDirectory,
   getThreadSession,
-  getThreadWorktreeOrWorkspace,
   setThreadSession,
 } from '../database.js'
 import {
@@ -32,10 +32,17 @@ import { createLogger, LogPrefix } from '../logger.js'
 import { notifyError } from '../sentry.js'
 import {
   execAsync,
+  getManagedWorktreeDirectory,
   listBranchesByLastCommit,
   resolveBestBaseRef,
   validateBranchRef,
 } from '../worktrees.js'
+import {
+  KIMAKI_WORKTREE_ADAPTER_TYPE,
+  removeWorktreeFromOwnRepository,
+  resolveGitCommit,
+  validateWorktreeIdentity,
+} from '../git-worktree-core.js'
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js'
 import {
   buildSessionPermissions,
@@ -47,8 +54,6 @@ import * as errore from 'errore'
 import { copyCurrentSessionModel } from './model.js'
 
 const logger = createLogger(LogPrefix.WORKTREE)
-const DEFAULT_WORKTREE_BASE_REF = 'HEAD'
-
 async function resolveRequestedWorktreeBaseRef({
   projectDirectory,
   rawBaseBranch,
@@ -59,7 +64,7 @@ async function resolveRequestedWorktreeBaseRef({
   if (!rawBaseBranch) {
     // Default to the current local HEAD so worktrees can branch from
     // unpublished commits in the main checkout.
-    return DEFAULT_WORKTREE_BASE_REF
+    return resolveGitCommit({ directory: projectDirectory, ref: 'HEAD' })
   }
 
   const validated = await validateBranchRef({
@@ -77,7 +82,7 @@ async function resolveRequestedWorktreeBaseRef({
   if (bestRef !== validated) {
     logger.log(`Base branch resolved: ${validated} → ${bestRef} (remote is ahead)`)
   }
-  return bestRef
+  return resolveGitCommit({ directory: projectDirectory, ref: bestRef })
 }
 
 /** Status message shown while a worktree is being created. */
@@ -211,37 +216,95 @@ async function getProjectDirectoryFromChannel(
 /**
  * Try creating a worktree via the OpenCode workspace SDK.
  * Returns the workspace directory on success, or an Error if the workspace
- * feature is not available or the creation fails. Callers fall back to the
- * direct git path on Error.
+ * feature is not available or the creation fails.
  */
-async function tryWorkspaceCreate({
-  threadId,
+export async function tryWorkspaceCreate({
   worktreeName,
   projectDirectory,
-  baseBranch,
+  baseCommit,
 }: {
-  threadId: string
   worktreeName: string
   projectDirectory: string
-  baseBranch?: string
+  baseCommit: string
 }): Promise<{ directory: string; workspaceId: string } | Error> {
   const getClient = await initializeOpencodeForDirectory(projectDirectory)
   if (getClient instanceof Error) return getClient
 
   const client = getClient()
+  const workspaceId = `wrk_${crypto.randomUUID()}`
+  const managedDirectory = getManagedWorktreeDirectory({
+    directory: projectDirectory,
+    name: worktreeName,
+  })
+  const cleanupFailedWorkspace = async (worktreeDirectory: string) => {
+    const removeResponse = await client.experimental.workspace.remove({
+      id: workspaceId,
+      directory: projectDirectory,
+    }).catch((e) => new OpenCodeSdkError({ operation: 'workspace.remove', cause: e }))
+    const sdkCleanupError = (() => {
+      if (removeResponse instanceof Error) return removeResponse
+      if (removeResponse.error) {
+        return new Error(`Workspace cleanup failed: ${JSON.stringify(removeResponse.error)}`)
+      }
+      return undefined
+    })()
+    const gitCleanupError = fs.existsSync(worktreeDirectory)
+      ? await removeWorktreeFromOwnRepository({
+          worktreeDirectory,
+          branchName: worktreeName,
+        })
+      : undefined
+    return sdkCleanupError ?? gitCleanupError
+  }
+
   const response = await client.experimental.workspace.create({
+    id: workspaceId,
     directory: projectDirectory,
-    type: 'kimaki-worktree',
+    type: KIMAKI_WORKTREE_ADAPTER_TYPE,
     branch: worktreeName,
-    extra: baseBranch ? { baseBranch } : null,
+    extra: {
+      projectDirectory,
+      baseCommit,
+    },
   }).catch((e) => new OpenCodeSdkError({ operation: 'workspace.create', cause: e }))
-  if (response instanceof Error) return response
-  if (response.error) {
-    return new Error(`Workspace creation failed: ${JSON.stringify(response.error)}`)
+  if (response instanceof Error || response.error) {
+    const creationError = response instanceof Error
+      ? response
+      : new Error(`Workspace creation failed: ${JSON.stringify(response.error)}`)
+    const cleanupError = await cleanupFailedWorkspace(managedDirectory)
+    if (cleanupError instanceof Error) {
+      return new Error(`${creationError.message}; cleanup failed: ${cleanupError.message}`, {
+        cause: creationError,
+      })
+    }
+    return creationError
   }
   const workspace = response.data
   if (!workspace?.directory || !workspace.id) {
-    return new Error('Workspace SDK returned no directory or ID')
+    const creationError = new Error('Workspace SDK returned no directory or ID')
+    const cleanupError = await cleanupFailedWorkspace(managedDirectory)
+    if (cleanupError instanceof Error) {
+      return new Error(`${creationError.message}; cleanup failed: ${cleanupError.message}`, {
+        cause: creationError,
+      })
+    }
+    return creationError
+  }
+
+  const identityResult = await validateWorktreeIdentity({
+    projectDirectory,
+    worktreeDirectory: workspace.directory,
+    baseCommit,
+  })
+  if (identityResult instanceof Error) {
+    const cleanupError = await cleanupFailedWorkspace(workspace.directory)
+    if (cleanupError instanceof Error) {
+      return new Error(
+        `${identityResult.message}; cleanup failed: ${cleanupError.message}`,
+        { cause: identityResult },
+      )
+    }
+    return identityResult
   }
   return { directory: workspace.directory, workspaceId: workspace.id }
 }
@@ -256,6 +319,7 @@ async function tryWorkspaceCreate({
  * starterMessage is optional — if omitted, status edits are skipped (creation
  * still proceeds). This keeps worktree creation independent of Discord message
  * delivery, so a transient send failure never silently skips the worktree.
+ * beforeReady can bind a session before incoming messages may use the checkout.
  *
  * Returns the worktree directory on success, or an Error on failure.
  * Never throws — all internal errors are caught and returned as Error values.
@@ -265,21 +329,22 @@ export async function createWorktreeInBackground({
   starterMessage,
   worktreeName,
   projectDirectory,
-  baseBranch,
+  baseCommit,
   rest,
+  beforeReady,
 }: {
   thread: ThreadChannel
   starterMessage?: Message
   worktreeName: string
   projectDirectory: string
-  baseBranch?: string
+  baseCommit?: string
   rest: REST
+  beforeReady?: (workspace: {
+    directory: string
+    workspaceId: string
+  }) => Promise<void>
 }): Promise<string | Error> {
   return (async () => {
-      logger.log(
-        `Creating worktree "${worktreeName}" for project ${projectDirectory}${baseBranch ? ` from ${baseBranch}` : ''}`,
-      )
-
       // Serialize status message edits so onProgress can't overwrite the
       // final success/error edit even if Discord's API is slow.
       let editChain: Promise<void> = Promise.resolve()
@@ -300,11 +365,26 @@ export async function createWorktreeInBackground({
         projectDirectory,
       })
 
+      const resolvedBaseCommit = baseCommit
+        ? baseCommit
+        : await resolveGitCommit({ directory: projectDirectory, ref: 'HEAD' })
+      if (resolvedBaseCommit instanceof Error) {
+        await setWorkspaceError({
+          threadId: thread.id,
+          errorMessage: resolvedBaseCommit.message,
+        })
+        editStatus(`🌳 **Worktree: ${worktreeName}**\n❌ ${resolvedBaseCommit.message}`)
+        await editChain
+        return resolvedBaseCommit
+      }
+      logger.log(
+        `Creating worktree "${worktreeName}" for project ${projectDirectory} from ${resolvedBaseCommit}`,
+      )
+
       const workspaceResult = await tryWorkspaceCreate({
-        threadId: thread.id,
         worktreeName,
         projectDirectory,
-        baseBranch,
+        baseCommit: resolvedBaseCommit,
       })
 
       if (workspaceResult instanceof Error) {
@@ -316,6 +396,20 @@ export async function createWorktreeInBackground({
         return workspaceResult
       }
 
+      const preparationResult = beforeReady
+        ? await beforeReady(workspaceResult).catch(
+            (e) => new WorktreeError('Failed to prepare worktree session', { cause: e }),
+          )
+        : undefined
+      if (preparationResult instanceof Error) {
+        logger.error('[WORKTREE] Session preparation failed:', preparationResult)
+        void notifyError(preparationResult, 'Worktree session preparation failed')
+        await sendThreadMessage(
+          thread,
+          `Worktree is ready, but failed to prepare its session: ${preparationResult.message}`,
+        )
+      }
+
       await setWorkspaceReady({
         threadId: thread.id,
         workspaceId: workspaceResult.workspaceId,
@@ -434,11 +528,11 @@ export async function handleNewWorktreeCommand({
   }
 
   // Parallelize: base branch validation and existing worktree check are independent
-  const [baseBranch, existingWorktree] = await Promise.all([
+  const [baseCommit, existingWorktree] = await Promise.all([
     resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch }),
     findExistingWorktreePath({ projectDirectory, worktreeName }),
   ])
-  if (baseBranch instanceof Error) {
+  if (baseCommit instanceof Error) {
     await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``)
     return
   }
@@ -489,7 +583,7 @@ export async function handleNewWorktreeCommand({
     starterMessage,
     worktreeName,
     projectDirectory,
-    baseBranch,
+    baseCommit,
     rest: command.client.rest,
   }).catch((e) => {
     logger.error('[NEW-WORKTREE] Background error:', e)
@@ -543,12 +637,12 @@ async function handleWorktreeInThread({
   // Parallelize: base branch validation, existing worktree check, and parent channel
   // resolve are all independent. resolveTextChannel fetches the parent from Discord
   // cache/API which can overlap with the git operations.
-  const [baseBranch, existingWorktreePath, textChannel] = await Promise.all([
+  const [baseCommit, existingWorktreePath, textChannel] = await Promise.all([
     resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch }),
     findExistingWorktreePath({ projectDirectory, worktreeName }),
     resolveTextChannel(thread),
   ])
-  if (baseBranch instanceof Error) {
+  if (baseCommit instanceof Error) {
     await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``)
     return
   }
@@ -600,11 +694,9 @@ async function handleWorktreeInThread({
     starterMessage: statusMessage,
     worktreeName,
     projectDirectory,
-    baseBranch,
+    baseCommit,
     rest: command.client.rest,
-  })
-    .then(async (result) => {
-      if (result instanceof Error) return
+    beforeReady: async ({ directory, workspaceId }) => {
       const sourceSessionId = await getThreadSession(thread.id)
       if (!sourceSessionId) {
         await sendThreadMessage(
@@ -614,16 +706,7 @@ async function handleWorktreeInThread({
         return
       }
 
-      const workspace = await getThreadWorktreeOrWorkspace(worktreeThread.id)
-      if (!workspace?.workspace_id) {
-        await sendThreadMessage(
-          worktreeThread,
-          '✗ Worktree is ready, but OpenCode returned no workspace ID for context reuse.',
-        )
-        return
-      }
-
-      const getClient = await initializeOpencodeForDirectory(result, {
+      const getClient = await initializeOpencodeForDirectory(directory, {
         originalRepoDirectory: projectDirectory,
         channelId: parent.id,
       })
@@ -637,8 +720,8 @@ async function handleWorktreeInThread({
 
       const forkResponse = await getClient().session.fork({
         sessionID: sourceSessionId,
-        directory: result,
-        workspace: workspace.workspace_id,
+        directory,
+        workspace: workspaceId,
       }).catch((e) => new OpenCodeSdkError({ operation: 'session.fork', cause: e }))
       if (forkResponse instanceof Error) {
         logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', forkResponse)
@@ -673,9 +756,9 @@ async function handleWorktreeInThread({
 
       const permissionResponse = await getClient().session.update({
         sessionID: forkedSession.id,
-        directory: result,
+        directory,
         permission: buildSessionPermissions({
-          directory: result,
+          directory,
           originalRepoDirectory: projectDirectory,
         }),
       }).catch((e) => new OpenCodeSdkError({ operation: 'session.update', cause: e }))
@@ -697,7 +780,7 @@ async function handleWorktreeInThread({
         threadId: worktreeThread.id,
         thread: worktreeThread,
         projectDirectory,
-        sdkDirectory: result,
+        sdkDirectory: directory,
         channelId: parent.id,
         appId,
       })
@@ -705,11 +788,11 @@ async function handleWorktreeInThread({
         worktreeThread,
         `Reusing context from <#${thread.id}> in worktree session \`${forkedSession.id}\`.`,
       )
-    })
-    .catch((e) => {
-      logger.error('[NEW-WORKTREE] Background error:', e)
-      void notifyError(e, 'Background worktree creation failed (in-thread)')
-    })
+    },
+  }).catch((e) => {
+    logger.error('[NEW-WORKTREE] Background error:', e)
+    void notifyError(e, 'Background worktree creation failed (in-thread)')
+  })
 }
 
 /**

package/src/commands/queue.ts

@@ -24,6 +24,7 @@ import {
   registerHtmlAction,
 } from '../html-actions.js'
 import { createLogger, LogPrefix } from '../logger.js'
+import { QUEUE_PREFIX } from '../message-formatting.js'
 import { store } from '../store.js'
 
 const logger = createLogger(LogPrefix.QUEUE)
@@ -157,7 +158,7 @@ export async function handleQueueCommand({
     return
   }
 
-  const responseText = `» **${command.user.displayName}:** ${message.slice(0, 1000)}${message.length > 1000 ? '...' : ''}`
+  const responseText = `${QUEUE_PREFIX}**${command.user.displayName}:** ${message.slice(0, 1000)}${message.length > 1000 ? '...' : ''}`
   await command.reply({
     content: responseText,
     flags: SILENT_MESSAGE_FLAGS,
@@ -352,7 +353,7 @@ export async function handleQueueCommandCommand({
     return
   }
 
-  const responseText = `» **${command.user.displayName}:** ${displayText}`
+  const responseText = `${QUEUE_PREFIX}**${command.user.displayName}:** ${displayText}`
   await command.reply({
     content: responseText,
     flags: SILENT_MESSAGE_FLAGS,

package/src/commands/resume.ts

@@ -17,6 +17,7 @@ import {
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import {
   sendThreadMessage,
+  sendSessionPartBatches,
   resolveProjectDirectoryFromAutocomplete,
   NOTIFY_MESSAGE_FLAGS,
 } from '../discord-utils.js'
@@ -135,12 +136,12 @@ export async function handleResumeCommand({
       }
 
       const batched = batchChunksForDiscord(chunks)
-      for (const batch of batched) {
-        const discordMessage = await sendThreadMessage(thread, batch.content)
+      const sent = await sendSessionPartBatches({ thread, batches: batched })
+      for (const batch of sent) {
         await setPartMessagesBatch(
           batch.partIds.map((partId) => ({
             partId,
-            messageId: discordMessage.id,
+            messageId: batch.message.id,
             threadId: thread.id,
           })),
         )

package/src/commands/session.ts

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

package/src/commands/user-command.ts

@@ -213,12 +213,12 @@ export const handleUserCommand: CommandHandler = async ({
         })
       }
 
-      const sessionDirectory = await (async () => {
-        if (!worktreePromise) return projectDirectory
-        const result = await worktreePromise
-        if (result instanceof Error) return projectDirectory
-        return result
-      })()
+      const worktreeResult = worktreePromise ? await worktreePromise : projectDirectory
+      if (worktreeResult instanceof Error) {
+        await command.editReply(`Worktree creation failed: ${worktreeResult.message}`)
+        return
+      }
+      const sessionDirectory = worktreeResult
 
       await command.editReply(
         `Started /${commandName} in ${newThread.toString()}`,

package/src/commands/worktrees.ts

@@ -28,13 +28,13 @@ import {
   cancelHtmlActionsForOwner,
   registerHtmlAction,
 } from '../html-actions.js'
-import * as errore from 'errore'
 import crypto from 'node:crypto'
-import { GitCommandError, OpenCodeSdkError } from '../errors.js'
+import { OpenCodeSdkError } from '../errors.js'
 import { resolveTextChannel, resolveWorkingDirectory } from '../discord-utils.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import {
   deleteWorktree,
+  extractGitExecOutput,
   git,
   getDefaultBranch,
   listGitWorktrees,
@@ -42,15 +42,9 @@ import {
 } from '../worktrees.js'
 import path from 'node:path'
 
-// Extracts the git stderr from a deleteWorktree error via errore.findCause.
-// Chain: Error { cause: GitCommandError { cause: CommandError { stderr } } }.
 export function extractGitStderr(error: Error): string | undefined {
-  const gitErr = errore.findCause(error, GitCommandError)
-  const stderr = (gitErr?.cause as { stderr?: string } | undefined)?.stderr?.trim()
-  if (stderr && stderr.length > 0) {
-    return stderr
-  }
-  return undefined
+  const stderr = extractGitExecOutput(error).stderr
+  return stderr.length > 0 ? stderr : undefined
 }
 
 export function formatTimeAgo(date: Date): string {
@@ -152,8 +146,7 @@ async function getWorktreeGitStatus({
   defaultBranch: string
 }): Promise<WorktreeGitStatus | null> {
   try {
-    // Use raw git calls so errors/timeouts are visible — isDirty() swallows
-    // errors and returns false, which would render "merged" instead of "unknown".
+    // Use raw git calls so status and ahead-count share one timeout window.
     const [statusResult, aheadResult] = await Promise.all([
       git(directory, 'status --porcelain', { timeout: GIT_CMD_TIMEOUT }),
       git(directory, `rev-list --count "${defaultBranch}..HEAD"`, {