feat: replace dynamic_skills with env_fingerprint_skill_selection, add config guard tests

- Remove dynamic_skills config; env_fingerprint_skill_selection is the single toggle
  (default: true when absent, set false to disable)
- Remove MessageContext import and per-turn message extraction from prompt.ts
- Add integration tests in tool/skill.test.ts verifying the config guard:
  - env_fingerprint_skill_selection: false → selector bypassed, all skills shown
  - env_fingerprint_skill_selection: true → selector called, uses cached subset
- Fix pre-existing test assertion format (bold markdown → XML)

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

Author: kulvirgit

packages/opencode/src/config/config.ts

@@ -1266,11 +1266,7 @@ export namespace Config {
             .describe(
               "Automatically enhance prompts with AI before sending (default: false). Uses a small model to rewrite rough prompts into clearer versions.",
             ),
-          // altimate_change start - dynamic skill loading toggle
-          dynamic_skills: z
-            .boolean()
-            .optional()
-            .describe("Enable dynamic skill filtering by environment fingerprint and per-turn message rescue"),
+          // altimate_change start - env fingerprint skill selection toggle
           env_fingerprint_skill_selection: z
             .boolean()
             .optional()

packages/opencode/src/session/prompt.ts

@@ -50,9 +50,8 @@ import { iife } from "@/util/iife"
 import { Shell } from "@/shell/shell"
 import { Truncate } from "@/tool/truncation"
 import { decodeDataUrl } from "@/util/data-url"
-// altimate_change start - import fingerprint for dynamic skill loading
+// altimate_change start - import fingerprint for env-based skill selection
 import { Fingerprint } from "../altimate/fingerprint"
-import { MessageContext } from "../altimate/context/message-context"
 import { Config } from "../config/config"
 // altimate_change end
 import { Telemetry } from "@/telemetry" // altimate_change — session telemetry
@@ -304,7 +303,7 @@ export namespace SessionPrompt {
     const session = await Session.get(sessionID)
     // altimate_change start - detect environment fingerprint at session start
     const altCfg = await Config.get()
-    if (altCfg.experimental?.dynamic_skills) {
+    if (altCfg.experimental?.env_fingerprint_skill_selection !== false) {
       await Fingerprint.detect(Instance.directory, Instance.worktree).catch((e) => {
         log.warn("fingerprint detection failed", { error: e })
       })
@@ -646,16 +645,7 @@ export namespace SessionPrompt {
       const lastUserMsg = msgs.findLast((m) => m.info.role === "user")
       const bypassAgentCheck = lastUserMsg?.parts.some((p) => p.type === "agent") ?? false
 
-      // altimate_change start - set message context for per-turn skill rescue
-      if ((await Config.get()).experimental?.dynamic_skills) {
-        const lastUserText =
-          lastUserMsg?.parts
-            .filter((p): p is Extract<typeof p, { type: "text" }> => p.type === "text")
-            .map((p) => p.text)
-            .join(" ") ?? ""
-        MessageContext.set(lastUserText)
-      }
-      // altimate_change end
+      // altimate_change - MessageContext removed: skill selection uses fingerprint only, not per-turn message
 
       const tools = await resolveTools({
         agent,

packages/opencode/src/tool/skill.ts

@@ -19,7 +19,7 @@ export const SkillTool = Tool.define("skill", async (ctx) => {
   // altimate_change start - LLM-based dynamic skill selection
   const cfg = await Config.get()
   let allAllowed: Skill.Info[]
-  if (cfg.experimental?.dynamic_skills && cfg.experimental?.env_fingerprint_skill_selection !== false) {
+  if (cfg.experimental?.env_fingerprint_skill_selection !== false) {
     allAllowed = await selectSkillsWithLLM(
       list,
       Fingerprint.get(),

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

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { afterEach, describe, expect, test } from "bun:test"
 import path from "path"
 import { pathToFileURL } from "url"
 import type { PermissionNext } from "../../src/permission/next"
@@ -7,6 +7,9 @@ import { Instance } from "../../src/project/instance"
 import { SkillTool } from "../../src/tool/skill"
 import { tmpdir } from "../fixture/fixture"
 import { SessionID, MessageID } from "../../src/session/schema"
+import { resetSkillSelectorCache, selectSkillsWithLLM, type SkillSelectorDeps } from "../../src/altimate/skill-selector"
+import type { Skill } from "../../src/skill"
+import type { LanguageModelV2 } from "@openrouter/ai-sdk-provider"
 
 const baseCtx: Omit<Tool.Context, "ask"> = {
   sessionID: SessionID.make("ses_test"),
@@ -18,6 +21,25 @@ const baseCtx: Omit<Tool.Context, "ask"> = {
   metadata: () => {},
 }
 
+const FAKE_MODEL = { modelId: "test", provider: "test" } as unknown as LanguageModelV2
+
+/** Pre-populate the skill selector cache with a specific subset */
+function seedCache(skillNames: string[]) {
+  resetSkillSelectorCache()
+  const skills = skillNames.map((name) => ({
+    name,
+    description: `Skill: ${name}`,
+    location: `/fake/${name}/SKILL.md`,
+    content: `# ${name}`,
+  })) as Skill.Info[]
+  // Call with mock deps that return exactly these names → populates the cache
+  const deps: SkillSelectorDeps = {
+    resolveModel: async () => FAKE_MODEL,
+    generate: async () => ({ object: { selected: skillNames } }),
+  }
+  return selectSkillsWithLLM(skills, undefined, deps)
+}
+
 describe("tool.skill", () => {
   test("description lists skill location URL", async () => {
     await using tmp = await tmpdir({
@@ -46,14 +68,19 @@ description: Skill for tool tests.
         fn: async () => {
           const tool = await SkillTool.init()
           const skillPath = path.join(tmp.path, ".opencode", "skill", "tool-skill", "SKILL.md")
-          expect(tool.description).toContain(`**tool-skill**: Skill for tool tests.`)
+          expect(tool.description).toContain(`<name>tool-skill</name>`)
+          expect(tool.description).toContain(`<description>Skill for tool tests.</description>`)
         },
       })
     } finally {
       process.env.OPENCODE_TEST_HOME = home
     }
   })
 
+  afterEach(() => {
+    resetSkillSelectorCache()
+  })
+
   test("execute returns skill content block with files", async () => {
     await using tmp = await tmpdir({
       git: true,
@@ -110,4 +137,92 @@ Use this skill.
       process.env.OPENCODE_TEST_HOME = home
     }
   })
+
+  test("env_fingerprint_skill_selection: false → selector bypassed, all skills shown", async () => {
+    // Pre-populate cache with only "skill-alpha" — if selector is called, it returns this cached subset
+    await seedCache(["skill-alpha"])
+
+    await using tmp = await tmpdir({
+      git: true,
+      config: {
+        experimental: {
+          env_fingerprint_skill_selection: false,
+        },
+      },
+      init: async (dir) => {
+        for (const name of ["skill-alpha", "skill-beta"]) {
+          await Bun.write(
+            path.join(dir, ".opencode", "skill", name, "SKILL.md"),
+            `---\nname: ${name}\ndescription: Test ${name}\n---\n# ${name}\n`,
+          )
+        }
+      },
+    })
+
+    const home = process.env.OPENCODE_TEST_HOME
+    process.env.OPENCODE_TEST_HOME = tmp.path
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          const tool = await SkillTool.init()
+          // Selector was bypassed → both skills appear (from Skill.available, not cache)
+          expect(tool.description).toContain("<name>skill-alpha</name>")
+          expect(tool.description).toContain("<name>skill-beta</name>")
+        },
+      })
+    } finally {
+      process.env.OPENCODE_TEST_HOME = home
+    }
+  })
+
+  test("env_fingerprint_skill_selection: true → selector called, uses cached subset", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      config: {
+        experimental: {
+          env_fingerprint_skill_selection: true,
+        },
+      },
+      init: async (dir) => {
+        for (const name of ["skill-alpha", "skill-beta"]) {
+          await Bun.write(
+            path.join(dir, ".opencode", "skill", name, "SKILL.md"),
+            `---\nname: ${name}\ndescription: Test ${name}\n---\n# ${name}\n`,
+          )
+        }
+      },
+    })
+
+    // Pre-populate cache with only "skill-alpha" AFTER tmpdir so location matches
+    const alphaLocation = path.join(tmp.path, ".opencode", "skill", "skill-alpha", "SKILL.md")
+    resetSkillSelectorCache()
+    const deps: SkillSelectorDeps = {
+      resolveModel: async () => FAKE_MODEL,
+      generate: async () => ({ object: { selected: ["skill-alpha"] } }),
+    }
+    await selectSkillsWithLLM(
+      [{ name: "skill-alpha", description: "Test skill-alpha", location: alphaLocation, content: "# skill-alpha" } as Skill.Info],
+      undefined,
+      deps,
+    )
+
+    const home = process.env.OPENCODE_TEST_HOME
+    process.env.OPENCODE_TEST_HOME = tmp.path
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          const tool = await SkillTool.init()
+          // Selector was called → returns cached subset (only skill-alpha)
+          expect(tool.description).toContain("<name>skill-alpha</name>")
+          expect(tool.description).not.toContain("<name>skill-beta</name>")
+        },
+      })
+    } finally {
+      process.env.OPENCODE_TEST_HOME = home
+    }
+  })
 })