refactor: [AI-5975] drop by_severity from sql_quality telemetry, address PR review

- 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>

Author: suryaiyer95

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 ?? "",

packages/opencode/src/altimate/native/types.ts

@@ -29,6 +29,7 @@ export interface SqlAnalyzeParams {
 
 export interface SqlAnalyzeIssue {
   type: string
+  rule?: string
   severity: string
   message: string
   recommendation: string

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,21 +12,42 @@ 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,
         schema_path: args.schema_path ?? "",
         schema_context: args.schema_context,
       })
       const data = result.data as Record<string, any>
+      // 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 },
+        metadata: {
+          success: result.success,
+          has_schema: hasSchema,
+          dialect: "snowflake",
+          ...(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 }, output: `Failed: ${msg}` }
+      return { title: "Check: ERROR", metadata: { success: false, has_schema: hasSchema, dialect: "snowflake" }, output: `Failed: ${msg}` }
     }
   },
 })

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,
@@ -20,14 +22,25 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
         schema_context: args.schema_context,
       })
       const data = result.data as Record<string, any>
+      // 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 },
+        metadata: {
+          success: result.success,
+          pass: data.pass,
+          has_schema: hasSchema,
+          dialect: "snowflake",
+          ...(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 }, output: `Failed: ${msg}` }
+      return { title: "Policy: ERROR", metadata: { success: false, pass: false, has_schema: hasSchema, dialect: "snowflake" }, output: `Failed: ${msg}` }
     }
   },
 })

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,14 +151,17 @@ 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,
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Impact: ERROR",
-        metadata: { success: false },
+        metadata: { success: false, has_schema: false, dialect: args.dialect },
         output: `Failed to analyze impact: ${msg}\n\nEnsure the dbt manifest exists (run \`dbt compile\`) and the dispatcher is running.`,
       }
     }

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,21 +32,29 @@ 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: {
           success: result.success,
           changeCount,
           breakingCount,
           hasBreakingChanges: result.has_breaking_changes,
+          has_schema: false,
+          dialect: args.dialect,
+          ...(findings.length > 0 && { findings }),
         },
         output: formatSchemaDiff(result),
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Schema Diff: ERROR",
-        metadata: { success: false, changeCount: 0, breakingCount: 0, hasBreakingChanges: false },
+        metadata: { success: false, changeCount: 0, breakingCount: 0, hasBreakingChanges: false, has_schema: false, dialect: args.dialect },
         output: `Failed to diff schema: ${msg}\n\nCheck your connection configuration and try again.`,
       }
     }

packages/opencode/src/altimate/tools/sql-analyze.ts

@@ -24,7 +24,7 @@ export const SqlAnalyzeTool = Tool.define("sql_analyze", {
 
       // 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 {

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,14 +47,17 @@ 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),
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Optimize: ERROR",
-        metadata: { success: false, suggestionCount: 0, antiPatternCount: 0, hasOptimizedSql: false, confidence: "unknown" },
+        metadata: { success: false, suggestionCount: 0, antiPatternCount: 0, hasOptimizedSql: false, confidence: "unknown", has_schema: false, dialect: args.dialect },
         output: `Failed to optimize SQL: ${msg}\n\nCheck your connection configuration and try again.`,
       }
     }

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,
+    })
+  })
 })
 
 // ---------------------------------------------------------------------------