feat: add validation framework with semantic intent classifier

- Add `/validate` skill with `SKILL.md` and `batch_validate.py` that calls
  Altimate backend API directly via SSE for single trace, date range, and
  session modes
- Add `validate` CLI command (`altimate-code validate install/status`) that
  installs the skill to `~/.altimate-code/skills/validate/`
- Add conversation-logger that auto-logs user/assistant turns to the backend
  on session idle; wire `initConversationLogger()` into `InstanceBootstrap`
- Add `ValidationIntent.classify()` in `src/altimate/intent/validation-classifier.ts`
  using Haiku via the existing provider stack to detect validation queries
  semantically — handles natural language like "audit my session" or "check
  this trace" without keyword/rule-based matching
- Intercept `session.prompt` route to auto-redirect validation queries to the
  `validate` skill, keeping all other flows unchanged; fails open on any error
- Increase Bash tool timeout from 900000ms (~15 min) to 3600000ms (~60 min)
- Add failed claims markdown table to validation summary output with: claim ID,
  trace ID, claim text, claimed value, source tool ID, actual text, actual data,
  error %, and root cause
- Fix `build.ts` to embed skill assets from correct path; auto-install validate
  skill after `bun run build`; retry on empty SSE stream
- Skill output written directly to markdown files; user notified with file path

Author: Bharatram-altimate-ai

.gitignore

@@ -23,8 +23,37 @@ target
 .scripts
 .direnv/
 
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+
+# SQLite databases (feedback store creates these at runtime)
+*.db
+
+# Runtime logs
+*.log
+logs/
+
+# Large intermediate files at repo root (generated during benchmark runs)
+/queries.json
+/queries_1k.json
+/results/
+
+# Local runtime config
+.altimate-code/
+
+# Commit message scratch files
+.github/meta/
+
+# Experiment / simulation artifacts
+/data/
+/experiments/
+/models/
+/simulation/
+
 # Local dev files
 opencode-dev
-logs/
 *.bun-build
 tsconfig.tsbuildinfo

bun.lock

@@ -8,7 +8,7 @@
   "scripts": {
     "typecheck": "tsgo --noEmit",
     "test": "bun test --timeout 30000",
-    "build": "bun run script/build.ts",
+    "build": "bun run script/build.ts && bun run --conditions=browser ./src/index.ts validate install",
     "dev": "bun run --conditions=browser ./src/index.ts",
     "db": "bun drizzle-kit"
   },

packages/altimate-code/src/provider/models-snapshot.ts

@@ -71,6 +71,11 @@ const migrations = await Promise.all(
 )
 console.log(`Loaded ${migrations.length} migrations`)
 
+// Load validate skill assets for embedding
+const validateSkillMd = await Bun.file(path.join(dir, "src/skill/validate/SKILL.md")).text()
+const validateBatchPy = await Bun.file(path.join(dir, "src/skill/validate/batch_validate.py")).text()
+console.log("Loaded validate skill assets")
+
 const singleFlag = process.argv.includes("--single")
 const baselineFlag = process.argv.includes("--baseline")
 const skipInstall = process.argv.includes("--skip-install")
@@ -218,8 +223,13 @@ for (const item of targets) {
       OPENCODE_CHANNEL: `'${Script.channel}'`,
       ALTIMATE_ENGINE_VERSION: `'${engineVersion}'`,
       OPENCODE_LIBC: item.os === "linux" ? `'${item.abi ?? "glibc"}'` : "undefined",
+      ALTIMATE_CLI_LIBC: item.os === "linux" ? `'${item.abi ?? "glibc"}'` : "undefined",
       OPENCODE_MIGRATIONS: JSON.stringify(migrations),
+      ALTIMATE_CLI_MIGRATIONS: JSON.stringify(migrations),
       OPENCODE_CHANGELOG: JSON.stringify(changelog),
+      ALTIMATE_CLI_CHANGELOG: JSON.stringify(changelog),
+      ALTIMATE_VALIDATE_SKILL_MD: JSON.stringify(validateSkillMd),
+      ALTIMATE_VALIDATE_BATCH_PY: JSON.stringify(validateBatchPy),
       OTUI_TREE_SITTER_WORKER_PATH: bunfsRoot + workerRelativePath,
     },
   })

packages/opencode/package.json

@@ -0,0 +1,54 @@
+import { generateText } from "ai"
+import { Provider } from "@/provider/provider"
+import { Log } from "@/util/log"
+
+export namespace ValidationIntent {
+  const log = Log.create({ service: "validation-intent" })
+
+  const SYSTEM_PROMPT = `You are a binary intent classifier.
+A validation query is any request to check, audit, evaluate, or quality-assess an AI trace, session, or conversation response.
+Respond ONLY with valid JSON: {"is_validation": true} or {"is_validation": false}. No explanation.`
+
+  // Prefer haiku — fast and cheap. Other small models as fallback.
+  const CANDIDATE_QUERIES = [
+    ["anthropic", ["haiku"]],
+    ["anthropic", ["claude-3-haiku"]],
+    ["anthropic", ["claude-3-5-haiku"]],
+  ] as const
+
+  async function getClassifierLanguageModel() {
+    for (const [providerID, query] of CANDIDATE_QUERIES) {
+      try {
+        const closest = await Provider.closest(providerID, [...query])
+        if (!closest) continue
+        const model = await Provider.getModel(closest.providerID, closest.modelID)
+        return await Provider.getLanguage(model)
+      } catch {
+        // try next candidate
+      }
+    }
+    return null
+  }
+
+  export async function classify(message: string): Promise<boolean> {
+    if (!message.trim()) return false
+
+    try {
+      const language = await getClassifierLanguageModel()
+      if (!language) return false
+
+      const { text } = await generateText({
+        model: language,
+        system: SYSTEM_PROMPT,
+        prompt: message,
+        maxOutputTokens: 20,
+      })
+
+      const result = JSON.parse(text.trim())
+      return result.is_validation === true
+    } catch (e) {
+      log.warn("intent classification failed, proceeding normally", { error: String(e) })
+      return false // fail open — let main flow handle it
+    }
+  }
+}

packages/opencode/script/build.ts

@@ -106,6 +106,7 @@ import type { EventSource } from "./context/sdk"
 export function tui(input: {
   url: string
   args: Args
+  config: TuiConfig.Info
   directory?: string
   fetch?: typeof fetch
   headers?: RequestInit["headers"]

packages/opencode/src/altimate/intent/validation-classifier.ts

@@ -2,6 +2,9 @@ import { cmd } from "../cmd"
 import { UI } from "@/cli/ui"
 import { tui } from "./app"
 import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
+import { TuiConfig } from "@/config/tui"
+import { Instance } from "@/project/instance"
+import { existsSync } from "fs"
 
 export const AttachCommand = cmd({
   command: "attach <url>",
@@ -63,8 +66,13 @@ export const AttachCommand = cmd({
         const auth = `Basic ${Buffer.from(`altimate:${password}`).toString("base64")}`
         return { Authorization: auth }
       })()
+      const config = await Instance.provide({
+        directory: directory && existsSync(directory) ? directory : process.cwd(),
+        fn: () => TuiConfig.get(),
+      })
       await tui({
         url: args.url,
+        config,
         args: {
           continue: args.continue,
           sessionID: args.session,

packages/opencode/src/cli/cmd/tui/app.tsx

@@ -12,6 +12,8 @@ import { Filesystem } from "@/util/filesystem"
 import type { Event } from "@opencode-ai/sdk/v2"
 import type { EventSource } from "./context/sdk"
 import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
+import { TuiConfig } from "@/config/tui"
+import { Instance } from "@/project/instance"
 
 declare global {
   const OPENCODE_WORKER_PATH: string
@@ -135,6 +137,10 @@ export const TuiThreadCommand = cmd({
         if (!args.prompt) return piped
         return piped ? piped + "\n" + args.prompt : args.prompt
       })
+      const config = await Instance.provide({
+        directory: cwd,
+        fn: () => TuiConfig.get(),
+      })
 
       // Check if server should be started (port or hostname explicitly set in CLI or config)
       const networkOpts = await resolveNetworkOptions(args)
@@ -165,6 +171,8 @@ export const TuiThreadCommand = cmd({
 
       const tuiPromise = tui({
         url,
+        config,
+        directory: cwd,
         fetch: customFetch,
         events,
         tuiConfig,

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

@@ -0,0 +1,83 @@
+import type { Argv } from "yargs"
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import fs from "fs/promises"
+import path from "path"
+import os from "os"
+
+// Injected at build time by build.ts (same pattern as ALTIMATE_CLI_MIGRATIONS).
+// In development these fall back to reading from disk via getAssets().
+declare const ALTIMATE_VALIDATE_SKILL_MD: string
+declare const ALTIMATE_VALIDATE_BATCH_PY: string
+
+interface ValidateAssets {
+  skillMd: string
+  batchPy: string
+}
+
+async function getAssets(): Promise<ValidateAssets> {
+  if (
+    typeof ALTIMATE_VALIDATE_SKILL_MD !== "undefined" &&
+    typeof ALTIMATE_VALIDATE_BATCH_PY !== "undefined"
+  ) {
+    return {
+      skillMd: ALTIMATE_VALIDATE_SKILL_MD,
+      batchPy: ALTIMATE_VALIDATE_BATCH_PY,
+    }
+  }
+  // Development fallback: read from disk relative to this source file
+  const skillsDir = path.join(import.meta.dir, "../../skill/validate")
+  const [skillMd, batchPy] = await Promise.all([
+    fs.readFile(path.join(skillsDir, "SKILL.md"), "utf-8"),
+    fs.readFile(path.join(skillsDir, "batch_validate.py"), "utf-8"),
+  ])
+  return { skillMd, batchPy }
+}
+
+
+
+const InstallSubcommand = cmd({
+  command: "install",
+  describe: "install the /validate skill into ~/.altimate-code",
+  handler: async () => {
+    prompts.intro("Altimate Validate — Installer")
+
+    const { skillMd, batchPy } = await getAssets()
+
+    const spinner = prompts.spinner()
+    spinner.start("Installing /validate skill...")
+    const skillTargetDir = path.join(os.homedir(), ".altimate-code", "skills", "validate")
+    await fs.mkdir(skillTargetDir, { recursive: true })
+    await fs.writeFile(path.join(skillTargetDir, "SKILL.md"), skillMd)
+    await fs.writeFile(path.join(skillTargetDir, "batch_validate.py"), batchPy)
+    spinner.stop(`Installed /validate skill → ${skillTargetDir}`)
+
+    prompts.outro("Altimate validation skill installed successfully!")
+  },
+})
+
+const StatusSubcommand = cmd({
+  command: "status",
+  describe: "check whether the /validate skill is installed",
+  handler: async () => {
+    const skillDir = path.join(os.homedir(), ".altimate-code", "skills", "validate")
+
+    prompts.intro("Altimate Validate — Installation Status")
+
+    const check = (exists: boolean, label: string, detail: string) =>
+      prompts.log.info(`${exists ? "✓" : "✗"} ${label}${exists ? "" : " (not found)"}: ${detail}`)
+
+    const skillMdExists = await fs.access(path.join(skillDir, "SKILL.md")).then(() => true).catch(() => false)
+    const batchPyExists = await fs.access(path.join(skillDir, "batch_validate.py")).then(() => true).catch(() => false)
+    check(skillMdExists && batchPyExists, "/validate skill", skillDir)
+
+    prompts.outro("Done")
+  },
+})
+
+export const ValidateCommand = cmd({
+  command: "validate",
+  describe: "manage the Altimate validation framework (/validate skill)",
+  builder: (yargs: Argv) => yargs.command(InstallSubcommand).command(StatusSubcommand).demandCommand(),
+  handler: () => {},
+})