feat: [AI-7392] authoritative tool source + humanized MCP titles

Classify every tool call's origin server-side and stamp it on the tool
part's state.metadata.source (builtin | altimate | mcp), so clients render
the source badge without re-deriving it from tool-name prefixes:

- tool-source.ts: native-set inversion (any non-native registry tool is
  Altimate, so new Altimate tools classify with no maintenance); Datamates
  MCP folded into "altimate"; humanizeMcpTitle for readable MCP labels.
- resolveTools: stamp metadata.source on registry tools; on MCP tools set
  both the source and a humanized title (they previously had title: "").

Author: ralphstodomingo

packages/opencode/src/altimate/tool-source.ts

@@ -0,0 +1,72 @@
+/**
+ * Authoritative classification of a tool call's origin, stamped onto the tool
+ * part's `state.metadata.source` so clients (chat webview, ...) render the right
+ * badge without re-deriving it from tool-name prefixes.
+ *
+ *  - "builtin"  — native opencode tools (read/glob/bash/...)
+ *  - "altimate" — Altimate-provided tools (sql_*, schema_*, finops_*, ...) AND
+ *                 tools from the Datamates MCP server (Altimate-owned, just
+ *                 delivered over MCP)
+ *  - "mcp"      — third-party MCP tools
+ *
+ * Registry tools and MCP tools are resolved in separate loops (see
+ * `session/prompt.ts` resolveTools), so each has its own classifier.
+ */
+export type ToolSource = "builtin" | "altimate" | "mcp"
+
+/**
+ * Native opencode tool ids. This set is small and stable; every other tool in
+ * the registry is Altimate-provided, so new Altimate tools classify correctly
+ * with no per-tool maintenance here.
+ */
+const NATIVE_TOOL_IDS = new Set<string>([
+  "invalid",
+  "question",
+  "bash",
+  "read",
+  "glob",
+  "grep",
+  "list",
+  "edit",
+  "write",
+  "multiedit",
+  "task",
+  "webfetch",
+  "todowrite",
+  "todoread",
+  "websearch",
+  "codesearch",
+  "skill",
+  "apply_patch",
+  "lsp",
+  "plan_exit",
+  "plan_enter",
+  "StructuredOutput",
+])
+
+/** MCP client-name prefixes that are Altimate-owned (Datamates as an MCP server). */
+const ALTIMATE_MCP_PREFIXES = ["datamate"]
+
+/** Classify a registry tool (never an MCP tool) as builtin vs Altimate. */
+export function registryToolSource(id: string): ToolSource {
+  return NATIVE_TOOL_IDS.has(id) ? "builtin" : "altimate"
+}
+
+/** Classify an MCP tool by its `<client>_<tool>` key: Altimate (Datamates) vs third-party. */
+export function mcpToolSource(key: string): ToolSource {
+  const lower = key.toLowerCase()
+  return ALTIMATE_MCP_PREFIXES.some((p) => lower.startsWith(p)) ? "altimate" : "mcp"
+}
+
+/**
+ * Best-effort readable title for an MCP tool call, from its `<client>_<tool>`
+ * key — e.g. "datamates_jira_get_issue" → "Jira Get Issue". Strips the leading
+ * client segment and Title-Cases the rest. (Richer per-call titles are the MCP
+ * server's job; this is the fallback so MCP rows aren't a bare snake_case id.)
+ */
+export function humanizeMcpTitle(key: string): string {
+  const withoutClient = key.includes("_") ? key.slice(key.indexOf("_") + 1) : key
+  const words = (withoutClient || key).split(/[_-]+/).filter(Boolean)
+  if (words.length === 0) return key
+  return words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ")
+}

packages/opencode/src/session/prompt.ts

@@ -65,6 +65,8 @@ import { registerAltimateValidators } from "../altimate/validators"
 registerAltimateValidators()
 import { Config } from "../config/config"
 import { Tracer } from "../altimate/observability/tracing"
+// altimate_change — stamp an authoritative tool source + humanized MCP title
+import { registryToolSource, mcpToolSource, humanizeMcpTitle } from "../altimate/tool-source"
 // altimate_change end
 import { Telemetry } from "@/telemetry" // altimate_change — session telemetry
 
@@ -1564,6 +1566,8 @@ export namespace SessionPrompt {
               messageID: input.processor.message.id,
             })),
           }
+          // altimate_change — stamp authoritative tool source so clients render the right badge
+          output.metadata = { ...(output.metadata ?? {}), source: registryToolSource(item.id) }
           await Plugin.trigger(
             "tool.execute.after",
             {
@@ -1655,10 +1659,13 @@ export namespace SessionPrompt {
           ...(result.metadata ?? {}),
           truncated: truncated.truncated,
           ...(truncated.truncated && { outputPath: truncated.outputPath }),
+          // altimate_change — authoritative source so the chat can badge Datamates MCP tools
+          source: mcpToolSource(key),
         }
 
         return {
-          title: "",
+          // altimate_change — MCP tools have no native title; give a readable label
+          title: humanizeMcpTitle(key),
           metadata,
           output: truncated.content,
           attachments: attachments.map((attachment) => ({

packages/opencode/test/altimate/tool-source.test.ts

@@ -0,0 +1,39 @@
+import { describe, test, expect } from "bun:test"
+import { registryToolSource, mcpToolSource, humanizeMcpTitle } from "../../src/altimate/tool-source"
+
+describe("registryToolSource", () => {
+  test("native opencode tools → builtin", () => {
+    for (const id of ["read", "write", "edit", "glob", "grep", "list", "bash", "task", "skill", "apply_patch"]) {
+      expect(registryToolSource(id)).toBe("builtin")
+    }
+  })
+
+  test("any non-native registry tool → altimate (incl. tools not enumerated here)", () => {
+    for (const id of ["sql_analyze", "schema_inspect", "finops_query_history", "altimate_core_check", "data_diff", "some_new_altimate_tool"]) {
+      expect(registryToolSource(id)).toBe("altimate")
+    }
+  })
+})
+
+describe("mcpToolSource", () => {
+  test("Datamates MCP tools → altimate", () => {
+    expect(mcpToolSource("datamates_jira_get_issue")).toBe("altimate")
+    expect(mcpToolSource("datamate_snowflake_query")).toBe("altimate")
+  })
+
+  test("third-party MCP tools → mcp", () => {
+    expect(mcpToolSource("github_search_issues")).toBe("mcp")
+    expect(mcpToolSource("linear_create_issue")).toBe("mcp")
+  })
+})
+
+describe("humanizeMcpTitle", () => {
+  test("strips the client segment and Title-Cases the rest", () => {
+    expect(humanizeMcpTitle("datamates_jira_get_issue")).toBe("Jira Get Issue")
+    expect(humanizeMcpTitle("github_search_issues")).toBe("Search Issues")
+  })
+
+  test("falls back gracefully for single-segment keys", () => {
+    expect(humanizeMcpTitle("ping")).toBe("Ping")
+  })
+})