fix: resolve simulation suite failures — object stringification, error propagation, and test mock formats

- `altimate-core-column-lineage`: fix `[object Object]` in `column_dict` output when source entries are `{ source_table, source_column }` objects instead of strings
- `schema-inspect`: propagate `{ success: false, error }` dispatcher responses to `metadata.error` instead of silently returning empty schema
- `sql-analyze`: guard against null/undefined result from dispatcher to prevent "undefined" literal in output
- `lineage-check`: guard against null/undefined result from dispatcher to prevent "undefined" literal in output
- `simulation-suite.test.ts`: fix `sql-translate` mock format — data fields must be flat (not wrapped in `data: {}`), add `source_dialect`/`target_dialect` to mock so assertions pass
- `simulation-suite.test.ts`: fix `dbt-manifest` mock format — unwrap `data: {}` so `model_count` and `models` are accessible at top level

Simulation suite: 695/839 → 839/839 (100%)

Author: suryaiyer95

packages/opencode/src/altimate/tools/altimate-core-column-lineage.ts

@@ -47,7 +47,16 @@ function formatColumnLineage(data: Record<string, any>): string {
   if (data.column_dict && Object.keys(data.column_dict).length > 0) {
     lines.push("Column Mappings:")
     for (const [target, sources] of Object.entries(data.column_dict)) {
-      const srcList = Array.isArray(sources) ? (sources as string[]).join(", ") : JSON.stringify(sources)
+      const srcList = Array.isArray(sources)
+        ? sources
+            .map((s: any) => {
+              if (typeof s === "string") return s
+              if (s && s.source_table && s.source_column) return `${s.source_table}.${s.source_column}`
+              if (s && s.source) return String(s.source)
+              return JSON.stringify(s)
+            })
+            .join(", ")
+        : JSON.stringify(sources)
       lines.push(`  ${target} ← ${srcList}`)
     }
     lines.push("")

packages/opencode/src/altimate/tools/lineage-check.ts

@@ -20,12 +20,22 @@ export const LineageCheckTool = Tool.define("lineage_check", {
   }),
   async execute(args, ctx) {
     try {
-      const result = await Dispatcher.call("lineage.check", {
+      const raw = await Dispatcher.call("lineage.check", {
         sql: args.sql,
         dialect: args.dialect,
         schema_context: args.schema_context,
       })
 
+      // Guard against null/undefined/non-object responses
+      if (raw == null || typeof raw !== "object") {
+        return {
+          title: "Lineage: ERROR",
+          metadata: { success: false, error: "Unexpected response from lineage handler" },
+          output: "Lineage check failed: unexpected response format.",
+        }
+      }
+      const result = raw as LineageCheckResult
+
       const data = (result.data ?? {}) as Record<string, any>
       if (result.error) {
         return {

packages/opencode/src/altimate/tools/schema-inspect.ts

@@ -15,11 +15,22 @@ export const SchemaInspectTool = Tool.define("schema_inspect", {
   }),
   async execute(args, ctx) {
     try {
-      const result = await Dispatcher.call("schema.inspect", {
+      const raw = (await Dispatcher.call("schema.inspect", {
         table: args.table,
         schema_name: args.schema_name,
         warehouse: args.warehouse,
-      })
+      })) as any
+
+      // Surface dispatcher-level errors (e.g. { success: false, error: "..." })
+      if (!raw || raw.success === false || raw.error) {
+        const errorMsg = (raw?.error as string) ?? "Schema inspection failed"
+        return {
+          title: "Schema: ERROR",
+          metadata: { columnCount: 0, rowCount: undefined, error: errorMsg },
+          output: `Failed to inspect schema: ${errorMsg}\n\nEnsure the dispatcher is running and a warehouse connection is configured.`,
+        }
+      }
+      const result = raw as SchemaInspectResult
 
       // altimate_change start — progressive disclosure suggestions
       let output = formatSchema(result)

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

@@ -26,13 +26,23 @@ export const SqlAnalyzeTool = Tool.define("sql_analyze", {
   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("sql.analyze", {
+      const raw = await Dispatcher.call("sql.analyze", {
         sql: args.sql,
         dialect: args.dialect,
         schema_path: args.schema_path,
         schema_context: args.schema_context,
       })
 
+      // Guard against null/undefined/non-object responses
+      if (raw == null || typeof raw !== "object") {
+        return {
+          title: "Analyze: ERROR",
+          metadata: { success: false, issueCount: 0, confidence: "unknown", dialect: args.dialect, has_schema: hasSchema, error: "Unexpected response from analysis handler" },
+          output: "Analysis failed: unexpected response format.",
+        }
+      }
+      const result = raw
+
       // The handler returns success=true when analysis completes (issues are
       // reported via issues/issue_count). Only treat it as a failure when
       // there's an actual error (e.g. parse failure).

packages/opencode/test/altimate/simulation-suite.test.ts

@@ -907,15 +907,13 @@ describe("Category 4: dbt Integration", () => {
         args: { path: "target/manifest.json" },
         mockResponse: {
           success: true,
-          data: {
-            model_count: project.models,
-            source_count: project.sources,
-            test_count: project.tests,
-            snapshot_count: 0,
-            seed_count: 0,
-            models,
-            sources: [{ name: "raw_data", schema: "raw", columns: [] }],
-          },
+          model_count: project.models,
+          source_count: project.sources,
+          test_count: project.tests,
+          snapshot_count: 0,
+          seed_count: 0,
+          models,
+          sources: [{ name: "raw_data", schema: "raw", columns: [] }],
         },
         assertions: (result) => {
           expect(result.output).toContain("model")
@@ -1122,10 +1120,10 @@ describe("Category 7: SQL Translation", () => {
             dialect: `${source}→${target}`,
             mockResponse: {
               success: true,
-              data: {
-                translated_sql: SQL_CORPUS[sqlKey].replace(/SELECT/g, "/* translated */ SELECT"),
-                warnings: source === "snowflake" && target === "mysql" ? ["QUALIFY clause not supported in MySQL"] : [],
-              },
+              translated_sql: SQL_CORPUS[sqlKey].replace(/SELECT/g, "/* translated */ SELECT"),
+              source_dialect: source,
+              target_dialect: target,
+              warnings: source === "snowflake" && target === "mysql" ? ["QUALIFY clause not supported in MySQL"] : [],
             },
             assertions: (result) => {
               expect(result.output).toContain(source)