@mtayfur/opencode-prompt-enhancer 1.0.1

package/plugins/prompt-enhancer.tsx

@@ -0,0 +1,990 @@
+/** @jsxImportSource @opentui/solid */
+import type { PluginOptions } from "@opencode-ai/plugin"
+import type { Message, Part, TextPart } from "@opencode-ai/sdk/v2"
+import type {
+  TuiPlugin,
+  TuiPluginModule,
+  TuiPromptInfo,
+  TuiPromptRef,
+  TuiRouteCurrent,
+  TuiSlotPlugin,
+} from "@opencode-ai/plugin/tui"
+import { useTerminalDimensions } from "@opentui/solid"
+import { Show, createMemo, createSignal } from "solid-js"
+import { ENHANCER_SYSTEM_PROMPT } from "./enhancer-system-prompt"
+
+const MAX_RECENT_MESSAGES = 3
+const MAX_CHANGED_FILES = 25
+const MAX_CONTEXT_ITEM_PREVIEW_LENGTH = 250
+const CONTEXT_TRUNCATION_MARKER = "\n[... truncated ...]\n"
+const ENHANCEMENT_TIMEOUT_MS = 60_000
+const ENHANCEMENT_ANIMATION_INTERVAL_MS = 250
+const TOAST_DURATION_MS = 3_000
+const ENHANCEMENT_CANCELED_MESSAGE = "Prompt enhancement canceled."
+const ENHANCEMENT_ANIMATION_FRAMES = [
+  "Enhancing prompt",
+  "Enhancing prompt.",
+  "Enhancing prompt..",
+  "Enhancing prompt...",
+] as const
+const DIALOG_TITLE = "Enhance Prompt"
+const DIALOG_WIDTH_RATIO = 0.60
+const DIALOG_MAX_WIDTH = 120
+const DIALOG_MIN_WIDTH = 40
+const DIALOG_SCREEN_MARGIN_X = 4
+const DIALOG_SCREEN_MARGIN_Y = 4
+const DIALOG_HEIGHT = 24
+const DIALOG_PADDING_X = 2
+const DIALOG_PADDING_Y = 1
+const DIALOG_TEXTAREA_RESERVED_HEIGHT = 7
+const DIALOG_TEXTAREA_VERTICAL_PADDING = 2
+const DIALOG_BACKDROP_COLOR = "#000000"
+const DIALOG_BACKDROP_OPACITY = 0.65
+const DIALOG_PLACEHOLDER = "Describe the task..."
+const DIALOG_HINT = "Enter to enhance • Shift+Enter for newline • Esc to cancel"
+const TOAST_TITLE = "Prompt enhancer"
+
+type ModelRef = {
+  providerID: string
+  modelID: string
+}
+
+type Api = Parameters<TuiPlugin>[0]
+type ActiveEnhancement = {
+  controller: AbortController
+  stopAnimation: () => void
+  clearPromise?: Promise<boolean>
+  handle: PromptHandle
+  originalPrompt?: TuiPromptInfo
+  input: string
+  canceled?: boolean
+}
+
+type PluginState = {
+  activeEnhancement?: ActiveEnhancement
+  promptRef?: TuiPromptRef
+  promptTarget?: PromptTarget
+  lastEnhancement?: {
+    original: TuiPromptInfo
+    enhancedInput: string
+    target: PromptTarget
+    directory: string
+  }
+}
+
+type PromptTarget =
+  | { name: "home" }
+  | { name: "session", sessionID: string }
+
+type PromptHandle = {
+  target: PromptTarget
+  directory: string
+  ref?: TuiPromptRef
+}
+
+type PromptUpdate = {
+  fallbackInput: string
+  createPromptInfo: (current: TuiPromptInfo) => TuiPromptInfo
+  refAction: "focus" | "blur"
+}
+
+type DialogTextareaRef = {
+  plainText: string
+  cursorOffset: number
+  focus(): void
+}
+
+type EnhanceDialogState = {
+  initialValue: string
+  onCancel: () => void
+  onConfirm: (value: string) => void
+}
+
+type SetEnhanceDialog = (dialog: EnhanceDialogState | undefined) => void
+
+type EnhancementInput = {
+  command?: string
+  draft: string
+}
+
+function parseEnhancementInput(input: string): EnhancementInput {
+  const match = input.match(/^(\/[A-Za-z0-9][A-Za-z0-9._:-]*(?:\/[A-Za-z0-9][A-Za-z0-9._:-]*)*)(?:(?: +|\n)([\s\S]*))?$/)
+  if (!match) return { draft: input }
+
+  return {
+    command: match[1],
+    draft: match[2] ?? "",
+  }
+}
+
+function formatEnhancedInput(input: EnhancementInput, enhancedDraft: string): string {
+  if (!input.command) return enhancedDraft
+
+  const nested = parseEnhancementInput(enhancedDraft)
+  const draft = nested.command === input.command ? nested.draft : enhancedDraft
+  return draft ? `${input.command} ${draft}` : input.command
+}
+
+function parseModelString(value: string | undefined): ModelRef | undefined {
+  if (!value) return undefined
+  const trimmed = value.trim()
+  const slash = trimmed.indexOf("/")
+  if (slash <= 0 || slash === trimmed.length - 1) return undefined
+  return {
+    providerID: trimmed.slice(0, slash),
+    modelID: trimmed.slice(slash + 1),
+  }
+}
+
+function isSessionRoute(route: TuiRouteCurrent): route is Extract<TuiRouteCurrent, { name: "session" }> {
+  return route.name === "session"
+}
+
+function extractVisibleText(parts: ReadonlyArray<Part>): string {
+  return parts
+    .filter((part): part is TextPart => part.type === "text" && !part.ignored)
+    .map((part) => part.text)
+    .join("")
+}
+
+function formatContextPreview(text: string): string {
+  if (text.length <= MAX_CONTEXT_ITEM_PREVIEW_LENGTH) return text
+
+  const available = MAX_CONTEXT_ITEM_PREVIEW_LENGTH - CONTEXT_TRUNCATION_MARKER.length
+  const headLength = Math.ceil(available / 2)
+  const tailLength = available - headLength
+  return `${text.slice(0, headLength)}${CONTEXT_TRUNCATION_MARKER}${text.slice(-tailLength)}`
+}
+
+function indentContextContinuation(text: string, indentation: string): string {
+  return text.replaceAll("\n", `\n${indentation}`)
+}
+
+function resolveEnhancerModel(api: Api, options: PluginOptions | undefined): ModelRef | undefined {
+  const modelOverride = typeof options?.model === "string" ? options.model : undefined
+  if (modelOverride?.trim()) {
+    const override = parseModelString(modelOverride)
+    if (override) return override
+
+    api.ui.toast({
+      variant: "warning",
+      title: TOAST_TITLE,
+      message: `Invalid model override ${JSON.stringify(modelOverride)}; expected "provider/model". Using default model.`,
+    })
+  }
+
+  return parseModelString(api.state.config.small_model || api.state.config.model)
+}
+
+function clonePromptInfo(prompt: TuiPromptInfo): TuiPromptInfo {
+  return {
+    input: prompt.input,
+    mode: prompt.mode,
+    parts: prompt.parts.map((part) => ({ ...part })),
+  }
+}
+
+function nextPromptInfo(prompt: TuiPromptInfo, input: string): TuiPromptInfo {
+  return {
+    input,
+    mode: prompt.mode,
+    parts: prompt.parts.filter((part) => part.type !== "text").map((part) => ({ ...part })),
+  }
+}
+
+function samePromptInfo(left: TuiPromptInfo, right: TuiPromptInfo): boolean {
+  return left.input === right.input && left.mode === right.mode && JSON.stringify(left.parts) === JSON.stringify(right.parts)
+}
+
+function errorFromReason(reason: unknown, fallbackMessage: string): Error {
+  return reason instanceof Error ? reason : new Error(fallbackMessage)
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max)
+}
+
+async function withRequestTimeout<T>(
+  signal: AbortSignal,
+  timeoutMs: number,
+  run: (signal: AbortSignal) => Promise<T>,
+): Promise<T> {
+  const controller = new AbortController()
+  const timeoutMessage = `Prompt enhancement timed out after ${Math.floor(timeoutMs / 1000)} seconds.`
+  const onAbort = () => controller.abort(signal.reason)
+  const timeout = setTimeout(() => controller.abort(new Error(timeoutMessage)), timeoutMs)
+
+  if (signal.aborted) {
+    controller.abort(signal.reason)
+  } else {
+    signal.addEventListener("abort", onAbort, { once: true })
+  }
+
+  try {
+    return await run(controller.signal)
+  } catch (error) {
+    if (controller.signal.aborted && !signal.aborted) {
+      throw errorFromReason(controller.signal.reason, timeoutMessage)
+    }
+    throw error
+  } finally {
+    clearTimeout(timeout)
+    signal.removeEventListener("abort", onAbort)
+  }
+}
+
+function samePromptTarget(left: PromptTarget | undefined, right: PromptTarget | undefined): boolean {
+  if (!left || !right || left.name !== right.name) return false
+  if (left.name === "session" && right.name === "session") {
+    return left.sessionID === right.sessionID
+  }
+  return true
+}
+
+function isPromptHandleActive(api: Api, state: PluginState, handle: PromptHandle): boolean {
+  const route = api.route.current
+  const target = handle.target
+  if (target.name === "home") {
+    if (route.name !== "home") return false
+  } else if (!isSessionRoute(route) || route.params.sessionID !== target.sessionID) {
+    return false
+  }
+  if (api.state.path.directory !== handle.directory) return false
+
+  if (handle.ref) {
+    return state.promptRef === handle.ref && samePromptTarget(state.promptTarget, handle.target)
+  }
+
+  return true
+}
+
+function bindPromptRef(
+  state: PluginState,
+  target: PromptTarget,
+  forwarded: ((ref: TuiPromptRef | undefined) => void) | undefined,
+  ref: TuiPromptRef | undefined,
+): void {
+  if (ref) {
+    state.promptRef = ref
+    state.promptTarget = target
+  } else if (samePromptTarget(state.promptTarget, target)) {
+    state.promptRef = undefined
+    state.promptTarget = undefined
+  }
+
+  forwarded?.(ref)
+}
+
+async function applyPromptUpdate(
+  api: Api,
+  state: PluginState,
+  handle: PromptHandle,
+  update: PromptUpdate,
+  signal: AbortSignal,
+): Promise<boolean> {
+  if (!isPromptHandleActive(api, state, handle)) return false
+
+  const promptRef = handle.ref
+  if (promptRef) {
+    promptRef.set(update.createPromptInfo(promptRef.current))
+    if (update.refAction === "focus") promptRef.focus()
+    else promptRef.blur()
+    return true
+  }
+
+  const requestOptions = { signal, throwOnError: true } as const
+  await api.client.tui.clearPrompt({ directory: handle.directory }, requestOptions)
+  if (update.fallbackInput) {
+    await api.client.tui.appendPrompt({ directory: handle.directory, text: update.fallbackInput }, requestOptions)
+  }
+  return true
+}
+
+function clearPrompt(api: Api, state: PluginState, handle: PromptHandle, signal: AbortSignal, template?: TuiPromptInfo): Promise<boolean> {
+  return applyPromptUpdate(api, state, handle, {
+    fallbackInput: "",
+    createPromptInfo: (current) => nextPromptInfo(template ?? current, ""),
+    refAction: "blur",
+  }, signal)
+}
+
+function writePrompt(
+  api: Api,
+  state: PluginState,
+  handle: PromptHandle,
+  input: string,
+  signal: AbortSignal,
+  template?: TuiPromptInfo,
+): Promise<boolean> {
+  return applyPromptUpdate(api, state, handle, {
+    fallbackInput: input,
+    createPromptInfo: (current) => nextPromptInfo(template ?? current, input),
+    refAction: "focus",
+  }, signal)
+}
+
+function restorePrompt(
+  api: Api,
+  state: PluginState,
+  handle: PromptHandle,
+  prompt: TuiPromptInfo,
+  signal: AbortSignal,
+): Promise<boolean> {
+  return applyPromptUpdate(api, state, handle, {
+    fallbackInput: prompt.input,
+    createPromptInfo: () => clonePromptInfo(prompt),
+    refAction: "focus",
+  }, signal)
+}
+
+function restoreEnhancementPrompt(
+  api: Api,
+  state: PluginState,
+  enhancement: ActiveEnhancement,
+  signal: AbortSignal,
+): Promise<boolean> {
+  return enhancement.originalPrompt
+    ? restorePrompt(api, state, enhancement.handle, enhancement.originalPrompt, signal)
+    : writePrompt(api, state, enhancement.handle, enhancement.input, signal)
+}
+
+async function cancelActiveEnhancement(
+  api: Api,
+  state: PluginState,
+  signal: AbortSignal,
+): Promise<boolean> {
+  const active = state.activeEnhancement
+  if (!active) return false
+
+  active.canceled = true
+  active.stopAnimation()
+  active.controller.abort(new Error(ENHANCEMENT_CANCELED_MESSAGE))
+
+  if (active.clearPromise) {
+    await active.clearPromise.catch(() => false)
+  }
+
+  return restoreEnhancementPrompt(api, state, active, signal)
+}
+
+function startEnhancementAnimation(
+  api: Api,
+  state: PluginState,
+  handle: PromptHandle,
+  template?: TuiPromptInfo,
+): () => void {
+  const promptRef = handle.ref
+  if (!promptRef) return () => {}
+
+  let frame = 0
+  let stopped = false
+
+  const render = () => {
+    if (stopped) return
+    if (!isPromptHandleActive(api, state, handle)) {
+      stopped = true
+      return
+    }
+
+    promptRef.set(nextPromptInfo(template ?? promptRef.current, ENHANCEMENT_ANIMATION_FRAMES[frame]))
+    frame = (frame + 1) % ENHANCEMENT_ANIMATION_FRAMES.length
+  }
+
+  render()
+  const interval = setInterval(render, ENHANCEMENT_ANIMATION_INTERVAL_MS)
+  return () => {
+    stopped = true
+    clearInterval(interval)
+  }
+}
+
+function gatherContext(api: Api): string {
+  const sections: string[] = []
+
+  const route = api.route.current
+  if (isSessionRoute(route)) {
+    const sessionID = route.params.sessionID
+    const messages = api.state.session.messages(sessionID)
+
+    const userMessages = messages.filter((message): message is Extract<Message, { role: "user" }> => message.role === "user")
+    const recent = userMessages.slice(-MAX_RECENT_MESSAGES).reverse()
+    if (recent.length > 0) {
+      const prompts: string[] = []
+      for (const msg of recent) {
+        const text = extractVisibleText(api.state.part(msg.id)).trim()
+        if (text) {
+          prompts.push(formatContextPreview(text))
+        }
+      }
+      if (prompts.length > 0) {
+        const formatted = prompts.map((prompt, index) => `${index + 1}. ${indentContextContinuation(prompt, "   ")}`).join("\n")
+        sections.push(`Recent user prompts in this session (newest first; use only same-task items):\n${formatted}`)
+      }
+    }
+
+    const diff = api.state.session.diff(sessionID)
+    if (diff.length > 0) {
+      const visibleFiles = diff.slice(0, MAX_CHANGED_FILES)
+      const count = diff.length > visibleFiles.length ? `; showing ${visibleFiles.length} of ${diff.length}` : ""
+      const files = visibleFiles.map((file) => `  @${file.file}`)
+      sections.push(`Files changed in session (candidates only; not proof of task intent${count}):\n${files.join("\n")}`)
+    }
+  }
+
+  const metadata = [`Working directory: ${api.state.path.directory}`]
+  const branch = api.state.vcs?.branch
+  if (branch) {
+    metadata.push(`Current branch: ${branch}`)
+  }
+  sections.push(`Workspace metadata (weak signal only):\n${metadata.join("\n")}`)
+
+  return sections.join("\n\n")
+}
+
+async function enhanceWithModel(
+  api: Api,
+  options: PluginOptions | undefined,
+  input: string,
+  signal: AbortSignal,
+): Promise<string> {
+  const directory = api.state.path.directory
+  const model = resolveEnhancerModel(api, options)
+  const context = gatherContext(api)
+  const userMessage = [
+    `<CONTEXT>\n${context}\n</CONTEXT>`,
+    `<DRAFT>\n${input}\n</DRAFT>`,
+  ].join("\n\n")
+
+  const created = await api.client.session.create(
+    {
+      directory,
+      title: `Prompt Enhancer ${Math.random().toString(36).slice(2, 8)}`,
+      permission: [{ permission: "*", action: "deny", pattern: "*" }],
+    },
+    { signal, throwOnError: true },
+  )
+
+  const tempSessionID = created.data?.id
+  if (!tempSessionID) throw new Error("Failed to start prompt enhancer.")
+
+  try {
+    const response = await withRequestTimeout(
+      signal,
+      ENHANCEMENT_TIMEOUT_MS,
+      (requestSignal) => api.client.session.prompt(
+        {
+          sessionID: tempSessionID,
+          directory,
+          model,
+          system: ENHANCER_SYSTEM_PROMPT,
+          parts: [
+            {
+              type: "text",
+              text: userMessage,
+            },
+          ],
+        },
+        { signal: requestSignal, throwOnError: true },
+      ),
+    )
+
+    const parts = response.data?.parts
+    if (!parts) throw new Error("Enhancer returned no response.")
+
+    const enhanced = extractVisibleText(parts)
+    if (!enhanced.trim()) throw new Error("Enhancer returned no text.")
+    return enhanced
+  } finally {
+    try {
+      await api.client.session.abort({ sessionID: tempSessionID, directory })
+    } catch {
+      // WHY: Cleanup continues with deletion when the helper has already stopped.
+    }
+    try {
+      await api.client.session.delete({ sessionID: tempSessionID, directory })
+    } catch {
+      // WHY: Helper cleanup must not replace a successful enhancement result.
+    }
+  }
+}
+
+function renderEnhanceDialog(api: Api, dialog: EnhanceDialogState) {
+  const theme = api.theme.current
+  const terminal = useTerminalDimensions()
+  const screenWidth = createMemo(() => Math.max(1, terminal().width))
+  const screenHeight = createMemo(() => Math.max(1, terminal().height))
+  const panelWidth = createMemo(() => {
+    const width = screenWidth()
+    const availableWidth = Math.max(1, width - DIALOG_SCREEN_MARGIN_X)
+    const minWidth = Math.min(DIALOG_MIN_WIDTH, availableWidth)
+    const maxWidth = Math.min(DIALOG_MAX_WIDTH, availableWidth)
+    return clamp(Math.floor(width * DIALOG_WIDTH_RATIO), minWidth, maxWidth)
+  })
+  const panelHeight = createMemo(() => {
+    const availableHeight = Math.max(1, screenHeight() - DIALOG_SCREEN_MARGIN_Y)
+    return Math.min(DIALOG_HEIGHT, availableHeight)
+  })
+  const textareaBoxHeight = createMemo(() => Math.max(1, panelHeight() - DIALOG_TEXTAREA_RESERVED_HEIGHT))
+  const textareaHeight = createMemo(() => Math.max(1, textareaBoxHeight() - DIALOG_TEXTAREA_VERTICAL_PADDING))
+  let dialogInput: DialogTextareaRef | undefined
+
+  return (
+    <box
+      position="absolute"
+      top={0}
+      left={0}
+      width={screenWidth()}
+      height={screenHeight()}
+      justifyContent="center"
+      alignItems="center"
+    >
+      <box
+        position="absolute"
+        top={0}
+        left={0}
+        width={screenWidth()}
+        height={screenHeight()}
+        backgroundColor={DIALOG_BACKDROP_COLOR}
+        opacity={DIALOG_BACKDROP_OPACITY}
+      />
+      <box
+        flexDirection="column"
+        width={panelWidth()}
+        height={panelHeight()}
+        gap={1}
+        paddingX={DIALOG_PADDING_X}
+        paddingY={DIALOG_PADDING_Y}
+        backgroundColor={theme.backgroundPanel}
+        border
+        borderColor={theme.border}
+      >
+        <text>{DIALOG_TITLE}</text>
+        <box
+          border
+          borderColor={theme.borderActive}
+          flexDirection="column"
+          height={textareaBoxHeight()}
+          paddingX={1}
+          paddingY={1}
+        >
+          <textarea
+            ref={(node: DialogTextareaRef | undefined) => {
+              dialogInput = node
+              if (!node) return
+              node.cursorOffset = node.plainText.length
+              queueMicrotask(() => {
+                if (dialogInput === node) node.focus()
+              })
+            }}
+            width="100%"
+            height={textareaHeight()}
+            initialValue={dialog.initialValue}
+            placeholder={DIALOG_PLACEHOLDER}
+            wrapMode="word"
+            textColor={theme.text}
+            placeholderColor={theme.textMuted}
+            backgroundColor={theme.backgroundPanel}
+            focusedBackgroundColor={theme.backgroundPanel}
+            focusedTextColor={theme.text}
+            cursorColor={theme.primary}
+            keyBindings={[
+              { name: "return", action: "submit" },
+              { name: "linefeed", action: "submit" },
+              { name: "return", shift: true, action: "newline" },
+              { name: "linefeed", shift: true, action: "newline" },
+            ]}
+            onKeyDown={(key) => {
+              if (key.name === "escape" || (key.ctrl && key.name === "c")) dialog.onCancel()
+            }}
+            onSubmit={() => dialog.onConfirm(dialogInput?.plainText ?? "")}
+          />
+        </box>
+        <text fg={theme.textMuted}>{DIALOG_HINT}</text>
+      </box>
+    </box>
+  )
+}
+
+function openEnhanceDialog(
+  api: Api,
+  options: PluginOptions | undefined,
+  state: PluginState,
+  setEnhanceDialog: SetEnhanceDialog,
+  signal: AbortSignal,
+): void {
+  if (state.activeEnhancement) {
+    api.ui.toast({ variant: "warning", title: TOAST_TITLE, message: "Enhancement in progress." })
+    return
+  }
+
+  if (signal.aborted) return
+
+  const target = state.promptTarget ?? (api.route.current.name === "home"
+    ? { name: "home" as const }
+    : isSessionRoute(api.route.current)
+      ? { name: "session" as const, sessionID: api.route.current.params.sessionID }
+      : undefined)
+  if (!target) {
+    api.ui.toast({ variant: "warning", title: TOAST_TITLE, message: "Enhancement only works from a prompt." })
+    return
+  }
+
+  const handle: PromptHandle = {
+    target,
+    directory: api.state.path.directory,
+    ref: state.promptRef,
+  }
+  const originalPrompt = handle.ref ? clonePromptInfo(handle.ref.current) : undefined
+  const initialValue = originalPrompt?.input ?? ""
+
+  const closeDialog = () => setEnhanceDialog(undefined)
+
+  const confirmInput = (value: string) => {
+    if (state.activeEnhancement) return
+
+    if (!value.trim()) {
+      api.ui.toast({ variant: "warning", title: TOAST_TITLE, message: "Enter a prompt first." })
+      closeDialog()
+      return
+    }
+
+    const enhancementInput = parseEnhancementInput(value)
+    if (!enhancementInput.draft.trim()) {
+      api.ui.toast({ variant: "warning", title: TOAST_TITLE, message: "Enter instructions after the slash command." })
+      closeDialog()
+      return
+    }
+
+    const promptChanged = originalPrompt && handle.ref
+      ? !samePromptInfo(handle.ref.current, originalPrompt)
+      : false
+    if (!isPromptHandleActive(api, state, handle) || promptChanged) {
+      api.ui.toast({ variant: "warning", title: TOAST_TITLE, message: "Prompt changed while dialog was open." })
+      closeDialog()
+      return
+    }
+
+    closeDialog()
+    api.ui.toast({
+      variant: "info",
+      title: TOAST_TITLE,
+      message: "Enhancing prompt...",
+      duration: TOAST_DURATION_MS,
+    })
+
+    const enhancementController = new AbortController()
+    const onLifecycleAbort = () => enhancementController.abort(signal.reason)
+    const activeEnhancement: ActiveEnhancement = {
+      controller: enhancementController,
+      stopAnimation: () => {},
+      handle,
+      originalPrompt,
+      input: value,
+    }
+    state.activeEnhancement = activeEnhancement
+    if (signal.aborted) {
+      enhancementController.abort(signal.reason)
+    } else {
+      signal.addEventListener("abort", onLifecycleAbort, { once: true })
+    }
+
+    void (async () => {
+      try {
+        const clearPromise = clearPrompt(api, state, handle, signal, originalPrompt)
+        activeEnhancement.clearPromise = clearPromise
+        const cleared = await clearPromise
+        if (!cleared) {
+          api.ui.toast({
+            variant: "warning",
+            title: TOAST_TITLE,
+            message: "Prompt changed before enhancement started.",
+          })
+          return
+        }
+
+        activeEnhancement.stopAnimation = startEnhancementAnimation(api, state, handle, originalPrompt)
+
+        const enhancedDraft = await enhanceWithModel(api, options, enhancementInput.draft, enhancementController.signal)
+        const enhanced = formatEnhancedInput(enhancementInput, enhancedDraft)
+        if (signal.aborted) return
+        if (enhancementController.signal.aborted) {
+          throw errorFromReason(enhancementController.signal.reason, ENHANCEMENT_CANCELED_MESSAGE)
+        }
+
+        activeEnhancement.stopAnimation()
+
+        const wrote = await writePrompt(api, state, handle, enhanced, signal, originalPrompt)
+        if (!wrote) {
+          api.ui.toast({
+            variant: "warning",
+            title: TOAST_TITLE,
+            message: "Enhanced prompt is ready, but that prompt is no longer active.",
+          })
+          return
+        }
+        if (enhancementController.signal.aborted) {
+          throw errorFromReason(enhancementController.signal.reason, ENHANCEMENT_CANCELED_MESSAGE)
+        }
+
+        state.lastEnhancement = originalPrompt
+          ? {
+              original: clonePromptInfo(originalPrompt),
+              enhancedInput: enhanced,
+              target: { ...handle.target },
+              directory: handle.directory,
+            }
+          : undefined
+
+        api.ui.toast({
+          variant: "success",
+          title: "Prompt enhanced",
+          message: "Enhanced prompt added to input.",
+          duration: TOAST_DURATION_MS,
+        })
+      } catch (error) {
+        if (signal.aborted) return
+
+        activeEnhancement.stopAnimation()
+
+        const canceled = enhancementController.signal.aborted && !signal.aborted
+        if (canceled && state.activeEnhancement?.canceled) {
+          // cancelActiveEnhancement already stopped the animation and restored the prompt.
+          return
+        }
+
+        let restored: boolean
+        try {
+          restored = await restoreEnhancementPrompt(api, state, activeEnhancement, signal)
+        } catch {
+          // Best-effort restore; do not suppress the error toast.
+          restored = false
+        }
+        let baseMessage: string
+        if (canceled) {
+          baseMessage = ENHANCEMENT_CANCELED_MESSAGE
+        } else if (error instanceof Error) {
+          baseMessage = error.message
+        } else {
+          baseMessage = "Prompt enhancement failed."
+        }
+        let message: string
+        if (canceled && restored) {
+          message = "Enhancement canceled. Original prompt restored."
+        } else if (restored) {
+          message = baseMessage
+        } else {
+          message = `${baseMessage} Original prompt could not be restored because the prompt changed. Please re-enter your prompt manually.`
+        }
+        api.ui.toast({ variant: canceled && restored ? "info" : "error", title: TOAST_TITLE, message })
+      } finally {
+        activeEnhancement.stopAnimation()
+        signal.removeEventListener("abort", onLifecycleAbort)
+        if (state.activeEnhancement?.controller === enhancementController) {
+          state.activeEnhancement = undefined
+        }
+      }
+    })()
+  }
+
+  setEnhanceDialog({ initialValue, onCancel: closeDialog, onConfirm: confirmInput })
+}
+
+function revertEnhancement(
+  api: Api,
+  state: PluginState,
+  signal: AbortSignal,
+): void {
+  if (state.activeEnhancement) {
+    void (async () => {
+      try {
+        const restored = await cancelActiveEnhancement(api, state, signal)
+        if (!restored) {
+          api.ui.toast({ variant: "warning", title: TOAST_TITLE, message: "Prompt changed while canceling." })
+          return
+        }
+
+        api.ui.toast({
+          variant: "info",
+          title: TOAST_TITLE,
+          message: "Enhancement canceled. Original prompt restored.",
+          duration: TOAST_DURATION_MS,
+        })
+      } catch (error) {
+        if (signal.aborted) return
+        const message = error instanceof Error ? error.message : "Cancel failed."
+        api.ui.toast({ variant: "error", title: TOAST_TITLE, message })
+      }
+    })()
+    return
+  }
+
+  const lastEnhancement = state.lastEnhancement
+  if (!lastEnhancement) {
+    api.ui.toast({ variant: "warning", title: TOAST_TITLE, message: "No enhancement to revert." })
+    return
+  }
+
+  const target = state.promptTarget
+  if (!target) {
+    api.ui.toast({ variant: "warning", title: TOAST_TITLE, message: "Revert only works from a prompt." })
+    return
+  }
+
+  if (api.state.path.directory !== lastEnhancement.directory || !samePromptTarget(target, lastEnhancement.target)) {
+    api.ui.toast({ variant: "warning", title: TOAST_TITLE, message: "The enhanced prompt is no longer active." })
+    return
+  }
+
+  const handle: PromptHandle = {
+    target,
+    directory: api.state.path.directory,
+    ref: state.promptRef,
+  }
+
+  if (!isPromptHandleActive(api, state, handle)) {
+    api.ui.toast({ variant: "warning", title: TOAST_TITLE, message: "Prompt changed since enhancement." })
+    return
+  }
+
+  const currentPrompt = handle.ref?.current
+  const expectedEnhancedPrompt = nextPromptInfo(lastEnhancement.original, lastEnhancement.enhancedInput)
+  if (!currentPrompt || !samePromptInfo(currentPrompt, expectedEnhancedPrompt)) {
+    api.ui.toast({
+      variant: "warning",
+      title: TOAST_TITLE,
+      message: "Prompt was manually changed after enhancement. Revert skipped.",
+    })
+    return
+  }
+
+  void (async () => {
+    try {
+      const wrote = await restorePrompt(api, state, handle, lastEnhancement.original, signal)
+      if (!wrote) {
+        api.ui.toast({
+          variant: "warning",
+          title: TOAST_TITLE,
+          message: "Prompt changed while reverting.",
+        })
+        return
+      }
+
+      state.lastEnhancement = undefined
+
+      api.ui.toast({
+        variant: "success",
+        title: TOAST_TITLE,
+        message: "Reverted to original prompt.",
+        duration: TOAST_DURATION_MS,
+      })
+    } catch (error) {
+      if (signal.aborted) return
+      const message = error instanceof Error ? error.message : "Revert failed."
+      api.ui.toast({ variant: "error", title: TOAST_TITLE, message })
+    }
+  })()
+}
+
+const tui: TuiPlugin = async (api, options) => {
+  const state: PluginState = {}
+  const [enhanceDialog, setEnhanceDialog] = createSignal<EnhanceDialogState | undefined>()
+
+  const promptSlots: TuiSlotPlugin = {
+    slots: {
+      app() {
+        return (
+          <Show when={enhanceDialog()}>
+            {(dialog) => renderEnhanceDialog(api, dialog())}
+          </Show>
+        )
+      },
+      home_prompt(_ctx, props) {
+        return (
+          <api.ui.Prompt
+            ref={(ref) => bindPromptRef(state, { name: "home" }, props.ref, ref)}
+            right={<api.ui.Slot name="home_prompt_right" />}
+          />
+        )
+      },
+      session_prompt(_ctx, props) {
+        return (
+          <api.ui.Prompt
+            ref={(ref) => bindPromptRef(state, { name: "session", sessionID: props.session_id }, props.ref, ref)}
+            sessionID={props.session_id}
+            visible={props.visible}
+            disabled={props.disabled}
+            onSubmit={props.on_submit}
+            right={<api.ui.Slot name="session_prompt_right" session_id={props.session_id} />}
+          />
+        )
+      },
+    },
+  }
+
+  api.slots.register(promptSlots)
+
+  const unregister = api.keymap.registerLayer({
+    commands: [
+      {
+        name: "prompt-enhancer.enhance",
+        title: DIALOG_TITLE,
+        desc: "Enhance current prompt",
+        category: "Prompt",
+        suggested: true,
+        run: () => {
+          openEnhanceDialog(api, options, state, setEnhanceDialog, api.lifecycle.signal)
+        },
+      },
+      {
+        name: "prompt-enhancer.revert",
+        title: "Revert Enhanced Prompt",
+        desc: "Revert last prompt enhancement",
+        category: "Prompt",
+        run: () => {
+          revertEnhancement(api, state, api.lifecycle.signal)
+        },
+      },
+    ],
+    bindings: [
+      {
+        key: "ctrl+e",
+        cmd: "prompt-enhancer.enhance",
+      },
+      {
+        key: "ctrl+shift+e",
+        cmd: "prompt-enhancer.revert",
+      },
+    ],
+  })
+
+  api.lifecycle.onDispose(() => {
+    unregister()
+    setEnhanceDialog(undefined)
+
+    const active = state.activeEnhancement
+    if (active) {
+      active.stopAnimation()
+      if (active.originalPrompt && active.handle.ref) {
+        try {
+          active.handle.ref.set(clonePromptInfo(active.originalPrompt))
+          active.handle.ref.focus()
+        } catch {
+          // WHY: Teardown restoration is best-effort because the captured prompt ref may already be detached.
+        }
+      }
+      active.controller.abort(api.lifecycle.signal.reason)
+    }
+
+    state.activeEnhancement = undefined
+    state.promptRef = undefined
+    state.promptTarget = undefined
+    state.lastEnhancement = undefined
+  })
+}
+
+const plugin = {
+  id: "prompt-enhancer",
+  tui,
+} satisfies TuiPluginModule & { id: string }
+
+export default plugin