feat: env-based skill selection with session caching and tracing

Run LLM skill selector once per session using environment fingerprint,
cache by working directory, and apply filtering to both system prompt
and tool description. Adds tracing spans for fingerprint, skill
selection, and system prompt.

- Use LLM.stream for skill selection (proper provider auth)
- Plain text response parsing (one skill name per line)
- Cache keyed by cwd — invalidates on project change
- Filter skills in both SystemPrompt.skills() and SkillTool
- Add env_fingerprint_skill_selection config (default: true)
- Trim fingerprint to data-engineering detections only
- Add tracing for fingerprint, skill-selection, and system-prompt spans

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

Author: kulvirgit

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

@@ -0,0 +1,137 @@
+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" })
+
+export namespace Fingerprint {
+  export interface Result {
+    tags: string[]
+    detectedAt: number
+    cwd: string
+  }
+
+  let cached: Result | undefined
+
+  export function get(): Result | undefined {
+    return cached
+  }
+
+  export async function refresh(): Promise<Result> {
+    const previousCwd = cached?.cwd ?? process.cwd()
+    cached = undefined
+    return detect(previousCwd)
+  }
+
+  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[] = []
+
+    const dirs = root && root !== cwd ? [cwd, root] : [cwd]
+
+    await Promise.all(
+      dirs.map((dir) => detectDir(dir, tags)),
+    )
+
+    // Deduplicate
+    const unique = [...new Set(tags)]
+
+    const result: Result = {
+      tags: unique,
+      detectedAt: Date.now(),
+      cwd,
+    }
+
+    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
+  }
+
+  async function detectDir(dir: string, tags: string[]): Promise<void> {
+    // Data-engineering detections only
+    const [
+      hasDbtProject,
+      hasProfilesYml,
+      hasSqlfluff,
+      hasDbtPackagesYml,
+      hasAirflowCfg,
+      hasDagsDir,
+      hasDatabricksYml,
+    ] = await Promise.all([
+      Filesystem.exists(path.join(dir, "dbt_project.yml")),
+      Filesystem.exists(path.join(dir, "profiles.yml")),
+      Filesystem.exists(path.join(dir, ".sqlfluff")),
+      Filesystem.exists(path.join(dir, "dbt_packages.yml")),
+      Filesystem.exists(path.join(dir, "airflow.cfg")),
+      Filesystem.isDir(path.join(dir, "dags")),
+      Filesystem.exists(path.join(dir, "databricks.yml")),
+    ])
+
+    // dbt detection
+    if (hasDbtProject) {
+      tags.push("dbt", "data-engineering")
+    }
+
+    // dbt packages
+    if (hasDbtPackagesYml) {
+      tags.push("dbt-packages")
+    }
+
+    // profiles.yml - extract adapter type
+    if (hasProfilesYml) {
+      try {
+        const content = await Filesystem.readText(path.join(dir, "profiles.yml"))
+        const adapterMatch = content.match(
+          /type:\s*(snowflake|bigquery|redshift|databricks|postgres|mysql|sqlite|duckdb|trino|spark|clickhouse)/i,
+        )
+        if (adapterMatch) {
+          tags.push(adapterMatch[1]!.toLowerCase())
+        }
+      } catch (e) {
+        log.debug("profiles.yml unreadable", { dir, error: e })
+      }
+    }
+
+    // SQL - check for .sqlfluff or any .sql files
+    if (hasSqlfluff) {
+      tags.push("sql")
+    } else {
+      try {
+        const sqlFiles = await Glob.scan("*.sql", {
+          cwd: dir,
+          include: "file",
+        })
+        if (sqlFiles.length > 0) {
+          tags.push("sql")
+        }
+      } catch (e) {
+        log.debug("sql glob scan failed", { dir, error: e })
+      }
+    }
+
+    // Airflow
+    if (hasAirflowCfg || hasDagsDir) {
+      tags.push("airflow")
+    }
+
+    // Databricks
+    if (hasDatabricksYml) {
+      tags.push("databricks")
+    }
+  }
+}

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.