fix: address code review findings for prompt enhancement

- Add 15s timeout via `AbortController` to prevent indefinite hangs
- Extract `ENHANCE_ID` constant and document synthetic `as any` casts
- Fix `clean()` regex to match full-string code fences only (avoids
  stripping inner code blocks)
- Export `stripThinkTags()` as separate utility for testability
- Move auto-enhance before extmark expansion (prevents sending
  expanded paste content to the small model)
- Add toast feedback and error logging for auto-enhance path
- Update `store.prompt.input` after enhancement so history is accurate
- Add outer try/catch with logging to `enhancePrompt()`
- Expand tests from 9 to 30: `stripThinkTags()`, `clean()` edge
  cases, combined pipeline tests

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: anandgupta42

packages/opencode/src/altimate/enhance-prompt.ts

@@ -8,6 +8,10 @@ import { MessageV2 } from "@/session/message-v2"
 
 const log = Log.create({ service: "enhance-prompt" })
 
+const ENHANCE_TIMEOUT_MS = 15_000
+// Synthetic ID for enhancement requests — not a real session/message
+const ENHANCE_ID = "enhance-prompt" as any
+
 // Research-backed enhancement prompt based on:
 // - AutoPrompter (arxiv 2504.20196): 5 missing info categories that cause 27% lower edit correctness
 // - Meta-prompting best practices: clear role, structural scaffolding, few-shot examples
@@ -49,9 +53,14 @@ Enhanced: "Analyze why the query is slow. Run EXPLAIN/query profile to identify
 User: "migrate this from snowflake to bigquery"
 Enhanced: "Migrate the SQL from Snowflake dialect to BigQuery dialect. Convert Snowflake-specific functions (e.g. DATEADD, IFF, QUALIFY) to BigQuery equivalents. Preserve the query logic and verify the translated query is syntactically valid."`
 
+export function stripThinkTags(text: string) {
+  return text.replace(/<think>[\s\S]*?<\/think>\s*/g, "")
+}
+
 export function clean(text: string) {
   return text
-    .replace(/^```\w*\n?|```$/g, "")
+    .trim()
+    .replace(/^```\w*\n([\s\S]*?)\n```$/, "$1")
     .trim()
     .replace(/^(['"])([\s\S]*)\1$/, "$2")
     .trim()
@@ -67,67 +76,73 @@ export async function isAutoEnhanceEnabled(): Promise<boolean> {
 }
 
 export async function enhancePrompt(text: string): Promise<string> {
-  if (!text.trim()) return text
-
-  log.info("enhancing", { length: text.length })
-
-  const defaultModel = await Provider.defaultModel()
-  const model =
-    (await Provider.getSmallModel(defaultModel.providerID)) ??
-    (await Provider.getModel(defaultModel.providerID, defaultModel.modelID))
-
-  const agent: Agent.Info = {
-    name: "enhance-prompt",
-    mode: "primary",
-    hidden: true,
-    options: {},
-    permission: [],
-    prompt: ENHANCE_SYSTEM_PROMPT,
-    temperature: 0.7,
-  }
-
-  const user: MessageV2.User = {
-    id: "enhance-prompt" as any,
-    sessionID: "enhance-prompt" as any,
-    role: "user",
-    time: { created: Date.now() },
-    agent: "enhance-prompt",
-    model: {
-      providerID: model.providerID,
-      modelID: model.id,
-    },
-  }
-
-  const stream = await LLM.stream({
-    agent,
-    user,
-    system: [],
-    small: true,
-    tools: {},
-    model,
-    abort: new AbortController().signal,
-    sessionID: "enhance-prompt" as any,
-    retries: 2,
-    messages: [
-      {
-        role: "user",
-        content: text,
+  const trimmed = text.trim()
+  if (!trimmed) return text
+
+  log.info("enhancing", { length: trimmed.length })
+
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), ENHANCE_TIMEOUT_MS)
+
+  try {
+    const defaultModel = await Provider.defaultModel()
+    const model =
+      (await Provider.getSmallModel(defaultModel.providerID)) ??
+      (await Provider.getModel(defaultModel.providerID, defaultModel.modelID))
+
+    const agent: Agent.Info = {
+      name: "enhance-prompt",
+      mode: "primary",
+      hidden: true,
+      options: {},
+      permission: [],
+      prompt: ENHANCE_SYSTEM_PROMPT,
+      temperature: 0.7,
+    }
+
+    const user: MessageV2.User = {
+      id: ENHANCE_ID,
+      sessionID: ENHANCE_ID,
+      role: "user",
+      time: { created: Date.now() },
+      agent: "enhance-prompt",
+      model: {
+        providerID: model.providerID,
+        modelID: model.id,
       },
-    ],
-  })
-
-  const result = await stream.text.catch((err) => {
-    log.error("failed to enhance prompt", { error: err })
-    return undefined
-  })
-
-  if (!result) return text
-
-  const cleaned = clean(
-    result
-      .replace(/<think>[\s\S]*?<\/think>\s*/g, "")
-      .trim(),
-  )
-
-  return cleaned || text
+    }
+
+    const stream = await LLM.stream({
+      agent,
+      user,
+      system: [],
+      small: true,
+      tools: {},
+      model,
+      abort: controller.signal,
+      sessionID: ENHANCE_ID,
+      retries: 2,
+      messages: [
+        {
+          role: "user",
+          content: trimmed,
+        },
+      ],
+    })
+
+    const result = await stream.text.catch((err) => {
+      log.error("failed to enhance prompt", { error: err })
+      return undefined
+    })
+
+    if (!result) return text
+
+    const cleaned = clean(stripThinkTags(result).trim())
+    return cleaned || text
+  } catch (err) {
+    log.error("enhance prompt failed", { error: err })
+    return text
+  } finally {
+    clearTimeout(timeout)
+  }
 }

packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx

@@ -611,6 +611,26 @@ export function Prompt(props: PromptProps) {
     const messageID = MessageID.ascending()
     let inputText = store.prompt.input
 
+    // altimate_change start - auto-enhance prompt before expanding paste text
+    // Only enhance the raw user text, not shell commands or slash commands
+    if (store.mode === "normal" && !inputText.startsWith("/")) {
+      try {
+        const autoEnhance = await isAutoEnhanceEnabled()
+        if (autoEnhance) {
+          toast.show({ message: "Enhancing prompt...", variant: "info", duration: 2000 })
+          const enhanced = await enhancePrompt(inputText)
+          if (enhanced !== inputText) {
+            inputText = enhanced
+            setStore("prompt", "input", enhanced)
+          }
+        }
+      } catch (err) {
+        // Enhancement failure should never block prompt submission
+        console.error("auto-enhance failed, using original prompt", err)
+      }
+    }
+    // altimate_change end
+
     // Expand pasted text inline before submitting
     const allExtmarks = input.extmarks.getAllForTypeId(promptPartTypeId)
     const sortedExtmarks = allExtmarks.sort((a: { start: number }, b: { start: number }) => b.start - a.start)
@@ -630,20 +650,6 @@ export function Prompt(props: PromptProps) {
     // Filter out text parts (pasted content) since they're now expanded inline
     const nonTextParts = store.prompt.parts.filter((part) => part.type !== "text")
 
-    // altimate_change start - auto-enhance prompt before sending (if enabled)
-    // Only enhance normal prompts, not shell commands or slash commands
-    if (store.mode === "normal" && !inputText.startsWith("/")) {
-      try {
-        const autoEnhance = await isAutoEnhanceEnabled()
-        if (autoEnhance) {
-          inputText = await enhancePrompt(inputText)
-        }
-      } catch {
-        // Enhancement failure should never block prompt submission
-      }
-    }
-    // altimate_change end
-
     // Capture mode before it gets reset
     const currentMode = store.mode
     const variant = local.model.variant.current()

packages/opencode/test/altimate/enhance-prompt.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { clean } from "../../src/altimate/enhance-prompt"
+import { clean, stripThinkTags } from "../../src/altimate/enhance-prompt"
 
 describe("enhance-prompt clean()", () => {
   test("strips markdown code fences", () => {
@@ -38,4 +38,106 @@ describe("enhance-prompt clean()", () => {
     const input = "```\nFirst do X.\nThen do Y.\n```"
     expect(clean(input)).toBe("First do X.\nThen do Y.")
   })
+
+  test("handles code fences with trailing whitespace", () => {
+    expect(clean("  ```\nenhanced prompt\n```  ")).toBe("enhanced prompt")
+  })
+
+  test("preserves inner code blocks", () => {
+    const input = "Run this:\n```sql\nSELECT 1\n```\nThen verify."
+    expect(clean(input)).toBe("Run this:\n```sql\nSELECT 1\n```\nThen verify.")
+  })
+
+  test("handles whitespace-only string", () => {
+    expect(clean("   ")).toBe("")
+  })
+
+  test("handles code fence with no newline before content", () => {
+    expect(clean("```enhanced prompt```")).toBe("```enhanced prompt```")
+  })
+
+  test("handles single backtick quotes (not code fences)", () => {
+    expect(clean("`enhanced prompt`")).toBe("`enhanced prompt`")
+  })
+
+  test("strips quotes from multiline content", () => {
+    expect(clean('"First line.\nSecond line."')).toBe("First line.\nSecond line.")
+  })
+
+  test("does not strip mismatched quotes", () => {
+    expect(clean("'enhanced prompt\"")).toBe("'enhanced prompt\"")
+  })
+
+  test("handles nested quotes inside code fences", () => {
+    // After fence stripping, quote stripping also triggers on surrounding quotes
+    expect(clean('```\n\'inner quoted\'\n```')).toBe("inner quoted")
+  })
+})
+
+describe("enhance-prompt stripThinkTags()", () => {
+  test("removes single think block", () => {
+    expect(stripThinkTags("<think>reasoning here</think>actual prompt")).toBe("actual prompt")
+  })
+
+  test("removes think block with trailing whitespace", () => {
+    expect(stripThinkTags("<think>reasoning</think>\n\nactual prompt")).toBe("actual prompt")
+  })
+
+  test("removes multiple think blocks", () => {
+    const input = "<think>first</think>part one <think>second</think>part two"
+    expect(stripThinkTags(input)).toBe("part one part two")
+  })
+
+  test("handles multiline think content", () => {
+    const input = "<think>\nStep 1: analyze\nStep 2: rewrite\n</think>\nEnhanced prompt here"
+    expect(stripThinkTags(input)).toBe("Enhanced prompt here")
+  })
+
+  test("returns text unchanged when no think tags", () => {
+    expect(stripThinkTags("fix the auth bug")).toBe("fix the auth bug")
+  })
+
+  test("handles empty string", () => {
+    expect(stripThinkTags("")).toBe("")
+  })
+
+  test("handles think tags with no content after", () => {
+    expect(stripThinkTags("<think>reasoning only</think>")).toBe("")
+  })
+
+  test("handles nested angle brackets inside think tags", () => {
+    expect(stripThinkTags("<think>check if x < 5 and y > 3</think>result")).toBe("result")
+  })
+})
+
+describe("enhance-prompt combined pipeline", () => {
+  test("strips think tags then code fences then quotes", () => {
+    const input = '<think>reasoning</think>```\n"enhanced prompt"\n```'
+    const result = clean(stripThinkTags(input).trim())
+    expect(result).toBe("enhanced prompt")
+  })
+
+  test("strips think tags and preserves plain text", () => {
+    const input = "<think>let me think about this</think>Fix the failing dbt test by checking the schema."
+    const result = clean(stripThinkTags(input).trim())
+    expect(result).toBe("Fix the failing dbt test by checking the schema.")
+  })
+
+  test("handles think tags with code-fenced response", () => {
+    const input = "<think>The user wants to fix a test</think>\n```text\nInvestigate the failing test.\n```"
+    const result = clean(stripThinkTags(input).trim())
+    expect(result).toBe("Investigate the failing test.")
+  })
+
+  test("handles clean output that is empty after stripping", () => {
+    const input = '<think>everything is reasoning</think>```\n\n```'
+    const result = clean(stripThinkTags(input).trim())
+    expect(result).toBe("")
+  })
+
+  test("preserves content when no wrapping detected", () => {
+    const input = "Add a created_at timestamp column to the users dbt model."
+    const result = clean(stripThinkTags(input).trim())
+    expect(result).toBe("Add a created_at timestamp column to the users dbt model.")
+  })
 })