feat: e2e tests, performance benchmarks, and UX gap fixes

## E2E Integration Tests (41 tests)
- `feature-discovery-e2e.test.ts` (29 tests): Full warehouse-add → suggestions
  flow, progressive disclosure chain, plan refinement session, telemetry
  event validation with mocked Dispatcher
- `performance-regression.test.ts` (12 tests): 1000x suggestion generation
  < 50ms, 10000x progressive lookup < 50ms, 100k phrase detection < 200ms,
  output determinism verification

## UX Gap Fixes
- **Suggestion deduplication**: Progressive hints shown at most once per
  session per tool via `shownProgressiveSuggestions` Set. Running
  `sql_execute` 10 times no longer repeats the same tip.
- **Approval false positives**: "yes, but change X" now correctly classified
  as "refine" not "approve". Added `refinementQualifiers` (" but ",
  " however ", " except ", " change ", etc.) that override approval detection.
  "no" uses `\bno\b` word boundary to avoid matching "know", "notion", etc.
- **Revision cap communication**: When 5 revision cap is hit, a synthetic
  message informs the LLM to tell the user. Telemetry tracks "cap_reached".
- **Warehouse add latency**: Suggestion gathering now uses `Promise.all` +
  `Promise.race` with 1500ms timeout. Slow schema/dbt checks silently
  skipped instead of blocking the response.

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

Author: anandgupta42

packages/opencode/src/altimate/telemetry/index.ts

@@ -394,7 +394,7 @@ export namespace Telemetry {
         timestamp: number
         session_id: string
         revision_number: number
-        action: "refine" | "approve" | "reject"
+        action: "refine" | "approve" | "reject" | "cap_reached"
       }
     // altimate_change end
     | {

packages/opencode/src/altimate/tools/post-connect-suggestions.ts

@@ -4,6 +4,9 @@
  * After warehouse connect, users often don't know what to do next.
  * This module provides contextual suggestions based on the user's
  * environment and progressive next-step hints after tool usage.
+ *
+ * Deduplication: progressive suggestions are shown at most once per
+ * session per tool to avoid repetitive hints.
  */
 
 import { Telemetry } from "../../telemetry"
@@ -17,6 +20,17 @@ export namespace PostConnectSuggestions {
     toolsUsedInSession: string[]
   }
 
+  /**
+   * Set of progressive suggestion keys already shown in this process.
+   * Reset when the process restarts (per-session lifetime).
+   */
+  const shownProgressiveSuggestions = new Set<string>()
+
+  /** Reset shown suggestions (useful for testing). */
+  export function resetShownSuggestions(): void {
+    shownProgressiveSuggestions.clear()
+  }
+
   export function getPostConnectSuggestions(ctx: SuggestionContext): string {
     const suggestions: string[] = []
 
@@ -60,7 +74,8 @@ export namespace PostConnectSuggestions {
 
   /**
    * Progressive disclosure: suggest next tool based on what was just used.
-   * Returns null if no suggestion applies or tool is unknown.
+   * Returns null if no suggestion applies, tool is unknown, or the
+   * suggestion was already shown in this session (deduplication).
    */
   export function getProgressiveSuggestion(
     lastToolUsed: string,
@@ -76,7 +91,17 @@ export namespace PostConnectSuggestions {
         "Schema indexed! You can now use sql_analyze for quality checks, schema_inspect for exploration, and lineage_check for data flow analysis.",
       warehouse_add: null, // Handled by post-connect suggestions
     }
-    return progression[lastToolUsed] ?? null
+
+    const suggestion = progression[lastToolUsed] ?? null
+    if (!suggestion) return null
+
+    // Deduplicate: only show each progressive suggestion once per session
+    if (shownProgressiveSuggestions.has(lastToolUsed)) {
+      return null
+    }
+    shownProgressiveSuggestions.add(lastToolUsed)
+
+    return suggestion
   }
 
   /**

packages/opencode/src/altimate/tools/warehouse-add.ts

@@ -44,41 +44,54 @@ IMPORTANT: For private key file paths, always use "private_key_path" (not "priva
       })
 
       if (result.success) {
-        // altimate_change start — append post-connect feature suggestions
+        // altimate_change start — append post-connect feature suggestions (async, non-blocking)
         let output = `Successfully added warehouse '${result.name}' (type: ${result.type}).\n\nUse warehouse_test to verify connectivity.`
+
+        // Run suggestion gathering concurrently with a timeout to avoid
+        // adding noticeable latency to the warehouse add response.
         try {
-          const schemaCache = await Dispatcher.call("schema.cache_status", {}).catch(() => null)
-          const schemaIndexed = (schemaCache?.total_tables ?? 0) > 0
-          const warehouseList = await Dispatcher.call("warehouse.list", {}).catch(() => ({ warehouses: [] }))
+          const SUGGESTION_TIMEOUT_MS = 1500
+          const suggestionPromise = (async () => {
+            const [schemaCache, warehouseList, dbtInfo] = await Promise.all([
+              Dispatcher.call("schema.cache_status", {}).catch(() => null),
+              Dispatcher.call("warehouse.list", {}).catch(() => ({ warehouses: [] })),
+              import("./project-scan")
+                .then((m) => m.detectDbtProject(process.cwd()))
+                .catch(() => ({ found: false })),
+            ])
+            const schemaIndexed = (schemaCache?.total_tables ?? 0) > 0
+            const dbtDetected = dbtInfo.found
 
-          let dbtDetected = false
-          try {
-            const { detectDbtProject } = await import("./project-scan")
-            const dbtInfo = await detectDbtProject(process.cwd())
-            dbtDetected = dbtInfo.found
-          } catch {
-            // project-scan unavailable — skip dbt detection
-          }
+            const suggestionCtx: PostConnectSuggestions.SuggestionContext = {
+              warehouseType: result.type,
+              schemaIndexed,
+              dbtDetected,
+              connectionCount: warehouseList.warehouses.length,
+              toolsUsedInSession: [],
+            }
+            return { suggestionCtx, schemaIndexed, dbtDetected }
+          })()
 
-          const suggestionCtx: PostConnectSuggestions.SuggestionContext = {
-            warehouseType: result.type,
-            schemaIndexed,
-            dbtDetected,
-            connectionCount: warehouseList.warehouses.length,
-            toolsUsedInSession: [],
-          }
-          output += PostConnectSuggestions.getPostConnectSuggestions(suggestionCtx)
+          const timeoutPromise = new Promise<null>((resolve) =>
+            setTimeout(() => resolve(null), SUGGESTION_TIMEOUT_MS),
+          )
+          const suggestionResult = await Promise.race([suggestionPromise, timeoutPromise])
 
-          // Derive suggestions list from the same context to avoid drift
-          const suggestionsShown = ["sql_execute", "sql_analyze", "lineage_check", "schema_detect_pii"]
-          if (!suggestionCtx.schemaIndexed) suggestionsShown.unshift("schema_index")
-          if (suggestionCtx.dbtDetected) suggestionsShown.push("dbt-develop", "dbt-troubleshoot")
-          if (suggestionCtx.connectionCount > 1) suggestionsShown.push("data_diff")
-          PostConnectSuggestions.trackSuggestions({
-            suggestionType: "post_warehouse_connect",
-            suggestionsShown,
-            warehouseType: result.type,
-          })
+          if (suggestionResult) {
+            const { suggestionCtx } = suggestionResult
+            output += PostConnectSuggestions.getPostConnectSuggestions(suggestionCtx)
+
+            // Derive suggestions list from the same context to avoid drift
+            const suggestionsShown = ["sql_execute", "sql_analyze", "lineage_check", "schema_detect_pii"]
+            if (!suggestionCtx.schemaIndexed) suggestionsShown.unshift("schema_index")
+            if (suggestionCtx.dbtDetected) suggestionsShown.push("dbt-develop", "dbt-troubleshoot")
+            if (suggestionCtx.connectionCount > 1) suggestionsShown.push("data_diff")
+            PostConnectSuggestions.trackSuggestions({
+              suggestionType: "post_warehouse_connect",
+              suggestionsShown,
+              warehouseType: result.type,
+            })
+          }
         } catch {
           // Suggestions must never break the add flow
         }

packages/opencode/src/session/prompt.ts

@@ -628,26 +628,67 @@ export namespace SessionPrompt {
           planHasWritten = await Filesystem.exists(planPath)
         }
         // If plan was already written and user sent a new message, this is a refinement
-        if (planHasWritten && step > 1 && planRevisionCount < 5) {
-          planRevisionCount++
+        if (planHasWritten && step > 1) {
           // Detect approval phrases in the last user message text
           const lastUserMsg = msgs.findLast((m) => m.info.role === "user")
           const userText = lastUserMsg?.parts
             .filter((p): p is MessageV2.TextPart => p.type === "text" && !("synthetic" in p && p.synthetic))
             .map((p) => p.text.toLowerCase())
             .join(" ") ?? ""
-          const rejectionPhrases = ["no", "don't", "stop", "reject", "not good", "undo", "abort", "start over", "wrong"]
-          const approvalPhrases = ["looks good", "proceed", "approved", "approve", "lgtm", "go ahead", "ship it", "yes", "perfect"]
-          const isRejection = rejectionPhrases.some((phrase) => userText.includes(phrase))
-          const isApproval = !isRejection && approvalPhrases.some((phrase) => userText.includes(phrase))
-          const action = isRejection ? "reject" : isApproval ? "approve" : "refine"
-          Telemetry.track({
-            type: "plan_revision",
-            timestamp: Date.now(),
-            session_id: sessionID,
-            revision_number: planRevisionCount,
-            action,
-          })
+
+          if (planRevisionCount >= 5) {
+            // Cap reached — track and inject a synthetic hint so the LLM informs the user
+            Telemetry.track({
+              type: "plan_revision",
+              timestamp: Date.now(),
+              session_id: sessionID,
+              revision_number: planRevisionCount,
+              action: "cap_reached",
+            })
+            // Append a synthetic text part to the last user message in the local msgs copy
+            // so the LLM sees the limit and can communicate it. This does not persist.
+            if (lastUserMsg) {
+              lastUserMsg.parts = [
+                ...lastUserMsg.parts,
+                {
+                  type: "text" as const,
+                  id: PartID.ascending(),
+                  sessionID,
+                  messageID: lastUserMsg.info.id,
+                  text: "\n\n[System note: This plan has reached the maximum revision limit (5). Please inform the user and suggest finalizing the plan or starting a new planning session.]",
+                  synthetic: true,
+                },
+              ]
+            }
+          } else {
+            planRevisionCount++
+
+            // Refinement qualifiers: if the user says "yes, but ..." or "approve, however ..."
+            // they intend to refine, not approve. Check for these before pure approval.
+            const refinementQualifiers = [" but ", " however ", " except ", " change ", " modify ", " update ", " instead ", " although ", " with the following", " with these"]
+            const hasRefinementQualifier = refinementQualifiers.some((q) => userText.includes(q))
+
+            const rejectionPhrases = ["don't", "stop", "reject", "not good", "undo", "abort", "start over", "wrong"]
+            // "no" as a standalone word to avoid matching "know", "notion", etc.
+            const rejectionWords = ["no"]
+            const approvalPhrases = ["looks good", "proceed", "approved", "approve", "lgtm", "go ahead", "ship it", "yes", "perfect"]
+
+            const isRejectionPhrase = rejectionPhrases.some((phrase) => userText.includes(phrase))
+            const isRejectionWord = rejectionWords.some((word) => {
+              const regex = new RegExp(`\\b${word}\\b`)
+              return regex.test(userText)
+            })
+            const isRejection = isRejectionPhrase || isRejectionWord
+            const isApproval = !isRejection && !hasRefinementQualifier && approvalPhrases.some((phrase) => userText.includes(phrase))
+            const action = isRejection ? "reject" : isApproval ? "approve" : "refine"
+            Telemetry.track({
+              type: "plan_revision",
+              timestamp: Date.now(),
+              session_id: sessionID,
+              revision_number: planRevisionCount,
+              action,
+            })
+          }
         }
       }
       // altimate_change end