@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/plugin/tool-execute-before.ts

@@ -1,222 +0,0 @@
-import type { PluginContext } from "./types"
-import { randomUUID } from "node:crypto"
-
-import { getMainSessionID } from "../features/claude-code-session-state"
-import { clearBoulderState } from "../features/boulder-state"
-import { log } from "../shared"
-import { getAgentConfigKey, stripInvisibleAgentCharacters } from "../shared/agent-display-names"
-import { resolveSessionAgent } from "./session-agent-resolver"
-import { parseRalphLoopArguments } from "../hooks/ralph-loop/command-arguments"
-import { ULTRAWORK_VERIFICATION_PROMISE } from "../hooks/ralph-loop/constants"
-import { readState, writeState } from "../hooks/ralph-loop/storage"
-
-import type { CreatedHooks } from "../create-hooks"
-
-function getLoopCommandArguments(args: Record<string, unknown>, command: "ralph-loop" | "ulw-loop"): string {
-  const rawUserMessage = typeof args.user_message === "string" ? args.user_message.trim() : ""
-  if (rawUserMessage) {
-    return rawUserMessage
-  }
-
-  const rawName = typeof args.name === "string" ? args.name : ""
-  return rawName.replace(new RegExp(`^/?(${command})\\s*`, "i"), "")
-}
-
-const ULTRAWORK_VERIFICATION_GATE_AGENT_KEYS = new Set(["critic"])
-
-function normalizeAgentKey(agentName: string | undefined): string | undefined {
-  if (typeof agentName !== "string") {
-    return undefined
-  }
-  const stripped = stripInvisibleAgentCharacters(agentName).trim()
-  if (!stripped) {
-    return undefined
-  }
-  return stripInvisibleAgentCharacters(getAgentConfigKey(stripped)).trim().toLowerCase()
-}
-
-function isUltraworkVerificationAgent(agentName: string | undefined): boolean {
-  const normalized = normalizeAgentKey(agentName)
-  return normalized ? ULTRAWORK_VERIFICATION_GATE_AGENT_KEYS.has(normalized) : false
-}
-
-export function createToolExecuteBeforeHandler(args: {
-  ctx: PluginContext
-  hooks: CreatedHooks
-}): (
-  input: { tool: string; sessionID: string; callID: string },
-  output: { args: Record<string, unknown> },
-) => Promise<void> {
-  const { ctx, hooks } = args
-
-  function buildUltraworkCriticVerificationPrompt(prompt: string, originalTask: string, verificationAttemptId: string): string {
-    const verificationPrompt = [
-      "You are verifying the active ULTRAWORK loop result for this session.",
-      "",
-      "Original task:",
-      originalTask,
-      "",
-      "Review the work skeptically and critically.",
-      "Assume it may be incomplete, misleading, or subtly broken until the evidence proves otherwise.",
-      "Look for missing scope, weak verification, process violations, hidden regressions, and any reason the task should NOT be considered complete.",
-      "",
-      `If the work is fully complete, end your response with <promise>${ULTRAWORK_VERIFICATION_PROMISE}</promise>.`,
-      "If the work is not complete, explain the blocking issues clearly and DO NOT emit that promise.",
-      "",
-      `<ulw_verification_attempt_id>${verificationAttemptId}</ulw_verification_attempt_id>`,
-    ].join("\n")
-
-    return `${prompt ? `${prompt}\n\n` : ""}${verificationPrompt}`
-  }
-
-  return async (input, output): Promise<void> => {
-    if (input.tool.toLowerCase() === "bash" && typeof output.args.command === "string") {
-      if (output.args.command.includes("\x00")) {
-        output.args.command = output.args.command.replace(/\x00/g, "")
-        log("[tool-execute-before] Stripped null bytes from bash command", {
-          sessionID: input.sessionID,
-          callID: input.callID,
-        })
-      }
-    }
-
-    await hooks.writeExistingFileGuard?.["tool.execute.before"]?.(input, output)
-    await hooks.questionLabelTruncator?.["tool.execute.before"]?.(input, output)
-    await hooks.claudeCodeHooks?.["tool.execute.before"]?.(input, output)
-    await hooks.nonInteractiveEnv?.["tool.execute.before"]?.(input, output)
-    await hooks.bashFileReadGuard?.["tool.execute.before"]?.(input, output)
-    await hooks.commentChecker?.["tool.execute.before"]?.(input, output)
-    await hooks.directoryAgentsInjector?.["tool.execute.before"]?.(input, output)
-    await hooks.directoryReadmeInjector?.["tool.execute.before"]?.(input, output)
-    await hooks.rulesInjector?.["tool.execute.before"]?.(input, output)
-    await hooks.tasksTodowriteDisabler?.["tool.execute.before"]?.(input, output)
-    await hooks.fastApply?.["tool.execute.before"]?.(input, output)
-    await hooks.webfetchRedirectGuard?.["tool.execute.before"]?.(input, output)
-    await hooks.strategistMdOnly?.["tool.execute.before"]?.(input, output)
-    await hooks.bobJuniorNotepad?.["tool.execute.before"]?.(input, output)
-    await hooks.guardHook?.["tool.execute.before"]?.(input, output)
-
-    const normalizedToolName = input.tool.toLowerCase()
-    if (
-      normalizedToolName === "question"
-      || normalizedToolName === "ask_user_question"
-      || normalizedToolName === "askuserquestion"
-    ) {
-      const sessionID = input.sessionID || getMainSessionID()
-      await hooks.sessionNotification?.({
-        event: {
-          type: "tool.execute.before",
-          properties: {
-            sessionID,
-            tool: input.tool,
-            args: output.args,
-          },
-        },
-      })
-    }
-
-    if (input.tool === "task") {
-      const argsObject = output.args
-      const category = typeof argsObject.category === "string" ? argsObject.category : undefined
-      const subagentType = typeof argsObject.subagent_type === "string" ? argsObject.subagent_type : undefined
-      const sessionId = typeof argsObject.session_id === "string" ? argsObject.session_id : undefined
-
-      if (category) {
-        argsObject.subagent_type = "sub"
-      } else if (!subagentType && sessionId) {
-        const resolvedAgent = await resolveSessionAgent(ctx.client, sessionId)
-        argsObject.subagent_type = resolvedAgent ?? "continue"
-      }
-
-      const normalizedSubagentType =
-        typeof argsObject.subagent_type === "string" ? stripInvisibleAgentCharacters(argsObject.subagent_type) : undefined
-      const prompt = typeof argsObject.prompt === "string" ? argsObject.prompt : ""
-      const loopState = typeof ctx.directory === "string" ? readState(ctx.directory) : null
-      const shouldInjectCriticVerification =
-        isUltraworkVerificationAgent(normalizedSubagentType)
-        && loopState?.active === true
-        && loopState.ultrawork === true
-        && loopState.verification_pending === true
-        && loopState.session_id === input.sessionID
-
-      if (shouldInjectCriticVerification) {
-        const verificationAttemptId = randomUUID()
-        log("[tool-execute-before] Injecting ULW critic verification attempt", {
-          sessionID: input.sessionID,
-          callID: input.callID,
-          verificationAttemptId,
-          loopSessionID: loopState.session_id,
-        })
-        writeState(ctx.directory, {
-          ...loopState,
-          verification_attempt_id: verificationAttemptId,
-          verification_session_id: undefined,
-        })
-        argsObject.run_in_background = false
-        argsObject.prompt = buildUltraworkCriticVerificationPrompt(
-          prompt,
-          loopState.prompt,
-          verificationAttemptId,
-        )
-      }
-    }
-
-    if (hooks.ralphLoop && input.tool === "skill") {
-      const rawName = typeof output.args.name === "string" ? output.args.name : undefined
-      const command = rawName?.replace(/^\//, "").toLowerCase()
-      const sessionID = input.sessionID || getMainSessionID()
-
-      if (command === "ralph-loop" && sessionID) {
-        const rawArgs = getLoopCommandArguments(output.args, "ralph-loop")
-        const parsedArguments = parseRalphLoopArguments(rawArgs)
-
-        hooks.ralphLoop.startLoop(sessionID, parsedArguments.prompt, {
-          maxIterations: parsedArguments.maxIterations,
-          completionPromise: parsedArguments.completionPromise,
-          strategy: parsedArguments.strategy,
-        })
-      } else if (command === "cancel-ralph" && sessionID) {
-        hooks.ralphLoop.cancelLoop(sessionID)
-      } else if (command === "ulw-loop" && sessionID) {
-        const rawArgs = getLoopCommandArguments(output.args, "ulw-loop")
-        const parsedArguments = parseRalphLoopArguments(rawArgs)
-
-        hooks.ralphLoop.startLoop(sessionID, parsedArguments.prompt, {
-          ultrawork: true,
-          maxIterations: parsedArguments.maxIterations,
-          completionPromise: parsedArguments.completionPromise,
-          strategy: parsedArguments.strategy,
-        })
-      }
-    }
-
-    if (input.tool === "skill") {
-      const rawName = typeof output.args.name === "string" ? output.args.name : undefined
-      const command = rawName?.replace(/^\//, "").toLowerCase()
-      const sessionID = input.sessionID || getMainSessionID()
-
-      if (command === "stop-continuation" && sessionID) {
-        hooks.stopContinuationGuard?.stop(sessionID)
-        hooks.todoContinuationEnforcer?.cancelAllCountdowns()
-        hooks.ralphLoop?.cancelLoop(sessionID)
-        clearBoulderState(ctx.directory)
-        log("[stop-continuation] All continuation mechanisms stopped", {
-          sessionID,
-        })
-      }
-
-      // Clear stop state when user explicitly resumes work via work-starting commands.
-      // This ensures /stop-continuation persists until the user intentionally restarts.
-      const workStartingCommands = ["start-work", "ralph-loop", "ulw-loop"]
-      if (workStartingCommands.includes(command ?? "") && sessionID) {
-        if (hooks.stopContinuationGuard?.isStopped(sessionID)) {
-          hooks.stopContinuationGuard.clear(sessionID)
-          log("[stop-continuation] Stop state cleared by work-starting command", {
-            sessionID,
-            command,
-          })
-        }
-      }
-    }
-  }
-}

package/src/plugin/tool-registry.ts

@@ -1,286 +0,0 @@
-import type { ToolDefinition } from "@opencode-ai/plugin"
-import type { SkillLoadOptions } from "../tools/skill/types"
-
-import type {
-  AvailableCategory,
-} from "../agents/dynamic-agent-prompt-builder"
-import type { HiaiOpenCodeConfig } from "../config"
-import type { McpServerConfig } from "../config/types"
-import { isInteractiveBashEnabled } from "../create-runtime-tmux-config"
-import type { PluginContext, ToolsRecord } from "./types"
-
-import {
-  builtinTools,
-  createBackgroundTools,
-  createCallOmoAgent,
-  createLookAt,
-  createSkillMcpTool,
-  createSkillTool,
-  createGrepTools,
-  createGlobTools,
-  createAstGrepTools,
-  createSessionManagerTools,
-  createDelegateTask,
-  discoverCommandsSync,
-  interactive_bash,
-  createTaskCreateTool,
-  createTaskGetTool,
-  createTaskList,
-  createTaskUpdateTool,
-  createHashlineEditTool,
-} from "../tools"
-import { getMainSessionID } from "../features/claude-code-session-state"
-import { filterDisabledTools } from "../shared/disabled-tools"
-import { isTaskSystemEnabled, log } from "../shared"
-
-import type { Managers } from "../create-managers"
-import type { SkillContext } from "./skill-context"
-import { normalizeToolArgSchemas } from "./normalize-tool-arg-schemas"
-
-type ToolRegistryFactories = {
-  builtinTools: typeof builtinTools
-  createBackgroundTools: typeof createBackgroundTools
-  createCallOmoAgent: typeof createCallOmoAgent
-  createLookAt: typeof createLookAt
-  createSkillMcpTool: typeof createSkillMcpTool
-  createSkillTool: typeof createSkillTool
-  createGrepTools: typeof createGrepTools
-  createGlobTools: typeof createGlobTools
-  createAstGrepTools: typeof createAstGrepTools
-  createSessionManagerTools: typeof createSessionManagerTools
-  createDelegateTask: typeof createDelegateTask
-  discoverCommandsSync: typeof discoverCommandsSync
-  interactive_bash: typeof interactive_bash
-  createTaskCreateTool: typeof createTaskCreateTool
-  createTaskGetTool: typeof createTaskGetTool
-  createTaskList: typeof createTaskList
-  createTaskUpdateTool: typeof createTaskUpdateTool
-  createHashlineEditTool: typeof createHashlineEditTool
-}
-
-const defaultToolRegistryFactories: ToolRegistryFactories = {
-  builtinTools,
-  createBackgroundTools,
-  createCallOmoAgent,
-  createLookAt,
-  createSkillMcpTool,
-  createSkillTool,
-  createGrepTools,
-  createGlobTools,
-  createAstGrepTools,
-  createSessionManagerTools,
-  createDelegateTask,
-  discoverCommandsSync,
-  interactive_bash,
-  createTaskCreateTool,
-  createTaskGetTool,
-  createTaskList,
-  createTaskUpdateTool,
-  createHashlineEditTool,
-}
-
-export type ToolRegistryResult = {
-  filteredTools: ToolsRecord
-  taskSystemEnabled: boolean
-}
-
-const LOW_PRIORITY_TOOL_ORDER = [
-  "session_list",
-  "session_read",
-  "session_search",
-  "session_info",
-  "interactive_bash",
-  "look_at",
-  "call_omo_agent",
-  "task_create",
-  "task_get",
-  "task_list",
-  "task_update",
-  "background_output",
-  "background_cancel",
-  "edit",
-  "ast_grep_replace",
-  "ast_grep_search",
-  "glob",
-  "grep",
-  "skill_mcp",
-  "skill",
-  "task",
-  "lsp_rename",
-  "lsp_prepare_rename",
-  "lsp_find_references",
-  "lsp_goto_definition",
-  "lsp_symbols",
-  "lsp_diagnostics",
-] as const
-
-export function trimToolsToCap(filteredTools: ToolsRecord, maxTools: number): void {
-  const toolNames = Object.keys(filteredTools)
-  if (toolNames.length <= maxTools) return
-
-  const removableToolNames = [
-    ...LOW_PRIORITY_TOOL_ORDER.filter((toolName) => toolNames.includes(toolName)),
-    ...toolNames
-      .filter((toolName) => !LOW_PRIORITY_TOOL_ORDER.includes(toolName as (typeof LOW_PRIORITY_TOOL_ORDER)[number]))
-      .sort(),
-  ]
-
-  let currentCount = toolNames.length
-  let removed = 0
-
-  for (const toolName of removableToolNames) {
-    if (currentCount <= maxTools) break
-    if (!filteredTools[toolName]) continue
-    delete filteredTools[toolName]
-    currentCount -= 1
-    removed += 1
-  }
-
-  log(
-    `[tool-registry] Trimmed ${removed} tools to satisfy max_tools=${maxTools}. Final plugin tool count=${currentCount}.`,
-  )
-}
-
-export function createToolRegistry(args: {
-  ctx: PluginContext
-  pluginConfig: HiaiOpenCodeConfig
-  managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager">
-  skillContext: SkillContext
-  availableCategories: AvailableCategory[]
-  builtinMcp?: Record<string, McpServerConfig>
-  interactiveBashEnabled?: boolean
-  toolFactories?: Partial<ToolRegistryFactories>
-}): ToolRegistryResult {
-  const {
-    ctx,
-    pluginConfig,
-    managers,
-    skillContext,
-    availableCategories,
-    builtinMcp,
-    interactiveBashEnabled = isInteractiveBashEnabled(),
-    toolFactories,
-  } = args
-  const factories: ToolRegistryFactories = {
-    ...defaultToolRegistryFactories,
-    ...toolFactories,
-  }
-  const backgroundTools = factories.createBackgroundTools(managers.backgroundManager, ctx.client)
-  const callOmoAgent = factories.createCallOmoAgent(
-    ctx,
-    managers.backgroundManager,
-    pluginConfig.disabled_agents ?? [],
-    pluginConfig.agents,
-    pluginConfig.categories,
-  )
-
-  const isMultimodalLookerEnabled = !(pluginConfig.disabled_agents ?? []).some(
-    (agent) => agent.toLowerCase() === "ui",
-  )
-  const lookAt = isMultimodalLookerEnabled ? factories.createLookAt(ctx) : null
-
-  const delegateTask = factories.createDelegateTask({
-    manager: managers.backgroundManager,
-    client: ctx.client,
-    directory: ctx.directory,
-    userCategories: pluginConfig.categories,
-    agentOverrides: pluginConfig.agents,
-    gitMasterConfig: pluginConfig.git_master,
-    bobJuniorModel: pluginConfig.agents?.["sub"]?.model,
-    browserProvider: skillContext.browserProvider,
-    disabledSkills: skillContext.disabledSkills,
-    availableCategories,
-    availableSkills: skillContext.availableSkills,
-    bobAgentConfig: pluginConfig.bob_agent,
-    syncPollTimeoutMs: pluginConfig.background_task?.syncPollTimeoutMs,
-    onSyncSessionCreated: async (event) => {
-      log("[index] onSyncSessionCreated callback", {
-        sessionID: event.sessionID,
-        parentID: event.parentID,
-        title: event.title,
-      })
-      await managers.tmuxSessionManager.onSessionCreated({
-        type: "session.created",
-        properties: {
-          info: {
-            id: event.sessionID,
-            parentID: event.parentID,
-            title: event.title,
-          },
-        },
-      })
-
-    },
-  })
-
-  const getSessionIDForMcp = (): string | undefined => getMainSessionID()
-
-  const skillMcpTool = factories.createSkillMcpTool({
-    manager: managers.skillMcpManager,
-    getLoadedSkills: () => skillContext.mergedSkills,
-    getSessionID: getSessionIDForMcp,
-    builtinMcp,
-  })
-
-  const commands = factories.discoverCommandsSync(ctx.directory, {
-    pluginsEnabled: pluginConfig.claude_code?.plugins ?? true,
-    enabledPluginsOverride: pluginConfig.claude_code?.plugins_override,
-  })
-  const skillTool = factories.createSkillTool({
-    commands,
-    skills: skillContext.mergedSkills,
-    mcpManager: managers.skillMcpManager,
-    getSessionID: getSessionIDForMcp,
-    gitMasterConfig: pluginConfig.git_master,
-    browserProvider: skillContext.browserProvider,
-    nativeSkills: "skills" in ctx ? (ctx as { skills: SkillLoadOptions["nativeSkills"] }).skills : undefined,
-  })
-
-  const taskSystemEnabled = isTaskSystemEnabled(pluginConfig)
-  const taskToolsRecord: Record<string, ToolDefinition> = taskSystemEnabled
-    ? {
-        task_create: factories.createTaskCreateTool(pluginConfig, ctx),
-        task_get: factories.createTaskGetTool(pluginConfig),
-        task_list: factories.createTaskList(pluginConfig),
-        task_update: factories.createTaskUpdateTool(pluginConfig, ctx),
-      }
-    : {}
-
-  const hashlineEnabled = pluginConfig.hashline_edit ?? false
-  const hashlineToolsRecord: Record<string, ToolDefinition> = hashlineEnabled
-    ? { edit: factories.createHashlineEditTool(ctx) }
-    : {}
-
-  const allTools: Record<string, ToolDefinition> = {
-    ...factories.builtinTools,
-    ...factories.createGrepTools(ctx),
-    ...factories.createGlobTools(ctx),
-    ...factories.createAstGrepTools(ctx),
-    ...factories.createSessionManagerTools(ctx),
-    ...backgroundTools,
-    call_omo_agent: callOmoAgent,
-    ...(lookAt ? { look_at: lookAt } : {}),
-    task: delegateTask,
-    skill_mcp: skillMcpTool,
-    skill: skillTool,
-    ...(interactiveBashEnabled ? { interactive_bash: factories.interactive_bash } : {}),
-    ...taskToolsRecord,
-    ...hashlineToolsRecord,
-  }
-
-  for (const toolDefinition of Object.values(allTools)) {
-    normalizeToolArgSchemas(toolDefinition)
-  }
-
-  const filteredTools: ToolsRecord = filterDisabledTools(allTools, pluginConfig.disabled_tools)
-
-  const maxTools = pluginConfig.experimental?.max_tools
-  if (maxTools) {
-    trimToolsToCap(filteredTools, maxTools)
-  }
-
-  return {
-    filteredTools,
-    taskSystemEnabled,
-  }
-}

package/src/plugin/types.ts

@@ -1,26 +0,0 @@
-import type { Plugin, ToolDefinition } from "@opencode-ai/plugin"
-
-export type PluginContext = Parameters<Plugin>[0]
-export type PluginInstance = Awaited<ReturnType<Plugin>>
-
-type ChatHeadersHook = PluginInstance extends { "chat.headers"?: infer T }
-  ? T
-  : (input: unknown, output: unknown) => Promise<void>
-
-export type PluginInterface = Omit<
-  PluginInstance,
-  "experimental.session.compacting" | "chat.headers"
-> & {
-  "chat.headers"?: ChatHeadersHook
-}
-
-export type ToolsRecord = Record<string, ToolDefinition>
-
-export type TmuxConfig = {
-  enabled: boolean
-  layout: "main-horizontal" | "main-vertical" | "tiled" | "even-horizontal" | "even-vertical"
-  main_pane_size: number
-  main_pane_min_width: number
-  agent_pane_min_width: number
-  isolation: "inline" | "window" | "session"
-}

package/src/plugin/ultrawork-db-model-override.ts

@@ -1,142 +0,0 @@
-import { Database } from "bun:sqlite"
-import { join } from "node:path"
-import { existsSync } from "node:fs"
-import { getDataDir } from "../shared/data-path"
-import { log } from "../shared"
-
-function getDbPath(): string {
-  return join(getDataDir(), "opencode", "opencode.db")
-}
-
-const MAX_MICROTASK_RETRIES = 10
-
-function tryUpdateMessageModel(
-  db: InstanceType<typeof Database>,
-  messageId: string,
-  targetModel: { providerID: string; modelID: string },
-  variant?: string,
-): boolean {
-  const stmt = db.prepare(
-    `UPDATE message SET data = json_set(data, '$.model.providerID', ?, '$.model.modelID', ?) WHERE id = ?`,
-  )
-  const result = stmt.run(targetModel.providerID, targetModel.modelID, messageId)
-  if (result.changes === 0) return false
-  if (variant) {
-    db.prepare(
-      `UPDATE message SET data = json_set(data, '$.variant', ?, '$.thinking', ?) WHERE id = ?`,
-    ).run(variant, variant, messageId)
-  }
-  return true
-}
-
-function retryViaMicrotask(
-  db: InstanceType<typeof Database>,
-  messageId: string,
-  targetModel: { providerID: string; modelID: string },
-  variant: string | undefined,
-  attempt: number,
-): void {
-  if (attempt >= MAX_MICROTASK_RETRIES) {
-    log("[ultrawork-db-override] Exhausted microtask retries, falling back to setTimeout", {
-      messageId,
-      attempt,
-    })
-    setTimeout(() => {
-      try {
-        if (tryUpdateMessageModel(db, messageId, targetModel, variant)) {
-          log(`[ultrawork-db-override] setTimeout fallback succeeded: ${targetModel.providerID}/${targetModel.modelID}`, { messageId })
-        } else {
-          log("[ultrawork-db-override] setTimeout fallback failed - message not found", { messageId })
-        }
-      } catch (error) {
-        log("[ultrawork-db-override] setTimeout fallback failed with error", {
-          messageId,
-          error: String(error),
-        })
-      } finally {
-        try {
-          db.close()
-        } catch (error) {
-          log("[ultrawork-db-override] Failed to close DB after setTimeout fallback", {
-            messageId,
-            error: String(error),
-          })
-        }
-      }
-    }, 0)
-    return
-  }
-
-  queueMicrotask(() => {
-    let shouldCloseDb = true
-
-    try {
-      if (tryUpdateMessageModel(db, messageId, targetModel, variant)) {
-        log(`[ultrawork-db-override] Deferred DB update (attempt ${attempt}): ${targetModel.providerID}/${targetModel.modelID}`, { messageId })
-        return
-      }
-
-      shouldCloseDb = false
-      retryViaMicrotask(db, messageId, targetModel, variant, attempt + 1)
-    } catch (error) {
-      log("[ultrawork-db-override] Deferred DB update failed with error", {
-        messageId,
-        attempt,
-        error: String(error),
-      })
-    } finally {
-      if (shouldCloseDb) {
-        try {
-          db.close()
-        } catch (error) {
-          log("[ultrawork-db-override] Failed to close DB after deferred DB update", {
-            messageId,
-            attempt,
-            error: String(error),
-          })
-        }
-      }
-    }
-  })
-}
-
-/**
- * Schedules a deferred SQLite update to change the message model in the DB
- * WITHOUT triggering a Bus event. Uses microtask retry loop to wait for
- * Session.updateMessage() to save the message first, then overwrites the model.
- *
- * Falls back to setTimeout(fn, 0) after 10 microtask attempts.
- */
-export function scheduleDeferredModelOverride(
-  messageId: string,
-  targetModel: { providerID: string; modelID: string },
-  variant?: string,
-): void {
-  queueMicrotask(() => {
-    const dbPath = getDbPath()
-    if (!existsSync(dbPath)) {
-      log("[ultrawork-db-override] DB not found, skipping deferred override")
-      return
-    }
-
-    let db: InstanceType<typeof Database>
-    try {
-      db = new Database(dbPath)
-    } catch (error) {
-      log("[ultrawork-db-override] Failed to open DB, skipping deferred override", {
-        messageId,
-        error: String(error),
-      })
-      return
-    }
-
-    try {
-      retryViaMicrotask(db, messageId, targetModel, variant, 0)
-    } catch (error) {
-      log("[ultrawork-db-override] Failed to apply deferred model override", {
-        error: String(error),
-      })
-      db.close()
-    }
-  })
-}