@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/plugin/hooks/create-continuation-hooks.ts

@@ -1,128 +0,0 @@
-import type { HookName, HiaiOpenCodeConfig } from "../../config"
-import type { BackgroundManager } from "../../features/background-agent"
-import type { PluginContext } from "../types"
-
-import {
-  createTodoContinuationEnforcer,
-  createBackgroundNotificationHook,
-  createStopContinuationGuardHook,
-  createCompactionContextInjector,
-  createCompactionTodoPreserverHook,
-  createGuardHook,
-} from "../../hooks"
-import { safeCreateHook } from "../../shared/safe-create-hook"
-import { createUnstableAgentBabysitter } from "../unstable-agent-babysitter"
-
-export type ContinuationHooks = {
-  stopContinuationGuard: ReturnType<typeof createStopContinuationGuardHook> | null
-  compactionContextInjector: ReturnType<typeof createCompactionContextInjector> | null
-  compactionTodoPreserver: ReturnType<typeof createCompactionTodoPreserverHook> | null
-  todoContinuationEnforcer: ReturnType<typeof createTodoContinuationEnforcer> | null
-  unstableAgentBabysitter: ReturnType<typeof createUnstableAgentBabysitter> | null
-  backgroundNotificationHook: ReturnType<typeof createBackgroundNotificationHook> | null
-  guardHook: ReturnType<typeof createGuardHook> | null
-}
-
-type SessionRecovery = {
-  setOnAbortCallback: (callback: (sessionID: string) => void) => void
-  setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void
-} | null
-
-export function createContinuationHooks(args: {
-  ctx: PluginContext
-  pluginConfig: HiaiOpenCodeConfig
-  isHookEnabled: (hookName: HookName) => boolean
-  safeHookEnabled: boolean
-  backgroundManager: BackgroundManager
-  sessionRecovery: SessionRecovery
-}): ContinuationHooks {
-  const {
-    ctx,
-    pluginConfig,
-    isHookEnabled,
-    safeHookEnabled,
-    backgroundManager,
-    sessionRecovery,
-  } = args
-
-  const safeHook = <T>(hookName: HookName, factory: () => T): T | null =>
-    safeCreateHook(hookName, factory, { enabled: safeHookEnabled })
-
-  const stopContinuationGuard = isHookEnabled("stop-continuation-guard")
-    ? safeHook("stop-continuation-guard", () =>
-        createStopContinuationGuardHook(ctx, {
-          backgroundManager,
-        }))
-    : null
-
-  const compactionContextInjector = isHookEnabled("compaction-context-injector")
-    ? safeHook("compaction-context-injector", () =>
-        createCompactionContextInjector({ ctx, backgroundManager }))
-    : null
-
-  const compactionTodoPreserver = isHookEnabled("compaction-todo-preserver")
-    ? safeHook("compaction-todo-preserver", () => createCompactionTodoPreserverHook(ctx))
-    : null
-
-  const todoContinuationEnforcer = isHookEnabled("todo-continuation-enforcer")
-    ? safeHook("todo-continuation-enforcer", () =>
-      createTodoContinuationEnforcer(ctx, {
-          backgroundManager,
-          isContinuationStopped: stopContinuationGuard?.isStopped,
-        }))
-    : null
-
-  const unstableAgentBabysitter = isHookEnabled("unstable-agent-babysitter")
-    ? safeHook("unstable-agent-babysitter", () =>
-        createUnstableAgentBabysitter({ ctx, backgroundManager, pluginConfig }))
-    : null
-
-  if (sessionRecovery) {
-    const onAbortCallbacks: Array<(sessionID: string) => void> = []
-    const onRecoveryCompleteCallbacks: Array<(sessionID: string) => void> = []
-
-    if (todoContinuationEnforcer) {
-      onAbortCallbacks.push(todoContinuationEnforcer.markRecovering)
-      onRecoveryCompleteCallbacks.push(todoContinuationEnforcer.markRecoveryComplete)
-    }
-
-
-    if (onAbortCallbacks.length > 0) {
-      sessionRecovery.setOnAbortCallback((sessionID: string) => {
-        for (const callback of onAbortCallbacks) callback(sessionID)
-      })
-    }
-
-    if (onRecoveryCompleteCallbacks.length > 0) {
-      sessionRecovery.setOnRecoveryCompleteCallback((sessionID: string) => {
-        for (const callback of onRecoveryCompleteCallbacks) callback(sessionID)
-      })
-    }
-  }
-
-  const backgroundNotificationHook = isHookEnabled("background-notification")
-    ? safeHook("background-notification", () => createBackgroundNotificationHook(backgroundManager))
-    : null
-
-  const guardHook = isHookEnabled("guard")
-    ? safeHook("guard", () =>
-        createGuardHook(ctx, {
-          directory: ctx.directory,
-          backgroundManager,
-          isContinuationStopped: (sessionID: string) =>
-            stopContinuationGuard?.isStopped(sessionID) ?? false,
-          agentOverrides: pluginConfig.agents,
-          autoCommit: pluginConfig.start_work?.auto_commit,
-        }))
-    : null
-
-  return {
-    stopContinuationGuard,
-    compactionContextInjector,
-    compactionTodoPreserver,
-    todoContinuationEnforcer,
-    unstableAgentBabysitter,
-    backgroundNotificationHook,
-    guardHook,
-  }
-}

package/src/plugin/hooks/create-core-hooks.ts

@@ -1,47 +0,0 @@
-import type { HookName, HiaiOpenCodeConfig } from "../../config"
-import type { PluginContext } from "../types"
-import type { ModelCacheState } from "../../plugin-state"
-
-import { createSessionHooks } from "./create-session-hooks"
-import { createToolGuardHooks } from "./create-tool-guard-hooks"
-import { createTransformHooks } from "./create-transform-hooks"
-
-export function createCoreHooks(args: {
-  ctx: PluginContext
-  pluginConfig: HiaiOpenCodeConfig
-  modelCacheState: ModelCacheState
-  isHookEnabled: (hookName: HookName) => boolean
-  safeHookEnabled: boolean
-}) {
-  const { ctx, pluginConfig, modelCacheState, isHookEnabled, safeHookEnabled } = args
-
-  const session = createSessionHooks({
-    ctx,
-    pluginConfig,
-    modelCacheState,
-    isHookEnabled,
-    safeHookEnabled,
-  })
-
-  const tool = createToolGuardHooks({
-    ctx,
-    pluginConfig,
-    modelCacheState,
-    isHookEnabled,
-    safeHookEnabled,
-  })
-
-  const transform = createTransformHooks({
-    ctx,
-    pluginConfig,
-    isHookEnabled: (name) => isHookEnabled(name as HookName),
-    safeHookEnabled,
-    ralphLoop: session.ralphLoop,
-  })
-
-  return {
-    ...session,
-    ...tool,
-    ...transform,
-  }
-}

package/src/plugin/hooks/create-session-hooks.ts

@@ -1,269 +0,0 @@
-import type { HiaiOpenCodeConfig, HookName } from "../../config"
-import type { ModelCacheState } from "../../plugin-state"
-import type { PluginContext } from "../types"
-
-import {
-  createContextWindowMonitorHook,
-  createSessionRecoveryHook,
-  createSessionNotification,
-  createThinkModeHook,
-  createModelFallbackHook,
-  createAnthropicContextWindowLimitRecoveryHook,
-  createAgentUsageReminderHook,
-  createNonInteractiveEnvHook,
-  createInteractiveBashSessionHook,
-  createRalphLoopHook,
-  createEditErrorRecoveryHook,
-  createDelegateTaskRetryHook,
-  createTaskResumeInfoHook,
-  createStartWorkHook,
-  createStrategistMdOnlyHook,
-  createBobJuniorNotepadHook,
-  createQuestionLabelTruncatorHook,
-  createPreemptiveCompactionHook,
-  createRuntimeFallbackHook,
-  createLegacyPluginToastHook,
-} from "../../hooks"
-import { createAnthropicEffortHook } from "../../hooks/anthropic-effort"
-import {
-  detectExternalNotificationPlugin,
-  getNotificationConflictWarning,
-  log,
-  normalizeSDKResponse,
-} from "../../shared"
-import { safeCreateHook } from "../../shared/safe-create-hook"
-import { sessionExists } from "../../tools"
-import { isTmuxIntegrationEnabled } from "../../create-runtime-tmux-config"
-
-export type SessionHooks = {
-  contextWindowMonitor: ReturnType<typeof createContextWindowMonitorHook> | null
-  preemptiveCompaction: ReturnType<typeof createPreemptiveCompactionHook> | null
-  sessionRecovery: ReturnType<typeof createSessionRecoveryHook> | null
-  sessionNotification: ReturnType<typeof createSessionNotification> | null
-  thinkMode: ReturnType<typeof createThinkModeHook> | null
-  modelFallback: ReturnType<typeof createModelFallbackHook> | null
-  anthropicContextWindowLimitRecovery: ReturnType<typeof createAnthropicContextWindowLimitRecoveryHook> | null
-  agentUsageReminder: ReturnType<typeof createAgentUsageReminderHook> | null
-  nonInteractiveEnv: ReturnType<typeof createNonInteractiveEnvHook> | null
-  interactiveBashSession: ReturnType<typeof createInteractiveBashSessionHook> | null
-  ralphLoop: ReturnType<typeof createRalphLoopHook> | null
-  editErrorRecovery: ReturnType<typeof createEditErrorRecoveryHook> | null
-  delegateTaskRetry: ReturnType<typeof createDelegateTaskRetryHook> | null
-  startWork: ReturnType<typeof createStartWorkHook> | null
-  strategistMdOnly: ReturnType<typeof createStrategistMdOnlyHook> | null
-  bobJuniorNotepad: ReturnType<typeof createBobJuniorNotepadHook> | null
-  questionLabelTruncator: ReturnType<typeof createQuestionLabelTruncatorHook> | null
-  taskResumeInfo: ReturnType<typeof createTaskResumeInfoHook> | null
-  anthropicEffort: ReturnType<typeof createAnthropicEffortHook> | null
-  runtimeFallback: ReturnType<typeof createRuntimeFallbackHook> | null
-  legacyPluginToast: ReturnType<typeof createLegacyPluginToastHook> | null
-}
-
-export function createSessionHooks(args: {
-  ctx: PluginContext
-  pluginConfig: HiaiOpenCodeConfig
-  modelCacheState: ModelCacheState
-  isHookEnabled: (hookName: HookName) => boolean
-  safeHookEnabled: boolean
-}): SessionHooks {
-  const { ctx, pluginConfig, modelCacheState, isHookEnabled, safeHookEnabled } = args
-  const safeHook = <T>(hookName: HookName, factory: () => T): T | null =>
-    safeCreateHook(hookName, factory, { enabled: safeHookEnabled })
-
-  const contextWindowMonitor = isHookEnabled("context-window-monitor")
-    ? safeHook("context-window-monitor", () =>
-        createContextWindowMonitorHook(ctx, modelCacheState))
-    : null
-
-  const preemptiveCompaction =
-    isHookEnabled("preemptive-compaction") &&
-    pluginConfig.experimental?.preemptive_compaction
-      ? safeHook("preemptive-compaction", () =>
-          createPreemptiveCompactionHook(ctx, pluginConfig, modelCacheState))
-      : null
-
-  const sessionRecovery = isHookEnabled("session-recovery")
-    ? safeHook("session-recovery", () =>
-        createSessionRecoveryHook(ctx, { experimental: pluginConfig.experimental }))
-    : null
-
-  let sessionNotification: ReturnType<typeof createSessionNotification> | null = null
-  if (isHookEnabled("session-notification")) {
-    const forceEnable = pluginConfig.notification?.force_enable ?? false
-    const externalNotifier = detectExternalNotificationPlugin(ctx.directory)
-    if (externalNotifier.detected && !forceEnable) {
-      log(getNotificationConflictWarning(externalNotifier.pluginName!))
-    } else {
-      sessionNotification = safeHook("session-notification", () => createSessionNotification(ctx))
-    }
-  }
-
-  const thinkMode = isHookEnabled("think-mode")
-    ? safeHook("think-mode", () => createThinkModeHook())
-    : null
-
-  const enableFallbackTitle = pluginConfig.experimental?.model_fallback_title ?? false
-  const fallbackTitleMaxEntries = 200
-  const fallbackTitleState = new Map<string, { baseTitle?: string; lastKey?: string }>()
-  const updateFallbackTitle = async (input: {
-    sessionID: string
-    providerID: string
-    modelID: string
-    variant?: string
-  }) => {
-    if (!enableFallbackTitle) return
-    const key = `${input.providerID}/${input.modelID}${input.variant ? `:${input.variant}` : ""}`
-    const existing = fallbackTitleState.get(input.sessionID) ?? {}
-    if (existing.lastKey === key) return
-
-    if (!existing.baseTitle) {
-      const sessionResp = await ctx.client.session.get({ path: { id: input.sessionID } }).catch(() => null)
-      const sessionInfo = sessionResp
-        ? normalizeSDKResponse(sessionResp, null as { title?: string } | null, { preferResponseOnMissingData: true })
-        : null
-      const rawTitle = sessionInfo?.title
-      if (typeof rawTitle === "string" && rawTitle.length > 0) {
-        existing.baseTitle = rawTitle.replace(/\s*\[fallback:[^\]]+\]$/i, "").trim()
-      } else {
-        existing.baseTitle = "Session"
-      }
-    }
-
-    const variantLabel = input.variant ? ` ${input.variant}` : ""
-    const newTitle = `${existing.baseTitle} [fallback: ${input.providerID}/${input.modelID}${variantLabel}]`
-
-    await ctx.client.session
-      .update({
-        path: { id: input.sessionID },
-        body: { title: newTitle },
-        query: { directory: ctx.directory },
-      })
-      .catch(() => {})
-
-    existing.lastKey = key
-    fallbackTitleState.set(input.sessionID, existing)
-    if (fallbackTitleState.size > fallbackTitleMaxEntries) {
-      const oldestKey = fallbackTitleState.keys().next().value
-      if (oldestKey) fallbackTitleState.delete(oldestKey)
-    }
-  }
-
-  const isModelFallbackConfigEnabled = pluginConfig.model_fallback ?? false
-  const modelFallback = isModelFallbackConfigEnabled && isHookEnabled("model-fallback")
-    ? safeHook("model-fallback", () =>
-      createModelFallbackHook({
-        toast: async ({ title, message, variant, duration }) => {
-          await ctx.client.tui
-            .showToast({
-              body: {
-                title,
-                message,
-                variant: variant ?? "warning",
-                duration: duration ?? 5000,
-              },
-            })
-            .catch(() => {})
-        },
-        onApplied: enableFallbackTitle ? updateFallbackTitle : undefined,
-      }))
-    : null
-
-  const anthropicContextWindowLimitRecovery = isHookEnabled("anthropic-context-window-limit-recovery")
-    ? safeHook("anthropic-context-window-limit-recovery", () =>
-        createAnthropicContextWindowLimitRecoveryHook(ctx, { experimental: pluginConfig.experimental, pluginConfig }))
-    : null
-
-  const agentUsageReminder = isHookEnabled("agent-usage-reminder")
-    ? safeHook("agent-usage-reminder", () => createAgentUsageReminderHook(ctx))
-    : null
-
-  const nonInteractiveEnv = isHookEnabled("non-interactive-env")
-    ? safeHook("non-interactive-env", () => createNonInteractiveEnvHook(ctx))
-    : null
-
-  const interactiveBashSession =
-    isHookEnabled("interactive-bash-session") &&
-    isTmuxIntegrationEnabled(pluginConfig)
-    ? safeHook("interactive-bash-session", () => createInteractiveBashSessionHook(ctx))
-    : null
-
-  const ralphLoop = isHookEnabled("ralph-loop")
-    ? safeHook("ralph-loop", () =>
-        createRalphLoopHook(ctx, {
-          config: pluginConfig.ralph_loop,
-          checkSessionExists: async (sessionId) => await sessionExists(sessionId),
-        }))
-    : null
-
-  const editErrorRecovery = isHookEnabled("edit-error-recovery")
-    ? safeHook("edit-error-recovery", () => createEditErrorRecoveryHook(ctx))
-    : null
-
-  const delegateTaskRetry = isHookEnabled("delegate-task-retry")
-    ? safeHook("delegate-task-retry", () => createDelegateTaskRetryHook(ctx))
-    : null
-
-  const startWork = isHookEnabled("start-work")
-    ? safeHook("start-work", () => createStartWorkHook(ctx))
-    : null
-
-  const strategistMdOnly = isHookEnabled("strategist-md-only")
-    ? safeHook("strategist-md-only", () => createStrategistMdOnlyHook(ctx))
-    : null
-
-  const bobJuniorNotepad = isHookEnabled("sub-notepad")
-    ? safeHook("sub-notepad", () => createBobJuniorNotepadHook(ctx))
-    : null
-
-  const questionLabelTruncator = isHookEnabled("question-label-truncator")
-    ? safeHook("question-label-truncator", () => createQuestionLabelTruncatorHook())
-    : null
-  const taskResumeInfo = isHookEnabled("task-resume-info")
-    ? safeHook("task-resume-info", () => createTaskResumeInfoHook())
-    : null
-
-  const anthropicEffort = isHookEnabled("anthropic-effort")
-    ? safeHook("anthropic-effort", () => createAnthropicEffortHook())
-    : null
-
-  const runtimeFallbackConfig =
-    typeof pluginConfig.runtime_fallback === "boolean"
-      ? { enabled: pluginConfig.runtime_fallback }
-      : pluginConfig.runtime_fallback
-
-  const runtimeFallback = isHookEnabled("runtime-fallback")
-    ? safeHook("runtime-fallback", () =>
-        createRuntimeFallbackHook(ctx, {
-          config: runtimeFallbackConfig,
-          pluginConfig,
-        }))
-    : null
-
-  const legacyPluginToast = isHookEnabled("legacy-plugin-toast")
-    ? safeHook("legacy-plugin-toast", () => createLegacyPluginToastHook(ctx))
-    : null
-
-  return {
-    contextWindowMonitor,
-    preemptiveCompaction,
-    sessionRecovery,
-    sessionNotification,
-    thinkMode,
-    modelFallback,
-    anthropicContextWindowLimitRecovery,
-    agentUsageReminder,
-    nonInteractiveEnv,
-    interactiveBashSession,
-    ralphLoop,
-    editErrorRecovery,
-    delegateTaskRetry,
-    startWork,
-    strategistMdOnly,
-    bobJuniorNotepad,
-    questionLabelTruncator,
-    taskResumeInfo,
-    anthropicEffort,
-    runtimeFallback,
-    legacyPluginToast,
-  }
-}

package/src/plugin/hooks/create-skill-hooks.ts

@@ -1,50 +0,0 @@
-import type { AvailableSkill } from "../../agents/dynamic-agent-prompt-builder"
-import type { HookName, HiaiOpenCodeConfig } from "../../config"
-import type { LoadedSkill } from "../../features/opencode-skill-loader/types"
-import type { PluginContext } from "../types"
-
-import { createAutoSlashCommandHook, createCategorySkillReminderHook } from "../../hooks"
-import { safeCreateHook } from "../../shared/safe-create-hook"
-
-export type SkillHooks = {
-  categorySkillReminder: ReturnType<typeof createCategorySkillReminderHook> | null
-  autoSlashCommand: ReturnType<typeof createAutoSlashCommandHook> | null
-}
-
-export function createSkillHooks(args: {
-  ctx: PluginContext
-  pluginConfig: HiaiOpenCodeConfig
-  isHookEnabled: (hookName: HookName) => boolean
-  safeHookEnabled: boolean
-  mergedSkills: LoadedSkill[]
-  availableSkills: AvailableSkill[]
-}): SkillHooks {
-  const {
-    ctx,
-    pluginConfig,
-    isHookEnabled,
-    safeHookEnabled,
-    mergedSkills,
-    availableSkills,
-  } = args
-
-  const safeHook = <T>(hookName: HookName, factory: () => T): T | null =>
-    safeCreateHook(hookName, factory, { enabled: safeHookEnabled })
-
-  const categorySkillReminder = isHookEnabled("category-skill-reminder")
-    ? safeHook("category-skill-reminder", () =>
-        createCategorySkillReminderHook(ctx, availableSkills))
-    : null
-
-  const autoSlashCommand = isHookEnabled("auto-slash-command")
-    ? safeHook("auto-slash-command", () =>
-        createAutoSlashCommandHook({
-          skills: mergedSkills,
-          pluginsEnabled: pluginConfig.claude_code?.plugins ?? true,
-          enabledPluginsOverride: pluginConfig.claude_code?.plugins_override,
-          directory: ctx.directory,
-        }))
-    : null
-
-  return { categorySkillReminder, autoSlashCommand }
-}

package/src/plugin/hooks/create-tool-guard-hooks.ts

@@ -1,159 +0,0 @@
-import type { HookName, HiaiOpenCodeConfig } from "../../config"
-import type { ModelCacheState } from "../../plugin-state"
-import type { PluginContext } from "../types"
-
-import {
-  createCommentCheckerHooks,
-  createToolOutputTruncatorHook,
-  createDirectoryAgentsInjectorHook,
-  createDirectoryReadmeInjectorHook,
-  createEmptyTaskResponseDetectorHook,
-  createRulesInjectorHook,
-  createTasksTodowriteDisablerHook,
-  createWriteExistingFileGuardHook,
-  createBashFileReadGuardHook,
-  createHashlineReadEnhancerHook,
-  createReadImageResizerHook,
-  createJsonErrorRecoveryHook,
-  createTodoDescriptionOverrideHook,
-  createWebFetchRedirectGuardHook,
-  createFastApplyHook,
-} from "../../hooks"
-import {
-  getOpenCodeVersion,
-  isOpenCodeVersionAtLeast,
-  log,
-  OPENCODE_NATIVE_AGENTS_INJECTION_VERSION,
-} from "../../shared"
-import { safeCreateHook } from "../../shared/safe-create-hook"
-
-export type ToolGuardHooks = {
-  commentChecker: ReturnType<typeof createCommentCheckerHooks> | null
-  toolOutputTruncator: ReturnType<typeof createToolOutputTruncatorHook> | null
-  directoryAgentsInjector: ReturnType<typeof createDirectoryAgentsInjectorHook> | null
-  directoryReadmeInjector: ReturnType<typeof createDirectoryReadmeInjectorHook> | null
-  emptyTaskResponseDetector: ReturnType<typeof createEmptyTaskResponseDetectorHook> | null
-  rulesInjector: ReturnType<typeof createRulesInjectorHook> | null
-  tasksTodowriteDisabler: ReturnType<typeof createTasksTodowriteDisablerHook> | null
-  writeExistingFileGuard: ReturnType<typeof createWriteExistingFileGuardHook> | null
-  bashFileReadGuard: ReturnType<typeof createBashFileReadGuardHook> | null
-  hashlineReadEnhancer: ReturnType<typeof createHashlineReadEnhancerHook> | null
-  jsonErrorRecovery: ReturnType<typeof createJsonErrorRecoveryHook> | null
-  readImageResizer: ReturnType<typeof createReadImageResizerHook> | null
-  todoDescriptionOverride: ReturnType<typeof createTodoDescriptionOverrideHook> | null
-  webfetchRedirectGuard: ReturnType<typeof createWebFetchRedirectGuardHook> | null
-  fastApply: ReturnType<typeof createFastApplyHook> | null
-}
-
-export function createToolGuardHooks(args: {
-  ctx: PluginContext
-  pluginConfig: HiaiOpenCodeConfig
-  modelCacheState: ModelCacheState
-  isHookEnabled: (hookName: HookName) => boolean
-  safeHookEnabled: boolean
-}): ToolGuardHooks {
-  const { ctx, pluginConfig, modelCacheState, isHookEnabled, safeHookEnabled } = args
-  const safeHook = <T>(hookName: HookName, factory: () => T): T | null =>
-    safeCreateHook(hookName, factory, { enabled: safeHookEnabled })
-
-  const commentChecker = isHookEnabled("comment-checker")
-    ? safeHook("comment-checker", () => createCommentCheckerHooks(pluginConfig.comment_checker))
-    : null
-
-  const toolOutputTruncator = isHookEnabled("tool-output-truncator")
-    ? safeHook("tool-output-truncator", () =>
-        createToolOutputTruncatorHook(ctx, {
-          modelCacheState,
-          experimental: pluginConfig.experimental,
-        }))
-    : null
-
-  let directoryAgentsInjector: ReturnType<typeof createDirectoryAgentsInjectorHook> | null = null
-  if (isHookEnabled("directory-agents-injector")) {
-    const currentVersion = getOpenCodeVersion()
-    const hasNativeSupport =
-      currentVersion !== null && isOpenCodeVersionAtLeast(OPENCODE_NATIVE_AGENTS_INJECTION_VERSION)
-    if (hasNativeSupport) {
-      log("directory-agents-injector auto-disabled due to native OpenCode support", {
-        currentVersion,
-        nativeVersion: OPENCODE_NATIVE_AGENTS_INJECTION_VERSION,
-      })
-    } else {
-      directoryAgentsInjector = safeHook("directory-agents-injector", () =>
-        createDirectoryAgentsInjectorHook(ctx, modelCacheState))
-    }
-  }
-
-  const directoryReadmeInjector = isHookEnabled("directory-readme-injector")
-    ? safeHook("directory-readme-injector", () =>
-        createDirectoryReadmeInjectorHook(ctx, modelCacheState))
-    : null
-
-  const emptyTaskResponseDetector = isHookEnabled("empty-task-response-detector")
-    ? safeHook("empty-task-response-detector", () => createEmptyTaskResponseDetectorHook(ctx))
-    : null
-
-  const cc = pluginConfig.claude_code
-  const skipClaudeUserRules = cc?.hooks === false
-  const rulesInjector = isHookEnabled("rules-injector")
-    ? safeHook("rules-injector", () =>
-        createRulesInjectorHook(ctx, modelCacheState, {
-          skipClaudeUserRules,
-        }))
-    : null
-
-  const tasksTodowriteDisabler = isHookEnabled("tasks-todowrite-disabler")
-    ? safeHook("tasks-todowrite-disabler", () =>
-        createTasksTodowriteDisablerHook({ experimental: pluginConfig.experimental }))
-    : null
-
-  const writeExistingFileGuard = isHookEnabled("write-existing-file-guard")
-    ? safeHook("write-existing-file-guard", () => createWriteExistingFileGuardHook(ctx))
-    : null
-
-  const bashFileReadGuard = isHookEnabled("bash-file-read-guard")
-    ? safeHook("bash-file-read-guard", () => createBashFileReadGuardHook())
-    : null
-
-  const hashlineReadEnhancer = isHookEnabled("hashline-read-enhancer")
-    ? safeHook("hashline-read-enhancer", () => createHashlineReadEnhancerHook(ctx, { hashline_edit: { enabled: pluginConfig.hashline_edit ?? false } }))
-    : null
-
-  const jsonErrorRecovery = isHookEnabled("json-error-recovery")
-    ? safeHook("json-error-recovery", () => createJsonErrorRecoveryHook(ctx))
-    : null
-
-  const readImageResizer = isHookEnabled("read-image-resizer")
-    ? safeHook("read-image-resizer", () => createReadImageResizerHook(ctx))
-    : null
-
-  const todoDescriptionOverride = isHookEnabled("todo-description-override")
-    ? safeHook("todo-description-override", () => createTodoDescriptionOverrideHook())
-    : null
-
-  const webfetchRedirectGuard = isHookEnabled("webfetch-redirect-guard")
-    ? safeHook("webfetch-redirect-guard", () => createWebFetchRedirectGuardHook(ctx))
-    : null
-
-  const fastApply = isHookEnabled("fast-apply")
-    ? safeHook("fast-apply", () => createFastApplyHook(pluginConfig.fast_apply ?? { enabled: false, ollama_url: "", model: "", timeout: 30000 }))
-    : null
-
-  return {
-    commentChecker,
-    toolOutputTruncator,
-    directoryAgentsInjector,
-    directoryReadmeInjector,
-    emptyTaskResponseDetector,
-    rulesInjector,
-    tasksTodowriteDisabler,
-    writeExistingFileGuard,
-    bashFileReadGuard,
-    hashlineReadEnhancer,
-    jsonErrorRecovery,
-    readImageResizer,
-    todoDescriptionOverride,
-    webfetchRedirectGuard,
-    fastApply,
-  }
-}