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

@@ -6,6 +6,7 @@ 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" })
 
@@ -58,12 +59,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
   }
 
@@ -147,11 +157,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,