feat: merge training into memory with context-aware relevance scoring

Replace two parallel injection systems (memory 8KB + training 16KB)
with a single unified injection that scores blocks by relevance to
the current agent.

How it works:
- All blocks (memory + training) loaded in one pass
- Each block scored: agent tag match (+10), training kind relevance
  per agent (+1-5), applied count bonus (+0-3), recency (+0-2),
  non-training base (+5)
- Builder sees rules/patterns first; analyst sees glossary/context first
- Budget is 20KB unified, filled greedily by score
- Training blocks still tracked with applied counts (fire-and-forget)

Architecture:
- memory/prompt.ts: new scoreBlock(), unified inject() with InjectionContext
- memory/types.ts: UNIFIED_INJECTION_BUDGET, AGENT_TRAINING_RELEVANCE weights
- session/prompt.ts: single inject call with agent context (was 2 separate)
- training/prompt.ts: deprecated, delegates to MemoryPrompt (backward compat)

No changes to: MemoryStore, TrainingStore, training tools, memory tools.

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

Author: anandgupta42

packages/opencode/src/altimate/training/prompt.ts

@@ -1,96 +1,24 @@
-// altimate_change - Training prompt injection for AI Teammate learned knowledge
-import { TrainingStore, type TrainingEntry } from "./store"
-import { TRAINING_BUDGET, type TrainingKind } from "./types"
-
-const KIND_HEADERS: Record<TrainingKind, { header: string; instruction: string }> = {
-  pattern: {
-    header: "Learned Patterns",
-    instruction: "Follow these patterns when creating similar artifacts. They were learned from the user's codebase.",
-  },
-  rule: {
-    header: "Learned Rules",
-    instruction: "Always follow these rules. They were taught by the user through corrections and explicit instruction.",
-  },
-  glossary: {
-    header: "Domain Glossary",
-    instruction: "Use these definitions when discussing business concepts. They are specific to the user's domain.",
-  },
-  standard: {
-    header: "Team Standards",
-    instruction: "Enforce these standards in code reviews and when writing new code. They were loaded from team documentation.",
-  },
-  context: {
-    header: "Domain Context",
-    instruction: "Use this background knowledge to inform your reasoning. Not directly enforceable, but critical for understanding 'why'.",
-  },
-  playbook: {
-    header: "Playbooks",
-    instruction: "Follow these step-by-step procedures when handling the described scenarios.",
-  },
-}
-
-// Track which entries have been applied this session to avoid double-counting
-const appliedThisSession = new Set<string>()
+// altimate_change - Training prompt (deprecated — delegates to unified MemoryPrompt.inject)
+// Kept for backward compatibility with training tools (budgetUsage) and tests.
+import { MemoryPrompt } from "../../memory/prompt"
+import { TRAINING_BUDGET } from "./types"
+import type { TrainingEntry } from "./store"
 
 export namespace TrainingPrompt {
+  /** Format a training entry for display. */
   export function formatEntry(entry: TrainingEntry): string {
     const meta = entry.meta.applied > 0 ? ` (applied ${entry.meta.applied}x)` : ""
     return `#### ${entry.name}${meta}\n${entry.content}`
   }
 
-  /** Reset session tracking (call at session start) */
+  /** @deprecated — Use MemoryPrompt.resetSession(). Kept for backward compat. */
   export function resetSession(): void {
-    appliedThisSession.clear()
+    MemoryPrompt.resetSession()
   }
 
+  /** @deprecated — Use MemoryPrompt.inject() with context. Kept for training tool compat. */
   export async function inject(budget: number = TRAINING_BUDGET): Promise<string> {
-    const entries = await TrainingStore.list()
-    if (entries.length === 0) return ""
-
-    const grouped = new Map<TrainingKind, TrainingEntry[]>()
-    for (const entry of entries) {
-      const list = grouped.get(entry.kind) ?? []
-      list.push(entry)
-      grouped.set(entry.kind, list)
-    }
-
-    const header =
-      "## Teammate Training\n\nYou have been trained on the following knowledge by your team. Apply it consistently.\n"
-    let result = header
-    let used = header.length
-    const injected: TrainingEntry[] = []
-
-    for (const kind of ["rule", "pattern", "standard", "glossary", "context", "playbook"] as TrainingKind[]) {
-      const items = grouped.get(kind)
-      if (!items || items.length === 0) continue
-
-      const section = KIND_HEADERS[kind]
-      const sectionHeader = `\n### ${section.header}\n_${section.instruction}_\n`
-      if (used + sectionHeader.length > budget) break
-      result += sectionHeader
-      used += sectionHeader.length
-
-      // Sort by applied count descending so most-used entries get priority in budget
-      const sorted = [...items].sort((a, b) => b.meta.applied - a.meta.applied)
-      for (const entry of sorted) {
-        const formatted = formatEntry(entry)
-        const needed = formatted.length + 2
-        if (used + needed > budget) break
-        result += "\n" + formatted + "\n"
-        used += needed
-        injected.push(entry)
-      }
-    }
-
-    // Increment applied count once per session per entry (fire-and-forget)
-    for (const entry of injected) {
-      if (!appliedThisSession.has(entry.id)) {
-        appliedThisSession.add(entry.id)
-        TrainingStore.incrementApplied(entry.scope, entry.kind, entry.name).catch(() => {})
-      }
-    }
-
-    return result
+    return MemoryPrompt.injectTrainingOnly(budget)
   }
 
   export async function budgetUsage(budget: number = TRAINING_BUDGET): Promise<{

packages/opencode/src/memory/index.ts

@@ -5,5 +5,5 @@ export { MemoryWriteTool } from "./tools/memory-write"
 export { MemoryDeleteTool } from "./tools/memory-delete"
 export { MemoryAuditTool } from "./tools/memory-audit"
 export { MemoryExtractTool } from "./tools/memory-extract"
-export { MEMORY_MAX_BLOCK_SIZE, MEMORY_MAX_BLOCKS_PER_SCOPE, MEMORY_MAX_CITATIONS, MEMORY_DEFAULT_INJECTION_BUDGET } from "./types"
-export type { MemoryBlock, Citation } from "./types"
+export { MEMORY_MAX_BLOCK_SIZE, MEMORY_MAX_BLOCKS_PER_SCOPE, MEMORY_MAX_CITATIONS, MEMORY_DEFAULT_INJECTION_BUDGET, UNIFIED_INJECTION_BUDGET, AGENT_TRAINING_RELEVANCE } from "./types"
+export type { MemoryBlock, Citation, InjectionContext } from "./types"