feat: add tracing for fingerprint detection and skill selection

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: kulvirgit

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

@@ -1,6 +1,7 @@
 import { Filesystem } from "../../util/filesystem"
 import { Glob } from "../../util/glob"
 import { Log } from "../../util/log"
+import { Tracer } from "../observability/tracing"
 import path from "path"
 
 const log = Log.create({ service: "fingerprint" })
@@ -27,6 +28,7 @@ export namespace Fingerprint {
   export async function detect(cwd: string, root?: string): Promise<Result> {
     if (cached && cached.cwd === cwd) return cached
 
+    const startTime = Date.now()
     const timer = log.time("detect", { cwd, root })
     const tags: string[] = []
 
@@ -48,6 +50,15 @@ export namespace Fingerprint {
     cached = result
     timer.stop()
     log.info("detected", { tags: unique.join(","), cwd })
+
+    Tracer.active?.logSpan({
+      name: "fingerprint",
+      startTime,
+      endTime: Date.now(),
+      input: { cwd, root },
+      output: { tags: unique },
+    })
+
     return result
   }
 

packages/opencode/src/altimate/observability/tracing.ts

@@ -41,7 +41,7 @@ export interface TraceSpan {
   spanId: string
   parentSpanId: string | null
   name: string
-  kind: "session" | "generation" | "tool" | "text"
+  kind: "session" | "generation" | "tool" | "text" | "span"
   startTime: number
   endTime?: number
   status: "ok" | "error"
@@ -246,6 +246,11 @@ interface TracerOptions {
 }
 
 export class Tracer {
+  // Global active tracer — set when a session starts, cleared on end.
+  private static _active: Tracer | null = null
+  static get active(): Tracer | null { return Tracer._active }
+  static setActive(tracer: Tracer | null) { Tracer._active = tracer }
+
   private traceId: string
   private sessionId: string | undefined
   private rootSpanId: string | undefined
@@ -561,6 +566,39 @@ export class Tracer {
     if (part.text != null) this.generationText.push(String(part.text))
   }
 
+  /**
+   * Log a custom span (e.g., fingerprint detection, skill selection).
+   * Used for internal operations that aren't LLM generations or tool calls.
+   */
+  logSpan(span: {
+    name: string
+    startTime: number
+    endTime: number
+    status?: "ok" | "error"
+    input?: unknown
+    output?: unknown
+    attributes?: Record<string, unknown>
+  }) {
+    if (!this.rootSpanId) return
+    try {
+      this.spans.push({
+        spanId: randomUUIDv7(),
+        parentSpanId: this.rootSpanId,
+        name: span.name,
+        kind: "span",
+        startTime: span.startTime,
+        endTime: span.endTime,
+        status: span.status ?? "ok",
+        input: span.input,
+        output: span.output,
+        attributes: span.attributes,
+      })
+      this.snapshot()
+    } catch {
+      // best-effort
+    }
+  }
+
   /**
    * Build a TraceFile snapshot of the current state (in-progress or complete).
    * Used for incremental writes and live viewing.

packages/opencode/src/altimate/skill-selector.ts

@@ -1,11 +1,11 @@
 // altimate_change start - LLM-based dynamic skill selection
-import { generateObject } from "ai"
+import { generateText } from "ai"
 import type { LanguageModelV2 } from "@openrouter/ai-sdk-provider"
-import z from "zod"
 import { Provider } from "../provider/provider"
 import { Log } from "../util/log"
 import type { Skill } from "../skill"
 import type { Fingerprint } from "./fingerprint"
+import { Tracer } from "./observability/tracing"
 
 const log = Log.create({ service: "skill-selector" })
 
@@ -27,9 +27,8 @@ export interface SkillSelectorDeps {
   generate: (params: {
     model: LanguageModelV2
     temperature: number
-    schema: z.ZodType
     messages: Array<{ role: "system" | "user"; content: string }>
-  }) => Promise<{ object: { selected: string[] } }>
+  }) => Promise<{ text: string }>
 }
 
 async function defaultResolveModel(): Promise<LanguageModelV2 | undefined> {
@@ -44,7 +43,7 @@ async function defaultResolveModel(): Promise<LanguageModelV2 | undefined> {
 
 const defaultDeps: SkillSelectorDeps = {
   resolveModel: defaultResolveModel,
-  generate: generateObject as any,
+  generate: generateText as any,
 }
 
 /**
@@ -58,12 +57,21 @@ export async function selectSkillsWithLLM(
   fingerprint: Fingerprint.Result | undefined,
   deps?: SkillSelectorDeps,
 ): Promise<Skill.Info[]> {
+  const startTime = Date.now()
+
   // Return cached result if cwd hasn't changed (0ms)
   const cwd = fingerprint?.cwd
   if (cachedResult && cwd === cachedCwd) {
     log.info("returning cached skill selection", {
       count: cachedResult.length,
     })
+    Tracer.active?.logSpan({
+      name: "skill-selection",
+      startTime,
+      endTime: Date.now(),
+      input: { fingerprint: fingerprint?.tags, source: "cache" },
+      output: { count: cachedResult.length, skills: cachedResult.map((s) => s.name) },
+    })
     return cachedResult
   }
 
@@ -96,15 +104,15 @@ export async function selectSkillsWithLLM(
     const params = {
       model,
       temperature: 0,
-      schema: z.object({ selected: z.array(z.string()) }),
       messages: [
         {
           role: "system" as const,
           content: [
             "You are a skill selector for a coding assistant.",
             "Given a project environment and available skills, select which skills are relevant for this project.",
-            "Return ONLY skill names the user likely needs. Select 0-15 skills.",
-            "Prefer fewer, more relevant skills over many loosely related ones.",
+            "Return ONLY a JSON object: {\"selected\": [\"skill-name-1\", \"skill-name-2\"]}",
+            "Select 0-15 skills. Prefer fewer, more relevant skills over many loosely related ones.",
+            "Return ONLY the JSON object, no other text.",
           ].join("\n"),
         },
         {
@@ -125,7 +133,15 @@ export async function selectSkillsWithLLM(
       ),
     ])
 
-    const selected = result.object.selected.slice(0, MAX_SKILLS)
+    // Parse JSON from response text
+    const text = result.text.trim()
+    const jsonMatch = text.match(/\{[\s\S]*\}/)
+    if (!jsonMatch) {
+      log.info("LLM response not valid JSON, returning all skills")
+      return cache(skills)
+    }
+    const parsed = JSON.parse(jsonMatch[0]) as { selected?: string[] }
+    const selected = (parsed.selected ?? []).slice(0, MAX_SKILLS)
 
     // Zero-selection guard
     if (selected.length === 0) {
@@ -147,11 +163,26 @@ export async function selectSkillsWithLLM(
       count: matched.length,
       names: matched.map((s) => s.name),
     })
+    Tracer.active?.logSpan({
+      name: "skill-selection",
+      startTime,
+      endTime: Date.now(),
+      input: { fingerprint: fingerprint?.tags, totalSkills: skills.length, source: "llm" },
+      output: { count: matched.length, skills: matched.map((s) => s.name) },
+    })
     return cache(matched)
   } catch (e) {
     log.info("skill selection failed, returning all skills", {
       error: e instanceof Error ? e.message : String(e),
     })
+    Tracer.active?.logSpan({
+      name: "skill-selection",
+      startTime,
+      endTime: Date.now(),
+      status: "error",
+      input: { fingerprint: fingerprint?.tags, source: "fallback" },
+      output: { count: skills.length, error: e instanceof Error ? e.message : String(e) },
+    })
     return cache(skills)
   }
 }

packages/opencode/src/cli/cmd/run.ts

@@ -720,6 +720,7 @@ You are speaking to a non-technical business executive. Follow these rules stric
         variant: args.variant,
         prompt: message,
       })
+      if (tracer) Tracer.setActive(tracer)
 
       // Register crash handlers to flush the trace on unexpected exit
       const onSigint = () => { tracer?.flushSync("Process interrupted"); process.exit(130) }
@@ -766,6 +767,7 @@ You are speaking to a non-technical business executive. Follow these rules stric
 
       // Finalize trace and save to disk
       if (tracer) {
+        Tracer.setActive(null)
         const tracePath = await tracer.endTrace(error)
         if (tracePath) {
           emit("trace_saved", { path: tracePath })

packages/opencode/src/cli/cmd/tui/worker.ts

@@ -93,6 +93,7 @@ function getOrCreateTracer(sessionID: string): Tracer | null {
       ? Tracer.withExporters([...tracingExporters], { maxFiles: tracingMaxFiles })
       : Tracer.create()
     tracer.startTrace(sessionID, {})
+    Tracer.setActive(tracer)
     sessionTracers.set(sessionID, tracer)
     return tracer
   } catch {

packages/opencode/src/session/prompt.ts

@@ -53,6 +53,7 @@ import { decodeDataUrl } from "@/util/data-url"
 // altimate_change start - import fingerprint for env-based skill selection
 import { Fingerprint } from "../altimate/fingerprint"
 import { Config } from "../config/config"
+import { Tracer } from "../altimate/observability/tracing"
 // altimate_change end
 import { Telemetry } from "@/telemetry" // altimate_change — session telemetry
 
@@ -727,6 +728,16 @@ export namespace SessionPrompt {
         system.push(STRUCTURED_OUTPUT_SYSTEM_PROMPT)
       }
 
+      // altimate_change start - trace system prompt
+      Tracer.active?.logSpan({
+        name: "system-prompt",
+        startTime: Date.now(),
+        endTime: Date.now(),
+        input: { agent: agent.name, step },
+        output: { parts: system.length, content: system.join("\n\n") },
+      })
+      // altimate_change end
+
       const result = await processor.process({
         user: lastUser,
         agent,

packages/opencode/test/altimate/skill-filtering.test.ts

@@ -35,7 +35,7 @@ function makeDeps(selected: string[], model: LanguageModelV2 = FAKE_MODEL): Skil
     resolveModel: async () => model,
     generate: async (params) => {
       calls.push(params)
-      return { object: { selected } }
+      return { text: JSON.stringify({ selected }) }
     },
   }
 }

packages/opencode/test/tool/skill.test.ts

@@ -39,7 +39,7 @@ function seedCache(skillNames: string[]) {
   })) as Skill.Info[]
   const deps: SkillSelectorDeps = {
     resolveModel: async () => FAKE_MODEL,
-    generate: async () => ({ object: { selected: skillNames } }),
+    generate: async () => ({ text: JSON.stringify({ selected: skillNames }) }),
   }
   return selectSkillsWithLLM(skills, undefined, deps)
 }
@@ -210,7 +210,7 @@ Use this skill.
     resetSkillSelectorCache()
     const deps: SkillSelectorDeps = {
       resolveModel: async () => FAKE_MODEL,
-      generate: async () => ({ object: { selected: ["skill-alpha"] } }),
+      generate: async () => ({ text: JSON.stringify({ selected: ["skill-alpha"] }) }),
     }
     await selectSkillsWithLLM(
       [{ name: "skill-alpha", description: "Test skill-alpha", location: alphaLocation, content: "# skill-alpha" } as Skill.Info],