From 7b7471368ccc298ba17a6bf1221b66a418841e40 Mon Sep 17 00:00:00 2001
From: suryaiyer95 <surya@altimate.ai>
Date: Tue, 24 Mar 2026 11:47:36 -0700
Subject: [PATCH 1/6] feat: [AI-5975] add `sql_quality` telemetry for issue
 prevention metrics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add a new `sql_quality` telemetry event that fires whenever tools
successfully detect SQL issues — turning findings into measurable
"issues prevented" data in App Insights.

Architecture:
- New `sql_quality` event type in `Telemetry.Event` with `finding_count`,
  `by_severity`, `by_category`, `has_schema`, `dialect`, `duration_ms`
- New `Telemetry.Finding` interface and `aggregateFindings()` helper
- Centralized emission in `tool.ts` — checks `metadata.findings` array
  after any tool completes, aggregates counts, emits event
- Tools populate `metadata.findings` with `{category, severity}` pairs:
  - `sql_analyze`: issue type + severity from lint/semantic/safety analysis
  - `altimate_core_validate`: classified validation errors (missing_table,
    missing_column, syntax_error, type_mismatch)
  - `altimate_core_semantics`: rule/type + severity from semantic checks
  - `altimate_core_fix`: fix_applied / unfixable_error categories
  - `altimate_core_correct`: correction_applied findings
  - `altimate_core_equivalence`: equivalence_difference findings

PII-safe: only category names and severity levels flow to telemetry,
never SQL content.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../opencode/src/altimate/telemetry/index.ts  |  39 +++
 .../altimate/tools/altimate-core-correct.ts   |  18 +-
 .../tools/altimate-core-equivalence.ts        |  25 +-
 .../src/altimate/tools/altimate-core-fix.ts   |  22 +-
 .../altimate/tools/altimate-core-policy.ts    |  18 +-
 .../altimate/tools/altimate-core-semantics.ts |  23 +-
 .../altimate/tools/altimate-core-validate.ts  |  32 ++-
 .../src/altimate/tools/sql-analyze.ts         |  11 +-
 packages/opencode/src/tool/tool.ts            |  19 ++
 .../altimate/sql-quality-telemetry.test.ts    | 229 ++++++++++++++++++
 10 files changed, 417 insertions(+), 19 deletions(-)
 create mode 100644 packages/opencode/test/altimate/sql-quality-telemetry.test.ts

diff --git a/packages/opencode/src/altimate/telemetry/index.ts b/packages/opencode/src/altimate/telemetry/index.ts
index 25ae60415..8e3502686 100644
--- a/packages/opencode/src/altimate/telemetry/index.ts
+++ b/packages/opencode/src/altimate/telemetry/index.ts
@@ -405,6 +405,23 @@ export namespace Telemetry {
         masked_args?: string
         duration_ms: number
       }
+    // altimate_change start — sql quality telemetry for issue prevention metrics
+    | {
+        type: "sql_quality"
+        timestamp: number
+        session_id: string
+        tool_name: string
+        tool_category: string
+        finding_count: number
+        /** JSON-encoded Record<string, number> — count per severity level */
+        by_severity: string
+        /** JSON-encoded Record<string, number> — count per issue category */
+        by_category: string
+        has_schema: boolean
+        dialect: string
+        duration_ms: number
+      }
+    // altimate_change end
 
   const ERROR_PATTERNS: Array<{
     class: Telemetry.Event & { type: "core_failure" } extends { error_class: infer C } ? C : never
@@ -774,6 +791,28 @@ export namespace Telemetry {
     }
   }
 
+  // altimate_change start — sql quality telemetry types
+  /** Lightweight finding record for quality telemetry. Only category/severity — never SQL content. */
+  export interface Finding {
+    category: string
+    severity: string
+  }
+
+  /** Aggregate an array of findings into counts suitable for the sql_quality event. */
+  export function aggregateFindings(findings: Finding[]): {
+    by_severity: Record<string, number>
+    by_category: Record<string, number>
+  } {
+    const by_severity: Record<string, number> = {}
+    const by_category: Record<string, number> = {}
+    for (const f of findings) {
+      by_severity[f.severity] = (by_severity[f.severity] ?? 0) + 1
+      by_category[f.category] = (by_category[f.category] ?? 0) + 1
+    }
+    return { by_severity, by_category }
+  }
+  // altimate_change end
+
   export async function shutdown() {
     // Wait for init to complete so we know whether telemetry is enabled
     // and have a valid endpoint to flush to.  init() is fire-and-forget
diff --git a/packages/opencode/src/altimate/tools/altimate-core-correct.ts b/packages/opencode/src/altimate/tools/altimate-core-correct.ts
index 92135e34a..76cec5245 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-correct.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-correct.ts
@@ -1,6 +1,7 @@
 import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
+import type { Telemetry } from "../telemetry"
 
 export const AltimateCoreCorrectTool = Tool.define("altimate_core_correct", {
   description:
@@ -11,6 +12,7 @@ export const AltimateCoreCorrectTool = Tool.define("altimate_core_correct", {
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
   }),
   async execute(args, ctx) {
+    const hasSchema = !!(args.schema_path || (args.schema_context && Object.keys(args.schema_context).length > 0))
     try {
       const result = await Dispatcher.call("altimate_core.correct", {
         sql: args.sql,
@@ -19,14 +21,26 @@ export const AltimateCoreCorrectTool = Tool.define("altimate_core_correct", {
       })
       const data = (result.data ?? {}) as Record<string, any>
       const error = result.error ?? data.error ?? extractCorrectErrors(data)
+      // altimate_change start — sql quality findings for telemetry
+      const findings: Telemetry.Finding[] = (data.changes ?? []).map(() => ({
+        category: "correction_applied",
+      }))
+      // altimate_change end
       return {
         title: `Correct: ${data.success ? "CORRECTED" : "COULD NOT CORRECT"}`,
-        metadata: { success: result.success, iterations: data.iterations, ...(error && { error }) },
+        metadata: {
+          success: result.success,
+          iterations: data.iterations,
+          has_schema: hasSchema,
+          dialect: "snowflake",
+          ...(error && { error }),
+          ...(findings.length > 0 && { findings }),
+        },
         output: formatCorrect(data),
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Correct: ERROR", metadata: { success: false, iterations: 0, error: msg }, output: `Failed: ${msg}` }
+      return { title: "Correct: ERROR", metadata: { success: false, iterations: 0, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-equivalence.ts b/packages/opencode/src/altimate/tools/altimate-core-equivalence.ts
index fa0f8b267..5a83e03b4 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-equivalence.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-equivalence.ts
@@ -1,6 +1,7 @@
 import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
+import type { Telemetry } from "../telemetry"
 
 export const AltimateCoreEquivalenceTool = Tool.define("altimate_core_equivalence", {
   description:
@@ -12,9 +13,10 @@ export const AltimateCoreEquivalenceTool = Tool.define("altimate_core_equivalenc
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
   }),
   async execute(args, ctx) {
-    if (!args.schema_path && (!args.schema_context || Object.keys(args.schema_context).length === 0)) {
+    const hasSchema = !!(args.schema_path || (args.schema_context && Object.keys(args.schema_context).length > 0))
+    if (!hasSchema) {
       const error = "No schema provided. Provide schema_context or schema_path so table/column references can be resolved."
-      return { title: "Equivalence: NO SCHEMA", metadata: { success: false, equivalent: false, error }, output: `Error: ${error}` }
+      return { title: "Equivalence: NO SCHEMA", metadata: { success: false, equivalent: false, has_schema: false, dialect: "snowflake", error }, output: `Error: ${error}` }
     }
     try {
       const result = await Dispatcher.call("altimate_core.equivalence", {
@@ -28,14 +30,29 @@ export const AltimateCoreEquivalenceTool = Tool.define("altimate_core_equivalenc
       // "Not equivalent" is a valid analysis result, not a failure.
       // Only treat it as failure when there's an actual error.
       const isRealFailure = !!error
+      // altimate_change start — sql quality findings for telemetry
+      const findings: Telemetry.Finding[] = []
+      if (!data.equivalent && data.differences?.length) {
+        for (const d of data.differences) {
+          findings.push({ category: "equivalence_difference" })
+        }
+      }
+      // altimate_change end
       return {
         title: isRealFailure ? "Equivalence: ERROR" : `Equivalence: ${data.equivalent ? "EQUIVALENT" : "DIFFERENT"}`,
-        metadata: { success: !isRealFailure, equivalent: data.equivalent, ...(error && { error }) },
+        metadata: {
+          success: !isRealFailure,
+          equivalent: data.equivalent,
+          has_schema: hasSchema,
+          dialect: "snowflake",
+          ...(error && { error }),
+          ...(findings.length > 0 && { findings }),
+        },
         output: formatEquivalence(data),
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Equivalence: ERROR", metadata: { success: false, equivalent: false, error: msg }, output: `Failed: ${msg}` }
+      return { title: "Equivalence: ERROR", metadata: { success: false, equivalent: false, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-fix.ts b/packages/opencode/src/altimate/tools/altimate-core-fix.ts
index e4002101c..ebd1db596 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-fix.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-fix.ts
@@ -1,6 +1,7 @@
 import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
+import type { Telemetry } from "../telemetry"
 
 export const AltimateCoreFixTool = Tool.define("altimate_core_fix", {
   description:
@@ -12,6 +13,7 @@ export const AltimateCoreFixTool = Tool.define("altimate_core_fix", {
     max_iterations: z.number().optional().describe("Maximum fix iterations (default: 5)"),
   }),
   async execute(args, ctx) {
+    const hasSchema = !!(args.schema_path || (args.schema_context && Object.keys(args.schema_context).length > 0))
     try {
       const result = await Dispatcher.call("altimate_core.fix", {
         sql: args.sql,
@@ -24,14 +26,30 @@ export const AltimateCoreFixTool = Tool.define("altimate_core_fix", {
       // post_fix_valid=true with no errors means SQL was already valid (nothing to fix)
       const alreadyValid = data.post_fix_valid && !error
       const success = result.success || alreadyValid
+      // altimate_change start — sql quality findings for telemetry
+      const findings: Telemetry.Finding[] = []
+      for (const fix of data.fixes_applied ?? data.changes ?? []) {
+        findings.push({ category: "fix_applied" })
+      }
+      for (const err of data.unfixable_errors ?? []) {
+        findings.push({ category: "unfixable_error" })
+      }
+      // altimate_change end
       return {
         title: `Fix: ${alreadyValid ? "ALREADY VALID" : data.fixed ? "FIXED" : "COULD NOT FIX"}`,
-        metadata: { success, fixed: !!data.fixed_sql, ...(error && { error }) },
+        metadata: {
+          success,
+          fixed: !!data.fixed_sql,
+          has_schema: hasSchema,
+          dialect: "snowflake",
+          ...(error && { error }),
+          ...(findings.length > 0 && { findings }),
+        },
         output: formatFix(data),
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Fix: ERROR", metadata: { success: false, fixed: false, error: msg }, output: `Failed: ${msg}` }
+      return { title: "Fix: ERROR", metadata: { success: false, fixed: false, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-policy.ts b/packages/opencode/src/altimate/tools/altimate-core-policy.ts
index 26763a5fe..a69a9739c 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-policy.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-policy.ts
@@ -1,6 +1,7 @@
 import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
+import type { Telemetry } from "../telemetry"
 
 export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
   description:
@@ -12,6 +13,7 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
   }),
   async execute(args, ctx) {
+    const hasSchema = !!(args.schema_path || (args.schema_context && Object.keys(args.schema_context).length > 0))
     try {
       const result = await Dispatcher.call("altimate_core.policy", {
         sql: args.sql,
@@ -21,14 +23,26 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
       })
       const data = (result.data ?? {}) as Record<string, any>
       const error = result.error ?? data.error
+      // altimate_change start — sql quality findings for telemetry
+      const findings: Telemetry.Finding[] = (data.violations ?? []).map((v: any) => ({
+        category: v.rule ?? "policy_violation",
+      }))
+      // altimate_change end
       return {
         title: `Policy: ${data.pass ? "PASS" : "VIOLATIONS FOUND"}`,
-        metadata: { success: result.success, pass: data.pass, ...(error && { error }) },
+        metadata: {
+          success: result.success,
+          pass: data.pass,
+          has_schema: hasSchema,
+          dialect: "snowflake",
+          ...(error && { error }),
+          ...(findings.length > 0 && { findings }),
+        },
         output: formatPolicy(data),
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Policy: ERROR", metadata: { success: false, pass: false, error: msg }, output: `Failed: ${msg}` }
+      return { title: "Policy: ERROR", metadata: { success: false, pass: false, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-semantics.ts b/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
index 42257f7d6..7ced0dfde 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
@@ -1,6 +1,7 @@
 import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
+import type { Telemetry } from "../telemetry"
 
 export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics", {
   description:
@@ -11,9 +12,10 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
   }),
   async execute(args, ctx) {
-    if (!args.schema_path && (!args.schema_context || Object.keys(args.schema_context).length === 0)) {
+    const hasSchema = !!(args.schema_path || (args.schema_context && Object.keys(args.schema_context).length > 0))
+    if (!hasSchema) {
       const error = "No schema provided. Provide schema_context or schema_path so table/column references can be resolved."
-      return { title: "Semantics: NO SCHEMA", metadata: { success: false, valid: false, issue_count: 0, error }, output: `Error: ${error}` }
+      return { title: "Semantics: NO SCHEMA", metadata: { success: false, valid: false, issue_count: 0, has_schema: false, dialect: "snowflake", error }, output: `Error: ${error}` }
     }
     try {
       const result = await Dispatcher.call("altimate_core.semantics", {
@@ -25,14 +27,27 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
       const issueCount = data.issues?.length ?? 0
       const error = result.error ?? data.error ?? extractSemanticsErrors(data)
       const hasError = Boolean(error)
+      // altimate_change start — sql quality findings for telemetry
+      const findings: Telemetry.Finding[] = (data.issues ?? []).map(() => ({
+        category: "semantic_issue",
+      }))
+      // altimate_change end
       return {
         title: hasError ? "Semantics: ERROR" : `Semantics: ${data.valid ? "VALID" : `${issueCount} issues`}`,
-        metadata: { success: result.success, valid: data.valid, issue_count: issueCount, ...(error && { error }) },
+        metadata: {
+          success: result.success,
+          valid: data.valid,
+          issue_count: issueCount,
+          has_schema: hasSchema,
+          dialect: "snowflake",
+          ...(error && { error }),
+          ...(findings.length > 0 && { findings }),
+        },
         output: formatSemantics(hasError ? { ...data, error } : data),
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Semantics: ERROR", metadata: { success: false, valid: false, issue_count: 0, error: msg }, output: `Failed: ${msg}` }
+      return { title: "Semantics: ERROR", metadata: { success: false, valid: false, issue_count: 0, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-validate.ts b/packages/opencode/src/altimate/tools/altimate-core-validate.ts
index c96d0ed61..90725b53f 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-validate.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-validate.ts
@@ -1,6 +1,7 @@
 import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
+import type { Telemetry } from "../telemetry"
 
 export const AltimateCoreValidateTool = Tool.define("altimate_core_validate", {
   description:
@@ -11,10 +12,11 @@ export const AltimateCoreValidateTool = Tool.define("altimate_core_validate", {
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
   }),
   async execute(args, ctx) {
-    const noSchema = !args.schema_path && (!args.schema_context || Object.keys(args.schema_context).length === 0)
+    const hasSchema = !!(args.schema_path || (args.schema_context && Object.keys(args.schema_context).length > 0))
+    const noSchema = !hasSchema
     if (noSchema) {
       const error = "No schema provided. Provide schema_context or schema_path so table/column references can be resolved."
-      return { title: "Validate: NO SCHEMA", metadata: { success: false, valid: false, error }, output: `Error: ${error}` }
+      return { title: "Validate: NO SCHEMA", metadata: { success: false, valid: false, has_schema: false, dialect: "snowflake", error }, output: `Error: ${error}` }
     }
     try {
       const result = await Dispatcher.call("altimate_core.validate", {
@@ -24,14 +26,26 @@ export const AltimateCoreValidateTool = Tool.define("altimate_core_validate", {
       })
       const data = (result.data ?? {}) as Record<string, any>
       const error = result.error ?? data.error ?? extractValidationErrors(data)
+      // altimate_change start — sql quality findings for telemetry
+      const findings: Telemetry.Finding[] = (data.errors ?? []).map((err: any) => ({
+        category: classifyValidationError(err.message ?? ""),
+      }))
+      // altimate_change end
       return {
         title: `Validate: ${data.valid ? "VALID" : "INVALID"}`,
-        metadata: { success: result.success, valid: data.valid, ...(error && { error }) },
+        metadata: {
+          success: result.success,
+          valid: data.valid,
+          has_schema: hasSchema,
+          dialect: "snowflake",
+          ...(error && { error }),
+          ...(findings.length > 0 && { findings }),
+        },
         output: formatValidate(data),
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Validate: ERROR", metadata: { success: false, valid: false, error: msg }, output: `Failed: ${msg}` }
+      return { title: "Validate: ERROR", metadata: { success: false, valid: false, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
@@ -44,6 +58,16 @@ function extractValidationErrors(data: Record<string, any>): string | undefined
   return undefined
 }
 
+function classifyValidationError(message: string): string {
+  const lower = message.toLowerCase()
+  // Column check before table — "column not found in table" would match both
+  if (lower.includes("column") && lower.includes("not found")) return "missing_column"
+  if (lower.includes("table") && lower.includes("not found")) return "missing_table"
+  if (lower.includes("syntax")) return "syntax_error"
+  if (lower.includes("type")) return "type_mismatch"
+  return "validation_error"
+}
+
 function formatValidate(data: Record<string, any>): string {
   if (data.error) return `Error: ${data.error}`
   if (data.valid) return "SQL is valid."
diff --git a/packages/opencode/src/altimate/tools/sql-analyze.ts b/packages/opencode/src/altimate/tools/sql-analyze.ts
index bccba80d3..c0d2e211e 100644
--- a/packages/opencode/src/altimate/tools/sql-analyze.ts
+++ b/packages/opencode/src/altimate/tools/sql-analyze.ts
@@ -1,6 +1,7 @@
 import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
+import type { Telemetry } from "../telemetry"
 import type { SqlAnalyzeResult } from "../native/types"
 
 export const SqlAnalyzeTool = Tool.define("sql_analyze", {
@@ -32,13 +33,21 @@ export const SqlAnalyzeTool = Tool.define("sql_analyze", {
       // reported via issues/issue_count). Only treat it as a failure when
       // there's an actual error (e.g. parse failure).
       const isRealFailure = !!result.error
+      // altimate_change start — sql quality findings for telemetry
+      const findings: Telemetry.Finding[] = result.issues.map((issue) => ({
+        category: issue.type,
+      }))
+      // altimate_change end
       return {
         title: `Analyze: ${result.error ? "ERROR" : `${result.issue_count} issue${result.issue_count !== 1 ? "s" : ""}`} [${result.confidence}]`,
         metadata: {
           success: !isRealFailure,
           issueCount: result.issue_count,
           confidence: result.confidence,
+          dialect: args.dialect,
+          has_schema: false,
           ...(result.error && { error: result.error }),
+          ...(findings.length > 0 && { findings }),
         },
         output: formatAnalysis(result),
       }
@@ -46,7 +55,7 @@ export const SqlAnalyzeTool = Tool.define("sql_analyze", {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Analyze: ERROR",
-        metadata: { success: false, issueCount: 0, confidence: "unknown", error: msg },
+        metadata: { success: false, issueCount: 0, confidence: "unknown", dialect: args.dialect, has_schema: false, error: msg },
         output: `Failed to analyze SQL: ${msg}\n\nCheck your connection configuration and try again.`,
       }
     }
diff --git a/packages/opencode/src/tool/tool.ts b/packages/opencode/src/tool/tool.ts
index bde5e3d5e..9075887a6 100644
--- a/packages/opencode/src/tool/tool.ts
+++ b/packages/opencode/src/tool/tool.ts
@@ -158,6 +158,25 @@ export namespace Tool {
                 duration_ms: durationMs,
               })
             }
+            // altimate_change start — emit sql_quality when tools report findings
+            const findings = result.metadata?.findings as Telemetry.Finding[] | undefined
+            if (Array.isArray(findings) && findings.length > 0) {
+              const { by_severity, by_category } = Telemetry.aggregateFindings(findings)
+              Telemetry.track({
+                type: "sql_quality",
+                timestamp: Date.now(),
+                session_id: ctx.sessionID,
+                tool_name: id,
+                tool_category: toolCategory,
+                finding_count: findings.length,
+                by_severity: JSON.stringify(by_severity),
+                by_category: JSON.stringify(by_category),
+                has_schema: result.metadata?.has_schema ?? false,
+                dialect: (result.metadata?.dialect as string) ?? "unknown",
+                duration_ms: durationMs,
+              })
+            }
+            // altimate_change end
           } catch {
             // Telemetry must never break tool execution
           }
diff --git a/packages/opencode/test/altimate/sql-quality-telemetry.test.ts b/packages/opencode/test/altimate/sql-quality-telemetry.test.ts
new file mode 100644
index 000000000..f59d4cddd
--- /dev/null
+++ b/packages/opencode/test/altimate/sql-quality-telemetry.test.ts
@@ -0,0 +1,229 @@
+/**
+ * SQL Quality Telemetry Tests
+ *
+ * Verifies that the `sql_quality` event is emitted with correct aggregations
+ * when tools report findings, and is NOT emitted when there are no findings.
+ */
+
+import { describe, expect, test } from "bun:test"
+import { Telemetry } from "../../src/altimate/telemetry"
+
+// ---------------------------------------------------------------------------
+// 1. aggregateFindings
+// ---------------------------------------------------------------------------
+describe("Telemetry.aggregateFindings", () => {
+  test("aggregates findings by severity and category", () => {
+    const findings: Telemetry.Finding[] = [
+      { category: "missing_table", severity: "error" },
+      { category: "missing_column", severity: "error" },
+      { category: "cartesian_product", severity: "warning" },
+      { category: "missing_table", severity: "error" },
+    ]
+    const result = Telemetry.aggregateFindings(findings)
+    expect(result.by_severity).toEqual({ error: 3, warning: 1 })
+    expect(result.by_category).toEqual({
+      missing_table: 2,
+      missing_column: 1,
+      cartesian_product: 1,
+    })
+  })
+
+  test("returns empty objects for empty findings", () => {
+    const result = Telemetry.aggregateFindings([])
+    expect(result.by_severity).toEqual({})
+    expect(result.by_category).toEqual({})
+  })
+
+  test("handles single finding", () => {
+    const findings: Telemetry.Finding[] = [
+      { category: "syntax_error", severity: "error" },
+    ]
+    const result = Telemetry.aggregateFindings(findings)
+    expect(result.by_severity).toEqual({ error: 1 })
+    expect(result.by_category).toEqual({ syntax_error: 1 })
+  })
+
+  test("handles all same category different severities", () => {
+    const findings: Telemetry.Finding[] = [
+      { category: "select_star", severity: "warning" },
+      { category: "select_star", severity: "info" },
+      { category: "select_star", severity: "error" },
+    ]
+    const result = Telemetry.aggregateFindings(findings)
+    expect(result.by_severity).toEqual({ warning: 1, info: 1, error: 1 })
+    expect(result.by_category).toEqual({ select_star: 3 })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 2. sql_quality event shape validation
+// ---------------------------------------------------------------------------
+describe("sql_quality event shape", () => {
+  test("by_severity and by_category serialize to valid JSON strings", () => {
+    const findings: Telemetry.Finding[] = [
+      { category: "anti_pattern", severity: "warning" },
+      { category: "anti_pattern", severity: "warning" },
+      { category: "performance_issue", severity: "info" },
+    ]
+    const { by_severity, by_category } = Telemetry.aggregateFindings(findings)
+    const severityJson = JSON.stringify(by_severity)
+    const categoryJson = JSON.stringify(by_category)
+
+    // Should round-trip through JSON
+    expect(JSON.parse(severityJson)).toEqual({ warning: 2, info: 1 })
+    expect(JSON.parse(categoryJson)).toEqual({ anti_pattern: 2, performance_issue: 1 })
+  })
+
+  test("aggregated counts match finding_count", () => {
+    const findings: Telemetry.Finding[] = [
+      { category: "a", severity: "error" },
+      { category: "b", severity: "warning" },
+      { category: "c", severity: "error" },
+      { category: "a", severity: "info" },
+    ]
+    const { by_severity, by_category } = Telemetry.aggregateFindings(findings)
+    const totalBySeverity = Object.values(by_severity).reduce((a, b) => a + b, 0)
+    const totalByCategory = Object.values(by_category).reduce((a, b) => a + b, 0)
+    expect(totalBySeverity).toBe(findings.length)
+    expect(totalByCategory).toBe(findings.length)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 3. Finding extraction patterns (validates what tools produce)
+// ---------------------------------------------------------------------------
+describe("tool finding extraction patterns", () => {
+  test("sql_analyze issues map to findings", () => {
+    const issues = [
+      { type: "select_star", severity: "warning", message: "...", recommendation: "...", confidence: "high" },
+      { type: "cartesian_product", severity: "error", message: "...", recommendation: "...", confidence: "high" },
+    ]
+    const findings: Telemetry.Finding[] = issues.map((i) => ({
+      category: i.type,
+      severity: i.severity,
+    }))
+    expect(findings).toEqual([
+      { category: "select_star", severity: "warning" },
+      { category: "cartesian_product", severity: "error" },
+    ])
+  })
+
+  test("validate errors map to findings with classification", () => {
+    const errors = [
+      { message: "Table 'users' not found in schema" },
+      { message: "Column 'email' not found in table 'orders'" },
+      { message: "Syntax error near 'SELCT'" },
+    ]
+    // Simulates classifyValidationError logic (column check before table check)
+    function classify(msg: string): string {
+      const lower = msg.toLowerCase()
+      if (lower.includes("column") && lower.includes("not found")) return "missing_column"
+      if (lower.includes("table") && lower.includes("not found")) return "missing_table"
+      if (lower.includes("syntax")) return "syntax_error"
+      return "validation_error"
+    }
+    const findings: Telemetry.Finding[] = errors.map((e) => ({
+      category: classify(e.message),
+      severity: "error",
+    }))
+    const { by_category } = Telemetry.aggregateFindings(findings)
+    expect(by_category).toEqual({
+      missing_table: 1,
+      missing_column: 1,
+      syntax_error: 1,
+    })
+  })
+
+  test("semantics issues preserve rule/type as category", () => {
+    const issues = [
+      { rule: "cartesian_product", severity: "error", message: "..." },
+      { type: "null_misuse", severity: "warning", message: "..." },
+      { severity: "warning", message: "..." }, // no rule or type
+    ]
+    const findings: Telemetry.Finding[] = issues.map((i: any) => ({
+      category: i.rule ?? i.type ?? "semantic_issue",
+      severity: i.severity ?? "warning",
+    }))
+    expect(findings).toEqual([
+      { category: "cartesian_product", severity: "error" },
+      { category: "null_misuse", severity: "warning" },
+      { category: "semantic_issue", severity: "warning" },
+    ])
+  })
+
+  test("fix tool produces fix_applied and unfixable_error categories", () => {
+    const data = {
+      fixes_applied: [{ description: "Fixed typo" }, { description: "Fixed reference" }],
+      unfixable_errors: [{ error: { message: "Cannot resolve" } }],
+    }
+    const findings: Telemetry.Finding[] = []
+    for (const _ of data.fixes_applied) {
+      findings.push({ category: "fix_applied", severity: "warning" })
+    }
+    for (const _ of data.unfixable_errors) {
+      findings.push({ category: "unfixable_error", severity: "error" })
+    }
+    const { by_category } = Telemetry.aggregateFindings(findings)
+    expect(by_category).toEqual({ fix_applied: 2, unfixable_error: 1 })
+  })
+
+  test("equivalence differences produce findings only when not equivalent", () => {
+    // Equivalent — no findings
+    const equivData = { equivalent: true, differences: [] }
+    const equivFindings: Telemetry.Finding[] = []
+    if (!equivData.equivalent && equivData.differences?.length) {
+      for (const _ of equivData.differences) {
+        equivFindings.push({ category: "equivalence_difference", severity: "warning" })
+      }
+    }
+    expect(equivFindings).toEqual([])
+
+    // Different — findings
+    const diffData = { equivalent: false, differences: [{ description: "..." }, { description: "..." }] }
+    const diffFindings: Telemetry.Finding[] = []
+    if (!diffData.equivalent && diffData.differences?.length) {
+      for (const _ of diffData.differences) {
+        diffFindings.push({ category: "equivalence_difference", severity: "warning" })
+      }
+    }
+    expect(diffFindings.length).toBe(2)
+    const { by_category } = Telemetry.aggregateFindings(diffFindings)
+    expect(by_category).toEqual({ equivalence_difference: 2 })
+  })
+
+  test("correct tool changes produce findings", () => {
+    const data = { changes: [{ description: "a" }, { description: "b" }] }
+    const findings: Telemetry.Finding[] = data.changes.map(() => ({
+      category: "correction_applied",
+      severity: "warning",
+    }))
+    expect(findings.length).toBe(2)
+    const { by_category } = Telemetry.aggregateFindings(findings)
+    expect(by_category).toEqual({ correction_applied: 2 })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 4. No findings = no event
+// ---------------------------------------------------------------------------
+describe("no findings = no sql_quality event", () => {
+  test("empty issues array produces empty findings", () => {
+    const issues: any[] = []
+    const findings: Telemetry.Finding[] = issues.map((i: any) => ({
+      category: i.type,
+      severity: i.severity,
+    }))
+    expect(findings.length).toBe(0)
+    // tool.ts checks: Array.isArray(findings) && findings.length > 0
+    // So no event would be emitted
+  })
+
+  test("valid SQL with no errors produces no findings", () => {
+    const data = { valid: true, errors: [] }
+    const findings: Telemetry.Finding[] = (data.errors ?? []).map(() => ({
+      category: "validation_error",
+      severity: "error",
+    }))
+    expect(findings.length).toBe(0)
+  })
+})

From d930e3c1758595292217f871b021ef64436c3632 Mon Sep 17 00:00:00 2001
From: suryaiyer95 <surya@altimate.ai>
Date: Tue, 24 Mar 2026 12:46:12 -0700
Subject: [PATCH 2/6] refactor: [AI-5975] drop `by_severity` from `sql_quality`
 telemetry, address PR review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Remove `severity` from `Finding` interface — only `category` matters
- Drop `by_severity` from `sql_quality` event type and `aggregateFindings`
- Gate `sql_quality` emission on `!isSoftFailure` to avoid double-counting
  with `core_failure` events (Copilot review feedback)
- Simplify semantics tool: use fixed `"semantic_issue"` category instead of
  dead `issue.rule ?? issue.type` fallback chain (CodeRabbit review feedback)
- Update test header to accurately describe what tests cover
- Fix sql_analyze test to use honest coarse categories (`"lint"`, `"safety"`)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../opencode/src/altimate/telemetry/index.ts  |  16 +--
 packages/opencode/src/tool/tool.ts            |   6 +-
 .../altimate/sql-quality-telemetry.test.ts    | 130 ++++++++----------
 3 files changed, 68 insertions(+), 84 deletions(-)

diff --git a/packages/opencode/src/altimate/telemetry/index.ts b/packages/opencode/src/altimate/telemetry/index.ts
index 8e3502686..1d8563394 100644
--- a/packages/opencode/src/altimate/telemetry/index.ts
+++ b/packages/opencode/src/altimate/telemetry/index.ts
@@ -413,8 +413,6 @@ export namespace Telemetry {
         tool_name: string
         tool_category: string
         finding_count: number
-        /** JSON-encoded Record<string, number> — count per severity level */
-        by_severity: string
         /** JSON-encoded Record<string, number> — count per issue category */
         by_category: string
         has_schema: boolean
@@ -792,24 +790,18 @@ export namespace Telemetry {
   }
 
   // altimate_change start — sql quality telemetry types
-  /** Lightweight finding record for quality telemetry. Only category/severity — never SQL content. */
+  /** Lightweight finding record for quality telemetry. Only category — never SQL content. */
   export interface Finding {
     category: string
-    severity: string
   }
 
-  /** Aggregate an array of findings into counts suitable for the sql_quality event. */
-  export function aggregateFindings(findings: Finding[]): {
-    by_severity: Record<string, number>
-    by_category: Record<string, number>
-  } {
-    const by_severity: Record<string, number> = {}
+  /** Aggregate an array of findings into category counts suitable for the sql_quality event. */
+  export function aggregateFindings(findings: Finding[]): Record<string, number> {
     const by_category: Record<string, number> = {}
     for (const f of findings) {
-      by_severity[f.severity] = (by_severity[f.severity] ?? 0) + 1
       by_category[f.category] = (by_category[f.category] ?? 0) + 1
     }
-    return { by_severity, by_category }
+    return by_category
   }
   // altimate_change end
 
diff --git a/packages/opencode/src/tool/tool.ts b/packages/opencode/src/tool/tool.ts
index 9075887a6..7b3e7495b 100644
--- a/packages/opencode/src/tool/tool.ts
+++ b/packages/opencode/src/tool/tool.ts
@@ -159,9 +159,10 @@ export namespace Tool {
               })
             }
             // altimate_change start — emit sql_quality when tools report findings
+            // Only emit for successful tool runs — soft failures already emit core_failure
             const findings = result.metadata?.findings as Telemetry.Finding[] | undefined
-            if (Array.isArray(findings) && findings.length > 0) {
-              const { by_severity, by_category } = Telemetry.aggregateFindings(findings)
+            if (!isSoftFailure && Array.isArray(findings) && findings.length > 0) {
+              const by_category = Telemetry.aggregateFindings(findings)
               Telemetry.track({
                 type: "sql_quality",
                 timestamp: Date.now(),
@@ -169,7 +170,6 @@ export namespace Tool {
                 tool_name: id,
                 tool_category: toolCategory,
                 finding_count: findings.length,
-                by_severity: JSON.stringify(by_severity),
                 by_category: JSON.stringify(by_category),
                 has_schema: result.metadata?.has_schema ?? false,
                 dialect: (result.metadata?.dialect as string) ?? "unknown",
diff --git a/packages/opencode/test/altimate/sql-quality-telemetry.test.ts b/packages/opencode/test/altimate/sql-quality-telemetry.test.ts
index f59d4cddd..e8155c9fa 100644
--- a/packages/opencode/test/altimate/sql-quality-telemetry.test.ts
+++ b/packages/opencode/test/altimate/sql-quality-telemetry.test.ts
@@ -1,8 +1,10 @@
 /**
  * SQL Quality Telemetry Tests
  *
- * Verifies that the `sql_quality` event is emitted with correct aggregations
- * when tools report findings, and is NOT emitted when there are no findings.
+ * Verifies the aggregation logic, event payload shape, and finding
+ * extraction patterns used for the `sql_quality` telemetry event, and
+ * that scenarios with no findings result in empty finding arrays (the
+ * condition used by tool.ts to decide not to emit the event).
  */
 
 import { describe, expect, test } from "bun:test"
@@ -12,46 +14,42 @@ import { Telemetry } from "../../src/altimate/telemetry"
 // 1. aggregateFindings
 // ---------------------------------------------------------------------------
 describe("Telemetry.aggregateFindings", () => {
-  test("aggregates findings by severity and category", () => {
+  test("aggregates findings by category", () => {
     const findings: Telemetry.Finding[] = [
-      { category: "missing_table", severity: "error" },
-      { category: "missing_column", severity: "error" },
-      { category: "cartesian_product", severity: "warning" },
-      { category: "missing_table", severity: "error" },
+      { category: "missing_table" },
+      { category: "missing_column" },
+      { category: "lint" },
+      { category: "missing_table" },
     ]
     const result = Telemetry.aggregateFindings(findings)
-    expect(result.by_severity).toEqual({ error: 3, warning: 1 })
-    expect(result.by_category).toEqual({
+    expect(result).toEqual({
       missing_table: 2,
       missing_column: 1,
-      cartesian_product: 1,
+      lint: 1,
     })
   })
 
-  test("returns empty objects for empty findings", () => {
+  test("returns empty object for empty findings", () => {
     const result = Telemetry.aggregateFindings([])
-    expect(result.by_severity).toEqual({})
-    expect(result.by_category).toEqual({})
+    expect(result).toEqual({})
   })
 
   test("handles single finding", () => {
     const findings: Telemetry.Finding[] = [
-      { category: "syntax_error", severity: "error" },
+      { category: "syntax_error" },
     ]
     const result = Telemetry.aggregateFindings(findings)
-    expect(result.by_severity).toEqual({ error: 1 })
-    expect(result.by_category).toEqual({ syntax_error: 1 })
+    expect(result).toEqual({ syntax_error: 1 })
   })
 
-  test("handles all same category different severities", () => {
+  test("handles all same category", () => {
     const findings: Telemetry.Finding[] = [
-      { category: "select_star", severity: "warning" },
-      { category: "select_star", severity: "info" },
-      { category: "select_star", severity: "error" },
+      { category: "lint" },
+      { category: "lint" },
+      { category: "lint" },
     ]
     const result = Telemetry.aggregateFindings(findings)
-    expect(result.by_severity).toEqual({ warning: 1, info: 1, error: 1 })
-    expect(result.by_category).toEqual({ select_star: 3 })
+    expect(result).toEqual({ lint: 3 })
   })
 })
 
@@ -59,33 +57,29 @@ describe("Telemetry.aggregateFindings", () => {
 // 2. sql_quality event shape validation
 // ---------------------------------------------------------------------------
 describe("sql_quality event shape", () => {
-  test("by_severity and by_category serialize to valid JSON strings", () => {
+  test("by_category serializes to valid JSON string", () => {
     const findings: Telemetry.Finding[] = [
-      { category: "anti_pattern", severity: "warning" },
-      { category: "anti_pattern", severity: "warning" },
-      { category: "performance_issue", severity: "info" },
+      { category: "lint" },
+      { category: "lint" },
+      { category: "safety" },
     ]
-    const { by_severity, by_category } = Telemetry.aggregateFindings(findings)
-    const severityJson = JSON.stringify(by_severity)
-    const categoryJson = JSON.stringify(by_category)
+    const by_category = Telemetry.aggregateFindings(findings)
+    const json = JSON.stringify(by_category)
 
     // Should round-trip through JSON
-    expect(JSON.parse(severityJson)).toEqual({ warning: 2, info: 1 })
-    expect(JSON.parse(categoryJson)).toEqual({ anti_pattern: 2, performance_issue: 1 })
+    expect(JSON.parse(json)).toEqual({ lint: 2, safety: 1 })
   })
 
   test("aggregated counts match finding_count", () => {
     const findings: Telemetry.Finding[] = [
-      { category: "a", severity: "error" },
-      { category: "b", severity: "warning" },
-      { category: "c", severity: "error" },
-      { category: "a", severity: "info" },
+      { category: "a" },
+      { category: "b" },
+      { category: "c" },
+      { category: "a" },
     ]
-    const { by_severity, by_category } = Telemetry.aggregateFindings(findings)
-    const totalBySeverity = Object.values(by_severity).reduce((a, b) => a + b, 0)
-    const totalByCategory = Object.values(by_category).reduce((a, b) => a + b, 0)
-    expect(totalBySeverity).toBe(findings.length)
-    expect(totalByCategory).toBe(findings.length)
+    const by_category = Telemetry.aggregateFindings(findings)
+    const total = Object.values(by_category).reduce((a, b) => a + b, 0)
+    expect(total).toBe(findings.length)
   })
 })
 
@@ -93,18 +87,18 @@ describe("sql_quality event shape", () => {
 // 3. Finding extraction patterns (validates what tools produce)
 // ---------------------------------------------------------------------------
 describe("tool finding extraction patterns", () => {
-  test("sql_analyze issues map to findings", () => {
+  test("sql_analyze issues map to findings via issue.type", () => {
+    // issue.type is coarse: "lint", "semantic", "safety"
     const issues = [
-      { type: "select_star", severity: "warning", message: "...", recommendation: "...", confidence: "high" },
-      { type: "cartesian_product", severity: "error", message: "...", recommendation: "...", confidence: "high" },
+      { type: "lint", severity: "warning", message: "...", recommendation: "...", confidence: "high" },
+      { type: "safety", severity: "high", message: "...", recommendation: "...", confidence: "high" },
     ]
     const findings: Telemetry.Finding[] = issues.map((i) => ({
       category: i.type,
-      severity: i.severity,
     }))
     expect(findings).toEqual([
-      { category: "select_star", severity: "warning" },
-      { category: "cartesian_product", severity: "error" },
+      { category: "lint" },
+      { category: "safety" },
     ])
   })
 
@@ -124,9 +118,8 @@ describe("tool finding extraction patterns", () => {
     }
     const findings: Telemetry.Finding[] = errors.map((e) => ({
       category: classify(e.message),
-      severity: "error",
     }))
-    const { by_category } = Telemetry.aggregateFindings(findings)
+    const by_category = Telemetry.aggregateFindings(findings)
     expect(by_category).toEqual({
       missing_table: 1,
       missing_column: 1,
@@ -134,21 +127,23 @@ describe("tool finding extraction patterns", () => {
     })
   })
 
-  test("semantics issues preserve rule/type as category", () => {
+  test("semantics issues all map to semantic_issue category", () => {
+    // Semantic findings don't have rule/type — always "semantic_issue"
     const issues = [
-      { rule: "cartesian_product", severity: "error", message: "..." },
-      { type: "null_misuse", severity: "warning", message: "..." },
-      { severity: "warning", message: "..." }, // no rule or type
+      { severity: "error", message: "..." },
+      { severity: "warning", message: "..." },
+      { severity: "warning", message: "..." },
     ]
-    const findings: Telemetry.Finding[] = issues.map((i: any) => ({
-      category: i.rule ?? i.type ?? "semantic_issue",
-      severity: i.severity ?? "warning",
+    const findings: Telemetry.Finding[] = issues.map(() => ({
+      category: "semantic_issue",
     }))
     expect(findings).toEqual([
-      { category: "cartesian_product", severity: "error" },
-      { category: "null_misuse", severity: "warning" },
-      { category: "semantic_issue", severity: "warning" },
+      { category: "semantic_issue" },
+      { category: "semantic_issue" },
+      { category: "semantic_issue" },
     ])
+    const by_category = Telemetry.aggregateFindings(findings)
+    expect(by_category).toEqual({ semantic_issue: 3 })
   })
 
   test("fix tool produces fix_applied and unfixable_error categories", () => {
@@ -158,12 +153,12 @@ describe("tool finding extraction patterns", () => {
     }
     const findings: Telemetry.Finding[] = []
     for (const _ of data.fixes_applied) {
-      findings.push({ category: "fix_applied", severity: "warning" })
+      findings.push({ category: "fix_applied" })
     }
     for (const _ of data.unfixable_errors) {
-      findings.push({ category: "unfixable_error", severity: "error" })
+      findings.push({ category: "unfixable_error" })
     }
-    const { by_category } = Telemetry.aggregateFindings(findings)
+    const by_category = Telemetry.aggregateFindings(findings)
     expect(by_category).toEqual({ fix_applied: 2, unfixable_error: 1 })
   })
 
@@ -173,7 +168,7 @@ describe("tool finding extraction patterns", () => {
     const equivFindings: Telemetry.Finding[] = []
     if (!equivData.equivalent && equivData.differences?.length) {
       for (const _ of equivData.differences) {
-        equivFindings.push({ category: "equivalence_difference", severity: "warning" })
+        equivFindings.push({ category: "equivalence_difference" })
       }
     }
     expect(equivFindings).toEqual([])
@@ -183,11 +178,11 @@ describe("tool finding extraction patterns", () => {
     const diffFindings: Telemetry.Finding[] = []
     if (!diffData.equivalent && diffData.differences?.length) {
       for (const _ of diffData.differences) {
-        diffFindings.push({ category: "equivalence_difference", severity: "warning" })
+        diffFindings.push({ category: "equivalence_difference" })
       }
     }
     expect(diffFindings.length).toBe(2)
-    const { by_category } = Telemetry.aggregateFindings(diffFindings)
+    const by_category = Telemetry.aggregateFindings(diffFindings)
     expect(by_category).toEqual({ equivalence_difference: 2 })
   })
 
@@ -195,10 +190,9 @@ describe("tool finding extraction patterns", () => {
     const data = { changes: [{ description: "a" }, { description: "b" }] }
     const findings: Telemetry.Finding[] = data.changes.map(() => ({
       category: "correction_applied",
-      severity: "warning",
     }))
     expect(findings.length).toBe(2)
-    const { by_category } = Telemetry.aggregateFindings(findings)
+    const by_category = Telemetry.aggregateFindings(findings)
     expect(by_category).toEqual({ correction_applied: 2 })
   })
 })
@@ -211,10 +205,9 @@ describe("no findings = no sql_quality event", () => {
     const issues: any[] = []
     const findings: Telemetry.Finding[] = issues.map((i: any) => ({
       category: i.type,
-      severity: i.severity,
     }))
     expect(findings.length).toBe(0)
-    // tool.ts checks: Array.isArray(findings) && findings.length > 0
+    // tool.ts guards: !isSoftFailure && Array.isArray(findings) && findings.length > 0
     // So no event would be emitted
   })
 
@@ -222,7 +215,6 @@ describe("no findings = no sql_quality event", () => {
     const data = { valid: true, errors: [] }
     const findings: Telemetry.Finding[] = (data.errors ?? []).map(() => ({
       category: "validation_error",
-      severity: "error",
     }))
     expect(findings.length).toBe(0)
   })

From 38a227aebdad41856027dc879f41e5c7b7702e51 Mon Sep 17 00:00:00 2001
From: suryaiyer95 <surya@altimate.ai>
Date: Tue, 24 Mar 2026 12:58:48 -0700
Subject: [PATCH 3/6] refactor: [AI-5975] drop `by_severity` from `sql_quality`
 telemetry, address PR review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Remove `severity` from `Finding` interface — only `category` matters
- Drop `by_severity` from `sql_quality` event type and `aggregateFindings`
- Gate `sql_quality` emission on `!isSoftFailure` to avoid double-counting
  with `core_failure` events (Copilot review feedback)
- Simplify semantics tool: use fixed `"semantic_issue"` category instead of
  dead `issue.rule ?? issue.type` fallback chain (CodeRabbit review feedback)
- Update test header to accurately describe what tests cover
- Fix sql_analyze test to use honest coarse categories (`"lint"`, `"safety"`)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../src/altimate/native/sql/register.ts       |   1 +
 .../opencode/src/altimate/native/types.ts     |   1 +
 .../src/altimate/tools/altimate-core-check.ts |  27 +++-
 .../src/altimate/tools/impact-analysis.ts     |  18 ++-
 .../src/altimate/tools/schema-diff.ts         |  11 +-
 .../src/altimate/tools/sql-analyze.ts         |   2 +-
 .../src/altimate/tools/sql-optimize.ts        |  13 +-
 .../altimate/sql-quality-telemetry.test.ts    | 121 +++++++++++++++++-
 8 files changed, 182 insertions(+), 12 deletions(-)

diff --git a/packages/opencode/src/altimate/native/sql/register.ts b/packages/opencode/src/altimate/native/sql/register.ts
index caae23c83..c65911127 100644
--- a/packages/opencode/src/altimate/native/sql/register.ts
+++ b/packages/opencode/src/altimate/native/sql/register.ts
@@ -45,6 +45,7 @@ register("sql.analyze", async (params) => {
     for (const f of lint.findings ?? []) {
       issues.push({
         type: "lint",
+        rule: f.rule,
         severity: f.severity ?? "warning",
         message: f.message ?? f.rule ?? "",
         recommendation: f.suggestion ?? "",
diff --git a/packages/opencode/src/altimate/native/types.ts b/packages/opencode/src/altimate/native/types.ts
index dc6108393..8d0f3978f 100644
--- a/packages/opencode/src/altimate/native/types.ts
+++ b/packages/opencode/src/altimate/native/types.ts
@@ -30,6 +30,7 @@ export interface SqlAnalyzeParams {
 
 export interface SqlAnalyzeIssue {
   type: string
+  rule?: string
   severity: string
   message: string
   recommendation: string
diff --git a/packages/opencode/src/altimate/tools/altimate-core-check.ts b/packages/opencode/src/altimate/tools/altimate-core-check.ts
index 3785888f4..1a2f20e19 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-check.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-check.ts
@@ -1,6 +1,7 @@
 import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
+import type { Telemetry } from "../telemetry"
 
 export const AltimateCoreCheckTool = Tool.define("altimate_core_check", {
   description:
@@ -11,6 +12,7 @@ export const AltimateCoreCheckTool = Tool.define("altimate_core_check", {
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
   }),
   async execute(args, ctx) {
+    const hasSchema = !!(args.schema_path || (args.schema_context && Object.keys(args.schema_context).length > 0))
     try {
       const result = await Dispatcher.call("altimate_core.check", {
         sql: args.sql,
@@ -19,14 +21,35 @@ export const AltimateCoreCheckTool = Tool.define("altimate_core_check", {
       })
       const data = (result.data ?? {}) as Record<string, any>
       const error = result.error ?? data.error
+      // altimate_change start — sql quality findings for telemetry
+      const findings: Telemetry.Finding[] = []
+      for (const err of data.validation?.errors ?? []) {
+        findings.push({ category: "validation_error" })
+      }
+      for (const f of data.lint?.findings ?? []) {
+        findings.push({ category: f.rule ?? "lint" })
+      }
+      for (const t of data.safety?.threats ?? []) {
+        findings.push({ category: t.type ?? "safety_threat" })
+      }
+      for (const p of data.pii?.findings ?? []) {
+        findings.push({ category: "pii_detected" })
+      }
+      // altimate_change end
       return {
         title: `Check: ${formatCheckTitle(data)}`,
-        metadata: { success: result.success, ...(error && { error }) },
+        metadata: {
+          success: result.success,
+          has_schema: hasSchema,
+          dialect: "snowflake",
+          ...(error && { error }),
+          ...(findings.length > 0 && { findings }),
+        },
         output: formatCheck(data),
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Check: ERROR", metadata: { success: false, error: msg }, output: `Failed: ${msg}` }
+      return { title: "Check: ERROR", metadata: { success: false, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/impact-analysis.ts b/packages/opencode/src/altimate/tools/impact-analysis.ts
index b219678a2..f1a1c7bd0 100644
--- a/packages/opencode/src/altimate/tools/impact-analysis.ts
+++ b/packages/opencode/src/altimate/tools/impact-analysis.ts
@@ -5,6 +5,7 @@
 import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
+import type { Telemetry } from "../telemetry"
 
 export const ImpactAnalysisTool = Tool.define("impact_analysis", {
   description: [
@@ -129,6 +130,18 @@ export const ImpactAnalysisTool = Tool.define("impact_analysis", {
               ? "MEDIUM"
               : "HIGH"
 
+      // altimate_change start — sql quality findings for telemetry
+      const findings: Telemetry.Finding[] = []
+      if (totalAffected > 0) {
+        findings.push({ category: `impact_${severity.toLowerCase()}` })
+        for (const d of direct) {
+          findings.push({ category: "impact_direct_dependent" })
+        }
+        for (const t of transitive) {
+          findings.push({ category: "impact_transitive_dependent" })
+        }
+      }
+      // altimate_change end
       return {
         title: `Impact: ${severity} — ${totalAffected} downstream model${totalAffected !== 1 ? "s" : ""} affected`,
         metadata: {
@@ -138,6 +151,9 @@ export const ImpactAnalysisTool = Tool.define("impact_analysis", {
           transitive_count: transitive.length,
           test_count: affectedTestCount,
           column_impact: columnImpact.length,
+          has_schema: false,
+          dialect: args.dialect,
+          ...(findings.length > 0 && { findings }),
         },
         output,
       }
@@ -145,7 +161,7 @@ export const ImpactAnalysisTool = Tool.define("impact_analysis", {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Impact: ERROR",
-        metadata: { success: false, error: msg },
+        metadata: { success: false, has_schema: false, dialect: args.dialect, error: msg },
         output: `Failed to analyze impact: ${msg}\n\nEnsure the dbt manifest exists (run \`dbt compile\`) and the dispatcher is running.`,
       }
     }
diff --git a/packages/opencode/src/altimate/tools/schema-diff.ts b/packages/opencode/src/altimate/tools/schema-diff.ts
index a1a42362b..68feab287 100644
--- a/packages/opencode/src/altimate/tools/schema-diff.ts
+++ b/packages/opencode/src/altimate/tools/schema-diff.ts
@@ -2,6 +2,7 @@ import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
 import type { SchemaDiffResult, ColumnChange } from "../native/types"
+import type { Telemetry } from "../telemetry"
 
 export const SchemaDiffTool = Tool.define("schema_diff", {
   description:
@@ -31,6 +32,11 @@ export const SchemaDiffTool = Tool.define("schema_diff", {
       const changeCount = result.changes.length
       const breakingCount = result.changes.filter((c) => c.severity === "breaking").length
 
+      // altimate_change start — sql quality findings for telemetry
+      const findings: Telemetry.Finding[] = result.changes.map((c) => ({
+        category: c.change_type ?? (c.severity === "breaking" ? "breaking_change" : "schema_change"),
+      }))
+      // altimate_change end
       return {
         title: `Schema Diff: ${result.success ? `${changeCount} change${changeCount !== 1 ? "s" : ""}${breakingCount > 0 ? ` (${breakingCount} BREAKING)` : ""}` : "PARSE ERROR"}`,
         metadata: {
@@ -38,6 +44,9 @@ export const SchemaDiffTool = Tool.define("schema_diff", {
           changeCount,
           breakingCount,
           hasBreakingChanges: result.has_breaking_changes,
+          has_schema: false,
+          dialect: args.dialect,
+          ...(findings.length > 0 && { findings }),
         },
         output: formatSchemaDiff(result),
       }
@@ -45,7 +54,7 @@ export const SchemaDiffTool = Tool.define("schema_diff", {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Schema Diff: ERROR",
-        metadata: { success: false, changeCount: 0, breakingCount: 0, hasBreakingChanges: false, error: msg },
+        metadata: { success: false, changeCount: 0, breakingCount: 0, hasBreakingChanges: false, has_schema: false, dialect: args.dialect, error: msg },
         output: `Failed to diff schema: ${msg}\n\nCheck your connection configuration and try again.`,
       }
     }
diff --git a/packages/opencode/src/altimate/tools/sql-analyze.ts b/packages/opencode/src/altimate/tools/sql-analyze.ts
index c0d2e211e..42050d29d 100644
--- a/packages/opencode/src/altimate/tools/sql-analyze.ts
+++ b/packages/opencode/src/altimate/tools/sql-analyze.ts
@@ -35,7 +35,7 @@ export const SqlAnalyzeTool = Tool.define("sql_analyze", {
       const isRealFailure = !!result.error
       // altimate_change start — sql quality findings for telemetry
       const findings: Telemetry.Finding[] = result.issues.map((issue) => ({
-        category: issue.type,
+        category: issue.rule ?? issue.type,
       }))
       // altimate_change end
       return {
diff --git a/packages/opencode/src/altimate/tools/sql-optimize.ts b/packages/opencode/src/altimate/tools/sql-optimize.ts
index bb8fe9163..3d1be06ef 100644
--- a/packages/opencode/src/altimate/tools/sql-optimize.ts
+++ b/packages/opencode/src/altimate/tools/sql-optimize.ts
@@ -2,6 +2,7 @@ import z from "zod"
 import { Tool } from "../../tool/tool"
 import { Dispatcher } from "../native"
 import type { SqlOptimizeResult, SqlOptimizeSuggestion, SqlAntiPattern } from "../native/types"
+import type { Telemetry } from "../telemetry"
 
 export const SqlOptimizeTool = Tool.define("sql_optimize", {
   description:
@@ -31,6 +32,13 @@ export const SqlOptimizeTool = Tool.define("sql_optimize", {
       const suggestionCount = result.suggestions.length
       const antiPatternCount = result.anti_patterns.length
 
+      // altimate_change start — sql quality findings for telemetry
+      const hasSchema = !!(args.schema_context && Object.keys(args.schema_context).length > 0)
+      const findings: Telemetry.Finding[] = [
+        ...result.anti_patterns.map((ap) => ({ category: ap.type ?? "anti_pattern" })),
+        ...result.suggestions.map((s) => ({ category: s.type ?? "optimization_suggestion" })),
+      ]
+      // altimate_change end
       return {
         title: `Optimize: ${result.success ? `${suggestionCount} suggestion${suggestionCount !== 1 ? "s" : ""}, ${antiPatternCount} anti-pattern${antiPatternCount !== 1 ? "s" : ""}` : "PARSE ERROR"} [${result.confidence}]`,
         metadata: {
@@ -39,6 +47,9 @@ export const SqlOptimizeTool = Tool.define("sql_optimize", {
           antiPatternCount,
           hasOptimizedSql: !!result.optimized_sql,
           confidence: result.confidence,
+          has_schema: hasSchema,
+          dialect: args.dialect,
+          ...(findings.length > 0 && { findings }),
         },
         output: formatOptimization(result),
       }
@@ -46,7 +57,7 @@ export const SqlOptimizeTool = Tool.define("sql_optimize", {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Optimize: ERROR",
-        metadata: { success: false, suggestionCount: 0, antiPatternCount: 0, hasOptimizedSql: false, confidence: "unknown", error: msg },
+        metadata: { success: false, suggestionCount: 0, antiPatternCount: 0, hasOptimizedSql: false, confidence: "unknown", has_schema: false, dialect: args.dialect, error: msg },
         output: `Failed to optimize SQL: ${msg}\n\nCheck your connection configuration and try again.`,
       }
     }
diff --git a/packages/opencode/test/altimate/sql-quality-telemetry.test.ts b/packages/opencode/test/altimate/sql-quality-telemetry.test.ts
index e8155c9fa..46e5ca831 100644
--- a/packages/opencode/test/altimate/sql-quality-telemetry.test.ts
+++ b/packages/opencode/test/altimate/sql-quality-telemetry.test.ts
@@ -87,17 +87,21 @@ describe("sql_quality event shape", () => {
 // 3. Finding extraction patterns (validates what tools produce)
 // ---------------------------------------------------------------------------
 describe("tool finding extraction patterns", () => {
-  test("sql_analyze issues map to findings via issue.type", () => {
-    // issue.type is coarse: "lint", "semantic", "safety"
+  test("sql_analyze issues use rule for lint, fall back to type otherwise", () => {
+    // Lint issues have rule (e.g. "select_star"), semantic/safety don't
     const issues = [
-      { type: "lint", severity: "warning", message: "...", recommendation: "...", confidence: "high" },
+      { type: "lint", rule: "select_star", severity: "warning", message: "...", recommendation: "...", confidence: "high" },
+      { type: "lint", rule: "filter_has_func", severity: "warning", message: "...", recommendation: "...", confidence: "high" },
+      { type: "semantic", severity: "warning", message: "...", recommendation: "...", confidence: "medium" },
       { type: "safety", severity: "high", message: "...", recommendation: "...", confidence: "high" },
     ]
-    const findings: Telemetry.Finding[] = issues.map((i) => ({
-      category: i.type,
+    const findings: Telemetry.Finding[] = issues.map((i: any) => ({
+      category: i.rule ?? i.type,
     }))
     expect(findings).toEqual([
-      { category: "lint" },
+      { category: "select_star" },
+      { category: "filter_has_func" },
+      { category: "semantic" },
       { category: "safety" },
     ])
   })
@@ -195,6 +199,111 @@ describe("tool finding extraction patterns", () => {
     const by_category = Telemetry.aggregateFindings(findings)
     expect(by_category).toEqual({ correction_applied: 2 })
   })
+
+  test("check tool aggregates validation, lint, safety, and pii findings", () => {
+    const data = {
+      validation: { valid: false, errors: [{ message: "syntax error" }] },
+      lint: { clean: false, findings: [{ rule: "select_star", severity: "warning", message: "..." }, { rule: "filter_has_func", severity: "warning", message: "..." }] },
+      safety: { safe: false, threats: [{ type: "sql_injection", severity: "high", description: "..." }] },
+      pii: { findings: [{ column: "email", category: "email", confidence: "high" }] },
+    }
+    const findings: Telemetry.Finding[] = []
+    for (const _ of data.validation.errors) findings.push({ category: "validation_error" })
+    for (const f of data.lint.findings) findings.push({ category: f.rule ?? "lint" })
+    for (const t of data.safety.threats) findings.push({ category: (t as any).type ?? "safety_threat" })
+    for (const _ of data.pii.findings) findings.push({ category: "pii_detected" })
+    const by_category = Telemetry.aggregateFindings(findings)
+    expect(by_category).toEqual({
+      validation_error: 1,
+      select_star: 1,
+      filter_has_func: 1,
+      sql_injection: 1,
+      pii_detected: 1,
+    })
+  })
+
+  test("policy violations use rule as category", () => {
+    const data = {
+      pass: false,
+      violations: [
+        { rule: "no_select_star", severity: "error", message: "..." },
+        { rule: "require_where", severity: "error", message: "..." },
+        { severity: "warning", message: "..." }, // no rule
+      ],
+    }
+    const findings: Telemetry.Finding[] = data.violations.map((v: any) => ({
+      category: v.rule ?? "policy_violation",
+    }))
+    const by_category = Telemetry.aggregateFindings(findings)
+    expect(by_category).toEqual({
+      no_select_star: 1,
+      require_where: 1,
+      policy_violation: 1,
+    })
+  })
+
+  test("schema diff uses change_type as category", () => {
+    const changes = [
+      { severity: "breaking", change_type: "column_dropped", message: "..." },
+      { severity: "warning", change_type: "type_changed", message: "..." },
+      { severity: "info", change_type: "column_added", message: "..." },
+      { severity: "breaking", change_type: "column_dropped", message: "..." },
+    ]
+    const findings: Telemetry.Finding[] = changes.map((c) => ({
+      category: c.change_type ?? (c.severity === "breaking" ? "breaking_change" : "schema_change"),
+    }))
+    const by_category = Telemetry.aggregateFindings(findings)
+    expect(by_category).toEqual({
+      column_dropped: 2,
+      type_changed: 1,
+      column_added: 1,
+    })
+  })
+
+  test("optimize tool combines anti-patterns and suggestions", () => {
+    const result = {
+      anti_patterns: [
+        { type: "cartesian_product", severity: "error", message: "..." },
+        { type: "select_star", severity: "warning", message: "..." },
+      ],
+      suggestions: [
+        { type: "cte_elimination", impact: "high", description: "..." },
+      ],
+    }
+    const findings: Telemetry.Finding[] = [
+      ...result.anti_patterns.map((ap) => ({ category: ap.type ?? "anti_pattern" })),
+      ...result.suggestions.map((s) => ({ category: s.type ?? "optimization_suggestion" })),
+    ]
+    const by_category = Telemetry.aggregateFindings(findings)
+    expect(by_category).toEqual({
+      cartesian_product: 1,
+      select_star: 1,
+      cte_elimination: 1,
+    })
+  })
+
+  test("impact analysis produces findings only when downstream affected", () => {
+    // No impact — no findings
+    const safeFindings: Telemetry.Finding[] = []
+    expect(safeFindings).toEqual([])
+
+    // High impact — findings per dependent
+    const findings: Telemetry.Finding[] = []
+    const direct = [{ name: "model_a" }, { name: "model_b" }]
+    const transitive = [{ name: "model_c" }]
+    const totalAffected = direct.length + transitive.length
+    if (totalAffected > 0) {
+      findings.push({ category: "impact_medium" })
+      for (const _ of direct) findings.push({ category: "impact_direct_dependent" })
+      for (const _ of transitive) findings.push({ category: "impact_transitive_dependent" })
+    }
+    const by_category = Telemetry.aggregateFindings(findings)
+    expect(by_category).toEqual({
+      impact_medium: 1,
+      impact_direct_dependent: 2,
+      impact_transitive_dependent: 1,
+    })
+  })
 })
 
 // ---------------------------------------------------------------------------

From 38914b5672b930106b190f8dbb85ebb35001a283 Mon Sep 17 00:00:00 2001
From: suryaiyer95 <surya@altimate.ai>
Date: Tue, 24 Mar 2026 14:42:29 -0700
Subject: [PATCH 4/6] fix: [AI-5975] decouple `metadata.success` from domain
 outcomes in finding tools
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Five tools were suppressing `sql_quality` telemetry because their
`metadata.success` tracked domain outcomes (SQL invalid, policy violated,
queries not equivalent) rather than engine execution success.

`tool.ts` gate: `!isSoftFailure && findings.length > 0`
- `isSoftFailure = metadata.success === false`
- Tools that found issues had `success: false` → findings suppressed

Fix: set `success: true` when the engine ran (even if it found problems).
Domain outcomes remain in dedicated fields (`valid`, `pass`, `equivalent`,
`fixed`). Only catch blocks set `success: false` (real engine crashes).

Affected tools:
- `altimate_core_validate` — validation errors now emit `sql_quality`
- `altimate_core_semantics` — semantic issues now emit `sql_quality`
- `altimate_core_policy` — policy violations now emit `sql_quality`
- `altimate_core_equivalence` — differences now emit `sql_quality`
- `altimate_core_fix` — unfixable errors now emit `sql_quality`

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 packages/opencode/src/altimate/tools/altimate-core-policy.ts    | 2 +-
 packages/opencode/src/altimate/tools/altimate-core-semantics.ts | 2 +-
 packages/opencode/src/altimate/tools/altimate-core-validate.ts  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/opencode/src/altimate/tools/altimate-core-policy.ts b/packages/opencode/src/altimate/tools/altimate-core-policy.ts
index a69a9739c..772c9a048 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-policy.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-policy.ts
@@ -31,7 +31,7 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
       return {
         title: `Policy: ${data.pass ? "PASS" : "VIOLATIONS FOUND"}`,
         metadata: {
-          success: result.success,
+          success: true, // engine ran — violations are findings, not failures
           pass: data.pass,
           has_schema: hasSchema,
           dialect: "snowflake",
diff --git a/packages/opencode/src/altimate/tools/altimate-core-semantics.ts b/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
index 7ced0dfde..d0f694308 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
@@ -35,7 +35,7 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
       return {
         title: hasError ? "Semantics: ERROR" : `Semantics: ${data.valid ? "VALID" : `${issueCount} issues`}`,
         metadata: {
-          success: result.success,
+          success: true, // engine ran — semantic issues are findings, not failures
           valid: data.valid,
           issue_count: issueCount,
           has_schema: hasSchema,
diff --git a/packages/opencode/src/altimate/tools/altimate-core-validate.ts b/packages/opencode/src/altimate/tools/altimate-core-validate.ts
index 90725b53f..590ad0d41 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-validate.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-validate.ts
@@ -34,7 +34,7 @@ export const AltimateCoreValidateTool = Tool.define("altimate_core_validate", {
       return {
         title: `Validate: ${data.valid ? "VALID" : "INVALID"}`,
         metadata: {
-          success: result.success,
+          success: true, // engine ran — validation errors are findings, not failures
           valid: data.valid,
           has_schema: hasSchema,
           dialect: "snowflake",

From 7029201a750125854d6648969bd02eb8386eeead Mon Sep 17 00:00:00 2001
From: suryaiyer95 <surya@altimate.ai>
Date: Tue, 24 Mar 2026 15:20:12 -0700
Subject: [PATCH 5/6] refactor: [AI-5975] remove hardcoded `dialect:
 "snowflake"` from core tools

- Remove `dialect` from metadata in 8 altimate-core/impact tools that don't
  accept a dialect parameter (it was always hardcoded to "snowflake")
- Make `dialect` optional in `sql_quality` telemetry event type
- Only emit `dialect` when the tool actually provides it (sql-analyze,
  sql-optimize, schema-diff still do via `args.dialect`)
- Tracked as #455 for adding proper dialect parameter support later

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 packages/opencode/src/altimate/telemetry/index.ts            | 2 +-
 packages/opencode/src/altimate/tools/altimate-core-check.ts  | 3 +--
 .../opencode/src/altimate/tools/altimate-core-correct.ts     | 3 +--
 .../opencode/src/altimate/tools/altimate-core-equivalence.ts | 5 ++---
 packages/opencode/src/altimate/tools/altimate-core-fix.ts    | 3 +--
 packages/opencode/src/altimate/tools/altimate-core-policy.ts | 3 +--
 .../opencode/src/altimate/tools/altimate-core-semantics.ts   | 5 ++---
 .../opencode/src/altimate/tools/altimate-core-validate.ts    | 5 ++---
 packages/opencode/src/altimate/tools/impact-analysis.ts      | 3 +--
 packages/opencode/src/tool/tool.ts                           | 2 +-
 10 files changed, 13 insertions(+), 21 deletions(-)

diff --git a/packages/opencode/src/altimate/telemetry/index.ts b/packages/opencode/src/altimate/telemetry/index.ts
index 1d8563394..da7cac4bb 100644
--- a/packages/opencode/src/altimate/telemetry/index.ts
+++ b/packages/opencode/src/altimate/telemetry/index.ts
@@ -416,7 +416,7 @@ export namespace Telemetry {
         /** JSON-encoded Record<string, number> — count per issue category */
         by_category: string
         has_schema: boolean
-        dialect: string
+        dialect?: string
         duration_ms: number
       }
     // altimate_change end
diff --git a/packages/opencode/src/altimate/tools/altimate-core-check.ts b/packages/opencode/src/altimate/tools/altimate-core-check.ts
index 1a2f20e19..6678fcb33 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-check.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-check.ts
@@ -41,7 +41,6 @@ export const AltimateCoreCheckTool = Tool.define("altimate_core_check", {
         metadata: {
           success: result.success,
           has_schema: hasSchema,
-          dialect: "snowflake",
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
         },
@@ -49,7 +48,7 @@ export const AltimateCoreCheckTool = Tool.define("altimate_core_check", {
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Check: ERROR", metadata: { success: false, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
+      return { title: "Check: ERROR", metadata: { success: false, has_schema: hasSchema, error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-correct.ts b/packages/opencode/src/altimate/tools/altimate-core-correct.ts
index 76cec5245..5e3050797 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-correct.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-correct.ts
@@ -32,7 +32,6 @@ export const AltimateCoreCorrectTool = Tool.define("altimate_core_correct", {
           success: result.success,
           iterations: data.iterations,
           has_schema: hasSchema,
-          dialect: "snowflake",
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
         },
@@ -40,7 +39,7 @@ export const AltimateCoreCorrectTool = Tool.define("altimate_core_correct", {
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Correct: ERROR", metadata: { success: false, iterations: 0, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
+      return { title: "Correct: ERROR", metadata: { success: false, iterations: 0, has_schema: hasSchema, error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-equivalence.ts b/packages/opencode/src/altimate/tools/altimate-core-equivalence.ts
index 5a83e03b4..4584ece6b 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-equivalence.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-equivalence.ts
@@ -16,7 +16,7 @@ export const AltimateCoreEquivalenceTool = Tool.define("altimate_core_equivalenc
     const hasSchema = !!(args.schema_path || (args.schema_context && Object.keys(args.schema_context).length > 0))
     if (!hasSchema) {
       const error = "No schema provided. Provide schema_context or schema_path so table/column references can be resolved."
-      return { title: "Equivalence: NO SCHEMA", metadata: { success: false, equivalent: false, has_schema: false, dialect: "snowflake", error }, output: `Error: ${error}` }
+      return { title: "Equivalence: NO SCHEMA", metadata: { success: false, equivalent: false, has_schema: false, error }, output: `Error: ${error}` }
     }
     try {
       const result = await Dispatcher.call("altimate_core.equivalence", {
@@ -44,7 +44,6 @@ export const AltimateCoreEquivalenceTool = Tool.define("altimate_core_equivalenc
           success: !isRealFailure,
           equivalent: data.equivalent,
           has_schema: hasSchema,
-          dialect: "snowflake",
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
         },
@@ -52,7 +51,7 @@ export const AltimateCoreEquivalenceTool = Tool.define("altimate_core_equivalenc
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Equivalence: ERROR", metadata: { success: false, equivalent: false, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
+      return { title: "Equivalence: ERROR", metadata: { success: false, equivalent: false, has_schema: hasSchema, error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-fix.ts b/packages/opencode/src/altimate/tools/altimate-core-fix.ts
index ebd1db596..b2ce392c9 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-fix.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-fix.ts
@@ -41,7 +41,6 @@ export const AltimateCoreFixTool = Tool.define("altimate_core_fix", {
           success,
           fixed: !!data.fixed_sql,
           has_schema: hasSchema,
-          dialect: "snowflake",
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
         },
@@ -49,7 +48,7 @@ export const AltimateCoreFixTool = Tool.define("altimate_core_fix", {
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Fix: ERROR", metadata: { success: false, fixed: false, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
+      return { title: "Fix: ERROR", metadata: { success: false, fixed: false, has_schema: hasSchema, error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-policy.ts b/packages/opencode/src/altimate/tools/altimate-core-policy.ts
index 772c9a048..65ab85078 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-policy.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-policy.ts
@@ -34,7 +34,6 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
           success: true, // engine ran — violations are findings, not failures
           pass: data.pass,
           has_schema: hasSchema,
-          dialect: "snowflake",
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
         },
@@ -42,7 +41,7 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Policy: ERROR", metadata: { success: false, pass: false, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
+      return { title: "Policy: ERROR", metadata: { success: false, pass: false, has_schema: hasSchema, error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-semantics.ts b/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
index d0f694308..a11ac00e5 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
@@ -15,7 +15,7 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
     const hasSchema = !!(args.schema_path || (args.schema_context && Object.keys(args.schema_context).length > 0))
     if (!hasSchema) {
       const error = "No schema provided. Provide schema_context or schema_path so table/column references can be resolved."
-      return { title: "Semantics: NO SCHEMA", metadata: { success: false, valid: false, issue_count: 0, has_schema: false, dialect: "snowflake", error }, output: `Error: ${error}` }
+      return { title: "Semantics: NO SCHEMA", metadata: { success: false, valid: false, issue_count: 0, has_schema: false, error }, output: `Error: ${error}` }
     }
     try {
       const result = await Dispatcher.call("altimate_core.semantics", {
@@ -39,7 +39,6 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
           valid: data.valid,
           issue_count: issueCount,
           has_schema: hasSchema,
-          dialect: "snowflake",
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
         },
@@ -47,7 +46,7 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Semantics: ERROR", metadata: { success: false, valid: false, issue_count: 0, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
+      return { title: "Semantics: ERROR", metadata: { success: false, valid: false, issue_count: 0, has_schema: hasSchema, error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/altimate-core-validate.ts b/packages/opencode/src/altimate/tools/altimate-core-validate.ts
index 590ad0d41..d4d6a35e9 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-validate.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-validate.ts
@@ -16,7 +16,7 @@ export const AltimateCoreValidateTool = Tool.define("altimate_core_validate", {
     const noSchema = !hasSchema
     if (noSchema) {
       const error = "No schema provided. Provide schema_context or schema_path so table/column references can be resolved."
-      return { title: "Validate: NO SCHEMA", metadata: { success: false, valid: false, has_schema: false, dialect: "snowflake", error }, output: `Error: ${error}` }
+      return { title: "Validate: NO SCHEMA", metadata: { success: false, valid: false, has_schema: false, error }, output: `Error: ${error}` }
     }
     try {
       const result = await Dispatcher.call("altimate_core.validate", {
@@ -37,7 +37,6 @@ export const AltimateCoreValidateTool = Tool.define("altimate_core_validate", {
           success: true, // engine ran — validation errors are findings, not failures
           valid: data.valid,
           has_schema: hasSchema,
-          dialect: "snowflake",
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
         },
@@ -45,7 +44,7 @@ export const AltimateCoreValidateTool = Tool.define("altimate_core_validate", {
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
-      return { title: "Validate: ERROR", metadata: { success: false, valid: false, has_schema: hasSchema, dialect: "snowflake", error: msg }, output: `Failed: ${msg}` }
+      return { title: "Validate: ERROR", metadata: { success: false, valid: false, has_schema: hasSchema, error: msg }, output: `Failed: ${msg}` }
     }
   },
 })
diff --git a/packages/opencode/src/altimate/tools/impact-analysis.ts b/packages/opencode/src/altimate/tools/impact-analysis.ts
index f1a1c7bd0..d99ad751f 100644
--- a/packages/opencode/src/altimate/tools/impact-analysis.ts
+++ b/packages/opencode/src/altimate/tools/impact-analysis.ts
@@ -152,7 +152,6 @@ export const ImpactAnalysisTool = Tool.define("impact_analysis", {
           test_count: affectedTestCount,
           column_impact: columnImpact.length,
           has_schema: false,
-          dialect: args.dialect,
           ...(findings.length > 0 && { findings }),
         },
         output,
@@ -161,7 +160,7 @@ export const ImpactAnalysisTool = Tool.define("impact_analysis", {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Impact: ERROR",
-        metadata: { success: false, has_schema: false, dialect: args.dialect, error: msg },
+        metadata: { success: false, has_schema: false, error: msg },
         output: `Failed to analyze impact: ${msg}\n\nEnsure the dbt manifest exists (run \`dbt compile\`) and the dispatcher is running.`,
       }
     }
diff --git a/packages/opencode/src/tool/tool.ts b/packages/opencode/src/tool/tool.ts
index 7b3e7495b..3003bc434 100644
--- a/packages/opencode/src/tool/tool.ts
+++ b/packages/opencode/src/tool/tool.ts
@@ -172,7 +172,7 @@ export namespace Tool {
                 finding_count: findings.length,
                 by_category: JSON.stringify(by_category),
                 has_schema: result.metadata?.has_schema ?? false,
-                dialect: (result.metadata?.dialect as string) ?? "unknown",
+                ...(result.metadata?.dialect && { dialect: result.metadata.dialect as string }),
                 duration_ms: durationMs,
               })
             }

From 06023ddfe22a4145fde94e7290532b43e62c1051 Mon Sep 17 00:00:00 2001
From: suryaiyer95 <surya@altimate.ai>
Date: Tue, 24 Mar 2026 15:24:17 -0700
Subject: [PATCH 6/6] fix: [AI-5975] guard finding arrays with `Array.isArray`
 for defensive safety

If a dispatcher returns a non-array for `errors`, `violations`, `issues`,
or `changes`, the `?? []` fallback handles null/undefined but not other
types. `Array.isArray` prevents `.map()` from throwing on unexpected payloads.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 packages/opencode/src/altimate/tools/altimate-core-correct.ts  | 3 ++-
 packages/opencode/src/altimate/tools/altimate-core-policy.ts   | 3 ++-
 .../opencode/src/altimate/tools/altimate-core-semantics.ts     | 3 ++-
 packages/opencode/src/altimate/tools/altimate-core-validate.ts | 3 ++-
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/packages/opencode/src/altimate/tools/altimate-core-correct.ts b/packages/opencode/src/altimate/tools/altimate-core-correct.ts
index 5e3050797..b318f3736 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-correct.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-correct.ts
@@ -22,7 +22,8 @@ export const AltimateCoreCorrectTool = Tool.define("altimate_core_correct", {
       const data = (result.data ?? {}) as Record<string, any>
       const error = result.error ?? data.error ?? extractCorrectErrors(data)
       // altimate_change start — sql quality findings for telemetry
-      const findings: Telemetry.Finding[] = (data.changes ?? []).map(() => ({
+      const changes = Array.isArray(data.changes) ? data.changes : []
+      const findings: Telemetry.Finding[] = changes.map(() => ({
         category: "correction_applied",
       }))
       // altimate_change end
diff --git a/packages/opencode/src/altimate/tools/altimate-core-policy.ts b/packages/opencode/src/altimate/tools/altimate-core-policy.ts
index 65ab85078..99bc056f8 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-policy.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-policy.ts
@@ -24,7 +24,8 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
       const data = (result.data ?? {}) as Record<string, any>
       const error = result.error ?? data.error
       // altimate_change start — sql quality findings for telemetry
-      const findings: Telemetry.Finding[] = (data.violations ?? []).map((v: any) => ({
+      const violations = Array.isArray(data.violations) ? data.violations : []
+      const findings: Telemetry.Finding[] = violations.map((v: any) => ({
         category: v.rule ?? "policy_violation",
       }))
       // altimate_change end
diff --git a/packages/opencode/src/altimate/tools/altimate-core-semantics.ts b/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
index a11ac00e5..0211b7c80 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-semantics.ts
@@ -28,7 +28,8 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
       const error = result.error ?? data.error ?? extractSemanticsErrors(data)
       const hasError = Boolean(error)
       // altimate_change start — sql quality findings for telemetry
-      const findings: Telemetry.Finding[] = (data.issues ?? []).map(() => ({
+      const issues = Array.isArray(data.issues) ? data.issues : []
+      const findings: Telemetry.Finding[] = issues.map(() => ({
         category: "semantic_issue",
       }))
       // altimate_change end
diff --git a/packages/opencode/src/altimate/tools/altimate-core-validate.ts b/packages/opencode/src/altimate/tools/altimate-core-validate.ts
index d4d6a35e9..9ff9da7bc 100644
--- a/packages/opencode/src/altimate/tools/altimate-core-validate.ts
+++ b/packages/opencode/src/altimate/tools/altimate-core-validate.ts
@@ -27,7 +27,8 @@ export const AltimateCoreValidateTool = Tool.define("altimate_core_validate", {
       const data = (result.data ?? {}) as Record<string, any>
       const error = result.error ?? data.error ?? extractValidationErrors(data)
       // altimate_change start — sql quality findings for telemetry
-      const findings: Telemetry.Finding[] = (data.errors ?? []).map((err: any) => ({
+      const errors = Array.isArray(data.errors) ? data.errors : []
+      const findings: Telemetry.Finding[] = errors.map((err: any) => ({
         category: classifyValidationError(err.message ?? ""),
       }))
       // altimate_change end