feat: [AI-5975] add sql_quality telemetry for issue prevention metrics

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

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

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

@@ -405,6 +405,21 @@ 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 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 +789,22 @@ export namespace Telemetry {
  }
  }
 
+ // altimate_change start — sql quality telemetry types
+ /** Lightweight finding record for quality telemetry. Only category — never SQL content. */
+ export interface Finding {
+ category: string
+ }
+
+ /** 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_category[f.category] = (by_category[f.category] ?? 0) + 1
+ }
+ return 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

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,34 @@ 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,
+ ...(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, error: msg }, output: `Failed: ${msg}` }
  }
  },
 })

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 changes = Array.isArray(data.changes) ? data.changes : []
+ const findings: Telemetry.Finding[] = 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,
+ ...(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, error: msg }, output: `Failed: ${msg}` }
  }
  },
 })

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, error }, output: `Error: ${error}` }
  }
  try {
  const result = await Dispatcher.call("altimate_core.equivalence", {
@@ -28,14 +30,28 @@ 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,
+ ...(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, error: msg }, output: `Failed: ${msg}` }
  }
  },
 })

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,29 @@ 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,
+ ...(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, error: msg }, 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,
@@ -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 violations = Array.isArray(data.violations) ? data.violations : []
+ const findings: Telemetry.Finding[] = 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: true, // engine ran — violations are findings, not failures
+ pass: data.pass,
+ has_schema: hasSchema,
+ ...(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, error: msg }, output: `Failed: ${msg}` }
  }
  },
 })

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, 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 issues = Array.isArray(data.issues) ? data.issues : []
+ const findings: Telemetry.Finding[] = 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: true, // engine ran — semantic issues are findings, not failures
+ valid: data.valid,
+ issue_count: issueCount,
+ has_schema: hasSchema,
+ ...(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, error: msg }, output: `Failed: ${msg}` }
  }
  },
 })