kimaki 0.26.0 → 0.28.0

package/src/interaction-handler.ts

@@ -76,6 +76,7 @@ import {
   handleAgentCommand,
   handleAgentSelectMenu,
   handleQuickAgentCommand,
+  handleQuickAgentAutocomplete,
 } from './commands/agent.js'
 import { handleAskQuestionSelectMenu } from './commands/ask-question.js'
 import {
@@ -115,15 +116,29 @@ import { hasKimakiAdminPermission, hasKimakiBotPermission } from './discord-util
 import { createLogger, LogPrefix } from './logger.js'
 import { notifyError } from './sentry.js'
 import { getChannelDirectory } from './database.js'
+import {
+  reserveThreadIngress,
+  runInThreadIngressSlot,
+} from './session-handler/thread-session-runtime.js'
 
 const interactionLogger = createLogger(LogPrefix.INTERACTION)
 
-/** Setup commands that should reply with guidance when used in
- * non-project channels, instead of silently ignoring. */
-const SETUP_COMMANDS = new Set([
-  'add-project',
-  'create-new-project',
-])
+function serialIngressChannelId(interaction: Interaction): string | undefined {
+  if (!interaction.isChatInputCommand()) {
+    return undefined
+  }
+  const name = interaction.commandName
+  if (name.endsWith('-cmd') || name.endsWith('-skill') || name.endsWith('-mcp-prompt')) {
+    return interaction.channelId ?? undefined
+  }
+  if (!name.endsWith('-agent') || name === 'agent') {
+    return undefined
+  }
+  if (interaction.options.getString('prompt')) {
+    return undefined
+  }
+  return interaction.channelId ?? undefined
+}
 
 /**
  * Check if the interaction's channel is owned by this machine (has a project
@@ -175,6 +190,11 @@ export function registerInteractionHandler({
   discordClient.on(
     Events.InteractionCreate,
     async (interaction: Interaction) => {
+      const ingressChannelId = serialIngressChannelId(interaction)
+      const ingressSlot = ingressChannelId
+        ? reserveThreadIngress(ingressChannelId)
+        : undefined
+      await runInThreadIngressSlot(ingressSlot, async () => {
       try {
         interactionLogger.log(
           `[INTERACTION] Received: ${interaction.type} - ${
@@ -189,14 +209,9 @@ 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)
+        // Setup commands must not let an unconfigured server grant itself host access.
         const owned = await isInteractionOwnedByThisMachine(interaction)
-        if (!owned && !isSetupCommand) {
+        if (!owned) {
           interactionLogger.log(
             `[IGNORED] Channel ${interaction.channelId} has no project directory configured, skipping interaction`,
           )
@@ -241,6 +256,13 @@ export function registerInteractionHandler({
               return
 
             default:
+              if (
+                interaction.commandName.endsWith('-agent') &&
+                interaction.commandName !== 'agent'
+              ) {
+                await handleQuickAgentAutocomplete({ interaction, appId })
+                return
+              }
               await interaction.respond([])
               return
           }
@@ -740,6 +762,7 @@ export function registerInteractionHandler({
           )
         }
       }
+      })
     },
   )
 }

package/src/ipc-tools-plugin.ts

@@ -1,15 +1,16 @@
-// OpenCode plugin that provides IPC-based tools for Discord interaction:
+// OpenCode plugin that provides Discord and session tools:
 // - kimaki_file_upload: prompts the Discord user to upload files via native picker
 // - kimaki_action_buttons: shows clickable action buttons in the Discord thread
+// - kimaki_sleep: persist a wake time so the session can sleep hours or days
 //
-// Tools communicate with the bot process via IPC rows in SQLite (the plugin
-// runs inside the OpenCode server process, not the bot process).
+// IPC tools talk to the bot process via SQLite rows. Sleep writes session_sleeps
+// directly. The plugin runs inside the OpenCode server process, not the bot.
 //
 // Exported from kimaki-opencode-plugin.ts — each export is treated as a separate
 // plugin by OpenCode's plugin loader.
 
 import type { Plugin } from '@opencode-ai/plugin'
-import type { ToolContext } from '@opencode-ai/plugin/tool'
+import type { ToolContext, ToolResult } from '@opencode-ai/plugin/tool'
 import dedent from 'string-dedent'
 import { z } from 'zod'
 import { setDataDir } from './config.js'
@@ -33,7 +34,7 @@ function tool<Args extends z.ZodRawShape>(input: {
   execute(
     args: z.infer<z.ZodObject<Args>>,
     context: ToolContext,
-  ): Promise<string>
+  ): Promise<ToolResult>
 }) {
   return input
 }
@@ -222,6 +223,82 @@ const ipcToolsPlugin: any = async () => {
           return 'Action button request timed out'
         },
       }),
+      kimaki_sleep: tool({
+        description: dedent`
+          Sleep this session until a future time. Kimaki later posts a wake
+          message in this thread and the same session continues.
+          Use this to wait hours or days for CI, a deploy, a date, or any later event.
+          The sleep is stored in SQLite and survives bot restarts.
+
+          Pass either duration (2h, 30m, 1d) or until (UTC ISO ending with Z).
+          Do not pass both. You MUST call kimaki_sleep LAST, after ALL text.
+          Do not call more tools after it.
+
+          The tool result is not a wake. After it succeeds, write one short
+          waiting line and stop. Do not continue the waited work until a later
+          Discord message that starts with "Woke after sleeping until".
+          A new user message cancels the sleep. If you still need that later
+          wake after answering, call kimaki_sleep again with until set to the
+          original UTC time.
+        `,
+        args: {
+          duration: z
+            .string()
+            .optional()
+            .describe(
+              'Relative wait. Examples: 30s, 2h, 1d. Do not pass with until.',
+            ),
+          until: z
+            .string()
+            .optional()
+            .describe(
+              'UTC ISO date ending with Z. Example: 2026-08-20T09:00:00Z.',
+            ),
+          reason: z
+            .string()
+            .optional()
+            .describe('Why the session is sleeping. Shown when it wakes.'),
+        },
+        async execute({ duration, until, reason }, context) {
+          const {
+            parseSleepWakeAt,
+            formatSessionSleepWakeAt,
+            formatSessionSleepToolOutput,
+          } = await import('./task-schedule.js')
+          const wakeAt = parseSleepWakeAt({
+            duration,
+            until,
+            now: new Date(),
+          })
+          if (wakeAt instanceof Error) {
+            return wakeAt.message
+          }
+
+          const { getThreadIdBySessionId, upsertSessionSleep } =
+            await loadDatabaseModule()
+          // Only a check that a thread owns this session: subagents have none.
+          // The wake resolves the thread again at delivery time, so nothing
+          // here can go stale if /resume rebinds the session later.
+          const threadId = await getThreadIdBySessionId(context.sessionID)
+          if (!threadId) {
+            return 'sleep is only available in the main session'
+          }
+
+          await upsertSessionSleep({
+            sessionId: context.sessionID,
+            wakeAt,
+            reason,
+          })
+
+          // The title carries the resolved absolute time so Discord shows the
+          // real wake instant instead of a relative input like "2h".
+          const untilLabel = formatSessionSleepWakeAt(wakeAt)
+          return {
+            title: `until ${untilLabel}`,
+            output: formatSessionSleepToolOutput({ wakeAt, reason }),
+          }
+        },
+      }),
     },
   }
 }

package/src/kimaki-opencode-plugin-loading.e2e.test.ts

@@ -1,117 +1,208 @@
 // E2e test for OpenCode plugin loading.
-// Spawns `opencode serve` directly with our plugin in OPENCODE_CONFIG_CONTENT,
-// waits for the health endpoint, then checks stderr for plugin errors.
-// No Discord infrastructure needed — just the OpenCode server process.
+// Spawns one `opencode serve` with the same plugin list kimaki writes (its own
+// plugin plus @subrouter/opencode), then checks stderr for load errors and
+// hits the real HTTP API. One server for both plugins, because that is how
+// they actually run, and because booting two costs seconds per file.
+// No Discord infrastructure and no real provider APIs.
 
 import { spawn, type ChildProcess } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { test, expect } from 'vitest'
+import { createRequire } from 'node:module'
+import { pathToFileURL } from 'node:url'
+import { afterAll, beforeAll, expect, test } from 'vitest'
+import { PROVIDER_IDS, type AuthFile } from '@subrouter/cli'
 import { resolveOpencodeCommand } from './opencode.js'
 import { getSpawnCommandAndArgs } from './opencode-command.js'
 import { chooseLockPort } from './test-utils.js'
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-
-async function waitForHealth({
-  port,
-  maxAttempts = 30,
-}: {
-  port: number
-  maxAttempts?: number
-}): Promise<boolean> {
-  for (let i = 0; i < maxAttempts; i++) {
-    try {
-      const response = await fetch(`http://127.0.0.1:${port}/api/health`)
-      if (response.status < 500) {
-        return true
-      }
-    } catch {
-      // connection refused, retry
-    }
+const require = createRequire(import.meta.url)
+
+const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' })
+const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e')
+const subrouterHome = path.join(projectDir, 'subrouter-home')
+const stderrLines: string[] = []
+
+let serverProcess: ChildProcess | undefined
+
+async function api<T>(routePath: string): Promise<T> {
+  const url = new URL(routePath, `http://127.0.0.1:${port}`)
+  url.searchParams.set('directory', projectDir)
+  const response = await fetch(url, { headers: { 'x-opencode-directory': projectDir } })
+  if (!response.ok) throw new Error(`${routePath} returned ${response.status}`)
+  return (await response.json()) as T
+}
+
+async function waitForHealth() {
+  for (let attempt = 0; attempt < 60; attempt++) {
+    const ok = await fetch(`http://127.0.0.1:${port}/api/health`)
+      .then((r) => r.status < 500)
+      .catch(() => false)
+    if (ok) return true
     await new Promise((resolve) => {
-      setTimeout(resolve, 1000)
+      setTimeout(resolve, 500)
     })
   }
   return false
 }
 
-test(
-  'opencode server loads plugin without errors',
-  async () => {
-    const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e')
-    fs.mkdirSync(projectDir, { recursive: true })
-
-    const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' })
-    const pluginPath = new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href
-    const stderrLines: string[] = []
-    const isolatedOpencodeRoot = path.join(projectDir, 'opencode-test-home')
-    const xdgDirectories = {
-      OPENCODE_CONFIG_DIR: path.join(isolatedOpencodeRoot, '.opencode-kimaki'),
-      XDG_CONFIG_HOME: path.join(isolatedOpencodeRoot, '.config'),
-      XDG_DATA_HOME: path.join(isolatedOpencodeRoot, '.local', 'share'),
-      XDG_CACHE_HOME: path.join(isolatedOpencodeRoot, '.cache'),
-      XDG_STATE_HOME: path.join(isolatedOpencodeRoot, '.local', 'state'),
-    }
-
-    fs.mkdirSync(isolatedOpencodeRoot, { recursive: true })
-    Object.values(xdgDirectories).forEach((directory) => {
-      fs.mkdirSync(directory, { recursive: true })
-    })
+beforeAll(async () => {
+  fs.rmSync(projectDir, { recursive: true, force: true })
+  const opencodeRoot = path.join(projectDir, 'opencode-test-home')
+  const xdgDirectories = {
+    OPENCODE_CONFIG_DIR: path.join(opencodeRoot, '.opencode-kimaki'),
+    XDG_CONFIG_HOME: path.join(opencodeRoot, '.config'),
+    XDG_DATA_HOME: path.join(opencodeRoot, '.local', 'share'),
+    XDG_CACHE_HOME: path.join(opencodeRoot, '.cache'),
+    XDG_STATE_HOME: path.join(opencodeRoot, '.local', 'state'),
+  }
+  ;[...Object.values(xdgDirectories), subrouterHome].forEach((directory) => {
+    fs.mkdirSync(directory, { recursive: true })
+  })
 
-    const {
-      command,
-      args,
-      windowsVerbatimArguments,
-    } = getSpawnCommandAndArgs({
-      resolvedCommand: resolveOpencodeCommand(),
-      baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
-    })
+  const { command, args, windowsVerbatimArguments } = getSpawnCommandAndArgs({
+    resolvedCommand: resolveOpencodeCommand(),
+    baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
+  })
 
-    const serverProcess: ChildProcess = spawn(command, args, {
-      stdio: 'pipe',
-      cwd: projectDir,
-      windowsVerbatimArguments,
-      env: {
-        ...process.env,
-        OPENCODE_CONFIG_CONTENT: JSON.stringify({
-          $schema: 'https://opencode.ai/config.json',
-          lsp: false,
-          formatter: false,
-          plugin: [pluginPath],
-        }),
-        OPENCODE_TEST_HOME: isolatedOpencodeRoot,
-        ...xdgDirectories,
-      },
-    })
+  serverProcess = spawn(command, args, {
+    stdio: 'pipe',
+    cwd: projectDir,
+    windowsVerbatimArguments,
+    env: {
+      ...process.env,
+      OPENCODE_CONFIG_CONTENT: JSON.stringify({
+        $schema: 'https://opencode.ai/config.json',
+        lsp: false,
+        formatter: false,
+        plugin: [
+          new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href,
+          pathToFileURL(require.resolve('@subrouter/opencode')).href,
+        ],
+      }),
+      OPENCODE_TEST_HOME: opencodeRoot,
+      SUBROUTER_HOME: subrouterHome,
+      SUBROUTER_MANUAL_OAUTH: '1',
+      ...xdgDirectories,
+    },
+  })
+
+  serverProcess.stderr?.on('data', (data) => {
+    stderrLines.push(...data.toString().split('\n').filter(Boolean))
+  })
 
-    serverProcess.stderr?.on('data', (data) => {
-      stderrLines.push(...data.toString().split('\n').filter(Boolean))
+  expect(await waitForHealth()).toBe(true)
+}, 120_000)
+
+afterAll(() => {
+  serverProcess?.kill('SIGTERM')
+})
+
+test('server loads both plugins without errors', () => {
+  const pluginErrorPatterns = [
+    /plugin.*error/i,
+    /failed to load plugin/i,
+    /cannot find module/i,
+    /ERR_MODULE_NOT_FOUND/i,
+    /plugin.*failed/i,
+    /plugin.*crash/i,
+  ]
+  const errorLines = stderrLines.filter((line) => {
+    return pluginErrorPatterns.some((pattern) => {
+      return pattern.test(line)
     })
+  })
+  expect(errorLines).toEqual([])
+})
+
+test('subrouter is a connected provider so /model accepts subrouter/default', async () => {
+  const providers = await api<{
+    all: Array<{
+      id: string
+      name: string
+      models: Record<
+        string,
+        {
+          name: string
+          capabilities: {
+            attachment: boolean
+            input: { image: boolean; pdf: boolean }
+          }
+        }
+      >
+    }>
+    connected: string[]
+  }>('/provider')
+
+  expect(providers.connected).toContain('subrouter')
+  const subrouter = providers.all.find((entry) => {
+    return entry.id === 'subrouter'
+  })
+  expect(subrouter?.name).toBe('subrouter.org')
+  expect(subrouter?.models.default).toMatchObject({
+    capabilities: {
+      attachment: false,
+      input: { image: false, pdf: false },
+    },
+  })
+})
+
+test('login offers subrouter and asks which subscription to add first', async () => {
+  const methods = await api<
+    Record<
+      string,
+      Array<{
+        type: string
+        label: string
+        prompts?: Array<{ type: string; key: string; options?: Array<{ value: string }> }>
+      }>
+    >
+  >('/provider/auth')
+
+  expect(methods.subrouter).toHaveLength(1)
+  expect(methods.subrouter?.[0]).toMatchObject({ type: 'oauth', label: 'Add a subscription' })
+
+  // Derived from subrouter, not hardcoded: it adds providers over time and a
+  // literal list here just breaks on the next one.
+  const prompt = methods.subrouter?.[0]?.prompts?.[0]
+  expect(prompt).toMatchObject({ type: 'select', key: 'provider' })
+  expect(prompt?.options?.map((option) => option.value)).toEqual([...PROVIDER_IDS])
+})
+
+test('authorize and callback add an opencode-go subscription', async () => {
+  const url = new URL('/provider/subrouter/oauth/authorize', `http://127.0.0.1:${port}`)
+  url.searchParams.set('directory', projectDir)
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'x-opencode-directory': projectDir },
+    body: JSON.stringify({ method: 0, inputs: { provider: 'opencode-go' } }),
+  })
+
+  expect(response.ok).toBe(true)
+  const authorization = (await response.json()) as { url: string; method: string; instructions: string }
+  expect(authorization.method).toBe('code')
+  expect(authorization.url).toBe('https://opencode.ai/auth')
+  expect(authorization.instructions).toContain('API key')
+
+  const callbackUrl = new URL(
+    '/provider/subrouter/oauth/callback',
+    `http://127.0.0.1:${port}`,
+  )
+  callbackUrl.searchParams.set('directory', projectDir)
+  const callbackResponse = await fetch(callbackUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-opencode-directory': projectDir,
+    },
+    body: JSON.stringify({ method: 0, code: 'zen-key-1' }),
+  })
 
-    try {
-      const healthy = await waitForHealth({ port })
-      expect(healthy).toBe(true)
-
-      // Check no plugin-related errors in stderr
-      const pluginErrorPatterns = [
-        /plugin.*error/i,
-        /failed to load plugin/i,
-        /cannot find module/i,
-        /ERR_MODULE_NOT_FOUND/i,
-        /plugin.*failed/i,
-        /plugin.*crash/i,
-      ]
-      const errorLines = stderrLines.filter((line) => {
-        return pluginErrorPatterns.some((pattern) => {
-          return pattern.test(line)
-        })
-      })
-      expect(errorLines).toEqual([])
-    } finally {
-      serverProcess.kill('SIGTERM')
-    }
-  },
-  60_000,
-)
+  expect(callbackResponse.ok).toBe(true)
+  const auth = JSON.parse(
+    fs.readFileSync(path.join(subrouterHome, 'auth.json'), 'utf8'),
+  ) as AuthFile
+  expect(auth.providers['opencode-go']?.accounts).toMatchObject([
+    { type: 'api', key: 'zen-key-1' },
+  ])
+})

package/src/kimaki-opencode-plugin.ts

@@ -4,23 +4,29 @@
 // initializer functions. OpenCode calls every export as a plugin.
 //
 // Plugins are split into focused modules:
-// - ipc-tools-plugin: file upload + action buttons (IPC-based Discord tools)
+// - ipc-tools-plugin: file upload, action buttons, and session sleep
 // - context-awareness-plugin: branch, pwd, memory reminder, onboarding tutorial
 // - memory-overview-plugin: frozen MEMORY.md heading overview per session
 // - opencode-interrupt-plugin: interrupt queued messages at step boundaries
-// - subagent-rate-limit-plugin: aborts only task subagents after rate limits
 // - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
+// - file-edit-log: record edit/write/apply_patch files per session
+// - bash-tool-schema-plugin: add description and hasSideEffect to bash
 
 export { ipcToolsPlugin } from './ipc-tools-plugin.js'
 export { contextAwarenessPlugin } from './context-awareness-plugin.js'
 export { memoryOverviewPlugin } from './memory-overview-plugin.js'
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js'
+// LEGACY per-provider account rotation. Superseded by @subrouter/opencode
+// (registered separately in opencode.ts), which also fails over across
+// providers. These stay because they own `anthropic/*` auth, which opencode
+// itself does not provide. See anthropic-auth-plugin.ts for the full note.
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js'
 export { openaiRotationPlugin } from './openai-auth-plugin.js'
 export { xaiRotationPlugin } from './xai-auth-plugin.js'
 export { imageOptimizerPlugin } from './image-optimizer-plugin.js'
-export { subagentRateLimitPlugin } from './subagent-rate-limit-plugin.js'
 export { cacheDriftPlugin } from './cache-drift-plugin.js'
 export { kittyGraphicsPlugin } from 'kitty-graphics-agent'
 export { injectionGuardInternal as injectionGuard } from 'opencode-injection-guard'
 export { kimakiWorkspaceAdaptorPlugin } from './kimaki-workspace-adaptor.js'
+export { fileEditTrackerPlugin } from './file-edit-log.js'
+export { bashToolSchemaPlugin } from './bash-tool-schema-plugin.js'

package/src/kimaki-workspace-adaptor.ts

@@ -9,7 +9,11 @@
 import type { Plugin, WorkspaceAdapter, WorkspaceInfo } from '@opencode-ai/plugin'
 import crypto from 'node:crypto'
 import path from 'node:path'
-import { createWorktreeCore, removeWorktreeCore } from './git-worktree-core.js'
+import {
+  createWorktreeCore,
+  KIMAKI_WORKTREE_ADAPTER_TYPE,
+  removeWorktreeFromOwnRepository,
+} from './git-worktree-core.js'
 
 /**
  * Compute the on-disk directory for a managed worktree.
@@ -39,15 +43,41 @@ function computeWorktreeDirectory({
   return path.join(dataDir, 'worktrees', projectHash, withoutPrefix)
 }
 
-function createKimakiWorktreeAdaptor(projectDirectory: string): WorkspaceAdapter {
+function getWorktreeIdentity(info: WorkspaceInfo) {
+  if (!info.extra || typeof info.extra !== 'object') {
+    return new Error('Kimaki worktree identity is missing')
+  }
+  const identity: { projectDirectory?: string; baseCommit?: string } = {}
+  Object.assign(identity, info.extra)
+  if (
+    typeof identity.projectDirectory !== 'string' ||
+    !path.isAbsolute(identity.projectDirectory)
+  ) {
+    return new Error('Kimaki worktree project directory must be absolute')
+  }
+  if (
+    typeof identity.baseCommit !== 'string' ||
+    !/^[0-9a-f]{40}$/i.test(identity.baseCommit)
+  ) {
+    return new Error('Kimaki worktree base commit must be a full commit SHA')
+  }
+  return {
+    projectDirectory: identity.projectDirectory,
+    baseCommit: identity.baseCommit,
+  }
+}
+
+function createKimakiWorktreeAdaptor(): WorkspaceAdapter {
   return {
     name: 'Kimaki Worktree',
     description: 'Create a git worktree managed by Kimaki',
 
     configure(info: WorkspaceInfo): WorkspaceInfo {
+      const identity = getWorktreeIdentity(info)
+      if (identity instanceof Error) throw identity
       const branchName = info.branch || info.name
       const directory = computeWorktreeDirectory({
-        projectDirectory,
+        projectDirectory: identity.projectDirectory,
         branchName,
       })
       if (directory instanceof Error) {
@@ -65,12 +95,13 @@ function createKimakiWorktreeAdaptor(projectDirectory: string): WorkspaceAdapter
       if (!info.directory) {
         throw new Error('Workspace directory not set — configure() likely failed')
       }
-      const baseBranch = (info.extra as { baseBranch?: string })?.baseBranch || undefined
+      const identity = getWorktreeIdentity(info)
+      if (identity instanceof Error) throw identity
       const result = await createWorktreeCore({
-        projectDirectory,
+        projectDirectory: identity.projectDirectory,
         targetDirectory: info.directory,
         branchName: info.branch || info.name,
-        baseBranch,
+        baseCommit: identity.baseCommit,
         // Silent log — plugin must not write to stdout/stderr
       })
       if (result instanceof Error) {
@@ -80,8 +111,7 @@ function createKimakiWorktreeAdaptor(projectDirectory: string): WorkspaceAdapter
 
     async remove(info: WorkspaceInfo): Promise<void> {
       if (!info.directory) return
-      const result = await removeWorktreeCore({
-        projectDirectory,
+      const result = await removeWorktreeFromOwnRepository({
         worktreeDirectory: info.directory,
         branchName: info.branch || '',
       })
@@ -104,12 +134,11 @@ function createKimakiWorktreeAdaptor(projectDirectory: string): WorkspaceAdapter
  * Called by OpenCode's plugin loader.
  */
 export const kimakiWorkspaceAdaptorPlugin: Plugin = async ({
-  directory,
   experimental_workspace,
 }) => {
   experimental_workspace.register(
-    'kimaki-worktree',
-    createKimakiWorktreeAdaptor(directory),
+    KIMAKI_WORKTREE_ADAPTER_TYPE,
+    createKimakiWorktreeAdaptor(),
   )
   return {}
 }