fix: address remaining review findings — history, debounce, tests

- Fix history storing original text instead of enhanced text by passing
  `inputText` explicitly to `history.append()` instead of spreading
  `store.prompt` which may contain stale state
- Add concurrency guard (`enhancingInProgress` flag) to prevent multiple
  concurrent auto-enhance LLM calls from rapid submissions
- Consolidate magic string into `ENHANCE_NAME` constant used across
  agent name, user agent, log service, and ID derivation
- Add justifying comment for `as any` cast on synthetic IDs explaining
  why branded types are safely bypassed
- Add `isAutoEnhanceEnabled()` tests (5 cases): config absent, present
  but missing flag, false, true, undefined
- Add `enhancePrompt()` tests (10 cases): empty input, whitespace,
  successful enhancement, think tag stripping, code fence stripping,
  stream.text failure, stream init failure, empty LLM response, think
  tags with no content, combined pipeline

Test count: 32 -> 48

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

Author: anandgupta42

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

@@ -6,11 +6,13 @@ import { Config } from "@/config/config"
 import { Log } from "@/util/log"
 import { MessageV2 } from "@/session/message-v2"
 
-const log = Log.create({ service: "enhance-prompt" })
-
+const ENHANCE_NAME = "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
+// MessageV2.User requires branded MessageID/SessionID types, but this is a
+// synthetic message that never enters the session store — cast is safe here.
+const ENHANCE_ID = ENHANCE_NAME as any
+
+const log = Log.create({ service: ENHANCE_NAME })
 
 // Research-backed enhancement prompt based on:
 // - AutoPrompter (arxiv 2504.20196): 5 missing info categories that cause 27% lower edit correctness
@@ -93,7 +95,7 @@ export async function enhancePrompt(text: string): Promise<string> {
       (await Provider.getModel(defaultModel.providerID, defaultModel.modelID))
 
     const agent: Agent.Info = {
-      name: "enhance-prompt",
+      name: ENHANCE_NAME,
       mode: "primary",
       hidden: true,
       options: {},
@@ -107,7 +109,7 @@ export async function enhancePrompt(text: string): Promise<string> {
       sessionID: ENHANCE_ID,
       role: "user",
       time: { created: Date.now() },
-      agent: "enhance-prompt",
+      agent: ENHANCE_NAME,
       model: {
         providerID: model.providerID,
         modelID: model.id,

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

@@ -36,6 +36,7 @@ import { useTextareaKeybindings } from "../textarea-keybindings"
 import { DialogSkill } from "../dialog-skill"
 // altimate_change start - import prompt enhancement
 import { enhancePrompt, isAutoEnhanceEnabled } from "@/altimate/enhance-prompt"
+let enhancingInProgress = false
 // altimate_change end
 
 export type PromptProps = {
@@ -613,10 +614,12 @@ export function Prompt(props: PromptProps) {
 
     // 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("/")) {
+    // Guard prevents concurrent enhancement calls from rapid submissions
+    if (store.mode === "normal" && !inputText.startsWith("/") && !enhancingInProgress) {
       try {
         const autoEnhance = await isAutoEnhanceEnabled()
         if (autoEnhance) {
+          enhancingInProgress = true
           toast.show({ message: "Enhancing prompt...", variant: "info", duration: 2000 })
           const enhanced = await enhancePrompt(inputText)
           if (enhanced !== inputText) {
@@ -627,6 +630,8 @@ export function Prompt(props: PromptProps) {
       } catch (err) {
         // Enhancement failure should never block prompt submission
         console.error("auto-enhance failed, using original prompt", err)
+      } finally {
+        enhancingInProgress = false
       }
     }
     // altimate_change end
@@ -720,6 +725,7 @@ export function Prompt(props: PromptProps) {
     }
     history.append({
       ...store.prompt,
+      input: inputText,
       mode: currentMode,
     })
     input.extmarks.clear()

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

@@ -1,6 +1,62 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect, test, mock, beforeEach } from "bun:test"
 import { clean, stripThinkTags } from "../../src/altimate/enhance-prompt"
 
+// Mock Config for isAutoEnhanceEnabled tests
+let mockConfig: any = {}
+mock.module("@/config/config", () => ({
+  Config: {
+    get: () => Promise.resolve(mockConfig),
+  },
+}))
+
+// Mock Provider and LLM for enhancePrompt tests
+let mockStreamResult: string | undefined = "enhanced result"
+let mockStreamShouldThrow = false
+mock.module("@/provider/provider", () => ({
+  Provider: {
+    defaultModel: () =>
+      Promise.resolve({ providerID: "test-provider", modelID: "test-model" }),
+    getSmallModel: () =>
+      Promise.resolve({ providerID: "test-provider", id: "test-small", modelID: "test-small" }),
+    getModel: () =>
+      Promise.resolve({ providerID: "test-provider", id: "test-model", modelID: "test-model" }),
+  },
+}))
+
+mock.module("@/session/llm", () => ({
+  LLM: {
+    stream: () => {
+      if (mockStreamShouldThrow) return Promise.reject(new Error("stream init failed"))
+      return Promise.resolve({
+        text: mockStreamResult !== undefined
+          ? Promise.resolve(mockStreamResult)
+          : Promise.reject(new Error("stream text failed")),
+      })
+    },
+  },
+}))
+
+mock.module("@/util/log", () => ({
+  Log: {
+    create: () => ({
+      info: () => {},
+      error: () => {},
+      debug: () => {},
+    }),
+  },
+}))
+
+mock.module("@/agent/agent", () => ({
+  Agent: {},
+}))
+
+mock.module("@/session/message-v2", () => ({
+  MessageV2: {},
+}))
+
+// Import after mocking
+const { enhancePrompt, isAutoEnhanceEnabled } = await import("../../src/altimate/enhance-prompt")
+
 describe("enhance-prompt clean()", () => {
   test("strips markdown code fences", () => {
     expect(clean("```\nfixed prompt\n```")).toBe("fixed prompt")
@@ -149,3 +205,103 @@ describe("enhance-prompt combined pipeline", () => {
     expect(result).toBe("Add a created_at timestamp column to the users dbt model.")
   })
 })
+
+describe("isAutoEnhanceEnabled()", () => {
+  beforeEach(() => {
+    mockConfig = {}
+  })
+
+  test("returns false when experimental config is absent", async () => {
+    mockConfig = {}
+    expect(await isAutoEnhanceEnabled()).toBe(false)
+  })
+
+  test("returns false when experimental exists but auto_enhance_prompt is missing", async () => {
+    mockConfig = { experimental: {} }
+    expect(await isAutoEnhanceEnabled()).toBe(false)
+  })
+
+  test("returns false when auto_enhance_prompt is false", async () => {
+    mockConfig = { experimental: { auto_enhance_prompt: false } }
+    expect(await isAutoEnhanceEnabled()).toBe(false)
+  })
+
+  test("returns true when auto_enhance_prompt is true", async () => {
+    mockConfig = { experimental: { auto_enhance_prompt: true } }
+    expect(await isAutoEnhanceEnabled()).toBe(true)
+  })
+
+  test("returns false when auto_enhance_prompt is undefined", async () => {
+    mockConfig = { experimental: { auto_enhance_prompt: undefined } }
+    expect(await isAutoEnhanceEnabled()).toBe(false)
+  })
+})
+
+describe("enhancePrompt()", () => {
+  beforeEach(() => {
+    mockStreamResult = "enhanced result"
+    mockStreamShouldThrow = false
+  })
+
+  test("returns original text for empty input", async () => {
+    expect(await enhancePrompt("")).toBe("")
+  })
+
+  test("returns original text for whitespace-only input", async () => {
+    expect(await enhancePrompt("   ")).toBe("   ")
+  })
+
+  test("returns enhanced text from LLM", async () => {
+    mockStreamResult = "Investigate the failing test and fix it."
+    const result = await enhancePrompt("fix the test")
+    expect(result).toBe("Investigate the failing test and fix it.")
+  })
+
+  test("strips think tags from LLM response", async () => {
+    mockStreamResult = "<think>let me reason</think>Enhanced prompt here"
+    const result = await enhancePrompt("do something")
+    expect(result).toBe("Enhanced prompt here")
+  })
+
+  test("strips code fences from LLM response", async () => {
+    mockStreamResult = '```\nEnhanced prompt here\n```'
+    const result = await enhancePrompt("do something")
+    expect(result).toBe("Enhanced prompt here")
+  })
+
+  test("returns original text when LLM stream.text fails", async () => {
+    mockStreamResult = undefined // causes stream.text to reject
+    const result = await enhancePrompt("fix the bug")
+    expect(result).toBe("fix the bug")
+  })
+
+  test("returns original text when LLM stream init fails", async () => {
+    mockStreamShouldThrow = true
+    const result = await enhancePrompt("fix the bug")
+    expect(result).toBe("fix the bug")
+  })
+
+  test("returns original text when LLM returns empty string", async () => {
+    mockStreamResult = ""
+    const result = await enhancePrompt("fix the bug")
+    expect(result).toBe("fix the bug")
+  })
+
+  test("handles LLM response with only think tags (no content)", async () => {
+    mockStreamResult = "<think>I should enhance this</think>"
+    const result = await enhancePrompt("fix the bug")
+    expect(result).toBe("fix the bug")
+  })
+
+  test("handles unclosed think tag in LLM response", async () => {
+    mockStreamResult = "<think>reasoning cut off by token limit"
+    const result = await enhancePrompt("fix the bug")
+    expect(result).toBe("fix the bug")
+  })
+
+  test("handles combined think tags + code fences + quotes", async () => {
+    mockStreamResult = '<think>reasoning</think>```\n"Investigate the failing test."\n```'
+    const result = await enhancePrompt("fix test")
+    expect(result).toBe("Investigate the failing test.")
+  })
+})