feat: capture warehouse query failures (binder errors) as \core_failure\

SQL execution errors (e.g. DuckDB \"Binder Error: WHERE clause cannot
contain window functions\") were silently swallowed — \`sql.execute\`
returns a soft error result so \`core_failure\` never fired.

Changes:
- Fire \`core_failure\` from \`sql.execute\` error path with masked SQL
  (string literals replaced with \`?\`, sensitive keys redacted)
- Add \`"binder"\`/\`"window function"\` keywords to \`classifyError\`
  parse_error class so these map correctly instead of falling to \`"unknown"\`
- Fix \`categorizeQueryError\` to classify binder/window errors as
  \`"parse_error"\` instead of \`"other"\`

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: suryaiyer95

packages/opencode/src/altimate/native/connections/register.ts

@@ -166,7 +166,7 @@ export function detectQueryType(sql: string | null | undefined): string {
 
 export function categorizeQueryError(e: unknown): string {
   const msg = String(e).toLowerCase()
-  if (msg.includes("syntax")) return "syntax_error"
+  if (msg.includes("binder") || msg.includes("window function") || msg.includes("syntax")) return "parse_error"
   if (msg.includes("permission") || msg.includes("denied") || msg.includes("access")) return "permission_denied"
   if (msg.includes("timeout")) return "timeout"
   if (msg.includes("connection") || msg.includes("closed") || msg.includes("terminated")) return "connection_lost"
@@ -228,6 +228,7 @@ register("sql.execute", async (params: SqlExecuteParams): Promise<SqlExecuteResu
     } catch {}
     return result
   } catch (e) {
+    const errorMsg = String(e)
     try {
       Telemetry.track({
         type: "warehouse_query",
@@ -239,11 +240,23 @@ register("sql.execute", async (params: SqlExecuteParams): Promise<SqlExecuteResu
         duration_ms: Date.now() - startTime,
         row_count: 0,
         truncated: false,
-        error: String(e).slice(0, 500),
+        error: errorMsg.slice(0, 500),
         error_category: categorizeQueryError(e),
       })
+      Telemetry.track({
+        type: "core_failure",
+        timestamp: Date.now(),
+        session_id: Telemetry.getContext().sessionId,
+        tool_name: "sql.execute",
+        tool_category: "sql",
+        error_class: Telemetry.classifyError(errorMsg),
+        error_message: errorMsg.slice(0, 500),
+        input_signature: Telemetry.computeInputSignature({ sql: params.sql, warehouse: params.warehouse, limit: params.limit }),
+        masked_args: Telemetry.maskArgs({ sql: params.sql }),
+        duration_ms: Date.now() - startTime,
+      })
     } catch {}
-    return { columns: [], rows: [], row_count: 0, truncated: false, error: String(e) } as SqlExecuteResult & { error: string }
+    return { columns: [], rows: [], row_count: 0, truncated: false, error: errorMsg } as SqlExecuteResult & { error: string }
   }
 })
 

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

@@ -365,7 +365,7 @@ export namespace Telemetry {
     class: Telemetry.Event & { type: "core_failure" } extends { error_class: infer C } ? C : never
     keywords: string[]
   }> = [
-    { class: "parse_error", keywords: ["parse", "syntax", "binder", "unexpected token", "sqlglot"] },
+    { class: "parse_error", keywords: ["parse", "syntax", "binder error", "binder", "unexpected token", "sqlglot", "cannot contain window", "window function"] },
     {
       class: "connection",
       keywords: ["econnrefused", "connection", "socket", "enotfound", "econnreset"],