Polish AI Teammate training UX: auto-lowercase names, update detection, budget visibility

- Fix researcher agent permissions: add training_save/remove (was read-only)
- Auto-lowercase + space-to-hyphen name transform in training_save (ARR → arr)
- Detect update vs new save, show "Updated" with preserved applied count
- Show training budget usage (chars/percent) on save, list, and remove
- Improve training_list: group by kind, show most-applied entries, budget %
- Improve training_remove: show available entries on not-found, applied count
- Show similar entry names in duplicate warnings (not just count)
- Raise content limit from 1800 to 2500 chars
- Export TRAINING_BUDGET constant, add budgetUsage() to TrainingPrompt
- Add 30 new tests: auto-lowercase, update detection, budget overflow,
  name collision, scale (80 entries), improved messaging
- All 118 training tests + 305 memory tests pass

https://claude.ai/code/session_01V17Kk3qCZFp9ZJiuNYucoq

Author: claude

packages/opencode/src/agent/agent.ts

@@ -252,7 +252,7 @@ export namespace Agent {
             altimate_core_check: "allow",
             read: "allow", grep: "allow", glob: "allow", bash: "allow",
             question: "allow", webfetch: "allow", websearch: "allow",
-            task: "allow", training_list: "allow",
+            task: "allow", training_save: "allow", training_list: "allow", training_remove: "allow",
           }),
           user,
         ),

packages/opencode/src/altimate/tools/training-list.ts

@@ -9,6 +9,8 @@ export const TrainingListTool = Tool.define("training_list", {
     "List all learned training entries (patterns, rules, glossary, standards).",
     "Shows what your teammate has been taught and how often each entry has been applied.",
     "Use this to review training, check what's been learned, or find entries to update/remove.",
+    "",
+    "Filter by kind (pattern/rule/glossary/standard) or scope (global/project/all).",
   ].join("\n"),
   parameters: z.object({
     kind: TrainingKind.optional().describe("Filter by kind: pattern, rule, glossary, or standard"),
@@ -26,11 +28,14 @@ export const TrainingListTool = Tool.define("training_list", {
         const hint = args.kind ? ` of kind "${args.kind}"` : ""
         return {
           title: "Training: empty",
-          metadata: { count: 0 },
+          metadata: { count: 0, budgetPercent: 0 },
           output: `No training entries found${hint}. Use /teach to learn from example files, /train to learn from documents, or correct me and I'll offer to save the rule.`,
         }
       }
 
+      // Budget usage
+      const budget = await TrainingPrompt.budgetUsage()
+
       const counts = await TrainingStore.count()
       const summary = [
         `## Training Status`,
@@ -43,26 +48,54 @@ export const TrainingListTool = Tool.define("training_list", {
         `| Standards | ${counts.standard} |`,
         `| **Total** | **${entries.length}** |`,
         "",
+        `**Context budget**: ${budget.used}/${budget.budget} chars (${budget.percent}% full)`,
+        "",
       ].join("\n")
 
-      const details = entries
-        .map((e) => {
+      // Sort by applied count descending for visibility of most-used entries
+      const sorted = [...entries].sort((a, b) => b.meta.applied - a.meta.applied)
+
+      // Find top applied entries for highlight
+      const topApplied = sorted.filter((e) => e.meta.applied > 0).slice(0, 3)
+      let highlights = ""
+      if (topApplied.length > 0) {
+        highlights =
+          "**Most applied**: " +
+          topApplied.map((e) => `\`${e.name}\` (${e.meta.applied}x)`).join(", ") +
+          "\n\n"
+      }
+
+      // Group by kind for display
+      const grouped = new Map<string, typeof entries>()
+      for (const e of entries) {
+        const list = grouped.get(e.kind) ?? []
+        list.push(e)
+        grouped.set(e.kind, list)
+      }
+
+      const sections: string[] = []
+      for (const kind of ["rule", "pattern", "standard", "glossary"] as const) {
+        const items = grouped.get(kind)
+        if (!items || items.length === 0) continue
+        sections.push(`### ${kind.charAt(0).toUpperCase() + kind.slice(1)}s`)
+        for (const e of items) {
           const applied = e.meta.applied > 0 ? ` (applied ${e.meta.applied}x)` : ""
           const source = e.meta.source ? ` — from: ${e.meta.source}` : ""
           const scope = e.scope === "global" ? " [global]" : ""
-          return `- **${e.name}** (${e.kind})${scope}${applied}${source}\n  ${e.content.split("\n")[0].slice(0, 100)}`
-        })
-        .join("\n")
+          sections.push(`- **${e.name}**${scope}${applied}${source}\n  ${e.content.split("\n")[0].slice(0, 120)}`)
+        }
+        sections.push("")
+      }
 
       return {
         title: `Training: ${entries.length} entries`,
-        metadata: { count: entries.length },
-        output: summary + details,
+        metadata: { count: entries.length, budgetPercent: budget.percent },
+        output: summary + highlights + sections.join("\n"),
       }
     } catch (e) {
       return {
         title: "Training List: ERROR",
-        metadata: { count: 0 },
+        metadata: { count: 0, budgetPercent: 0 },
         output: `Failed to list training: ${e instanceof Error ? e.message : String(e)}`,
       }
     }

packages/opencode/src/altimate/tools/training-remove.ts

@@ -1,7 +1,7 @@
 // altimate_change - Training remove tool for AI Teammate
 import z from "zod"
 import { Tool } from "../../tool/tool"
-import { TrainingStore } from "../training"
+import { TrainingStore, TrainingPrompt } from "../training"
 import { TrainingKind } from "../training/types"
 
 export const TrainingRemoveTool = Tool.define("training_remove", {
@@ -17,20 +17,33 @@ export const TrainingRemoveTool = Tool.define("training_remove", {
   }),
   async execute(args, ctx) {
     try {
+      // Get the entry first so we can show what was removed
+      const entry = await TrainingStore.get(args.scope, args.kind, args.name)
+
       const removed = await TrainingStore.remove(args.scope, args.kind, args.name)
 
       if (!removed) {
+        // Help the user find the right name
+        const available = await TrainingStore.list({ kind: args.kind })
+        let hint = ""
+        if (available.length > 0) {
+          const names = available.map((e) => `\`${e.name}\``).join(", ")
+          hint = `\n\nAvailable ${args.kind} entries: ${names}`
+        }
         return {
           title: "Training: not found",
           metadata: { action: "not_found", kind: args.kind, name: args.name },
-          output: `No training entry found: ${args.kind}/${args.name} in ${args.scope} scope.`,
+          output: `No training entry found: ${args.kind}/${args.name} in ${args.scope} scope.${hint}`,
         }
       }
 
+      const appliedNote = entry && entry.meta.applied > 0 ? ` It had been applied ${entry.meta.applied} time(s).` : ""
+      const budget = await TrainingPrompt.budgetUsage()
+
       return {
         title: `Training: removed "${args.name}" (${args.kind})`,
         metadata: { action: "removed", kind: args.kind, name: args.name },
-        output: `Removed ${args.kind} "${args.name}" from ${args.scope} training.`,
+        output: `Removed ${args.kind} "${args.name}" from ${args.scope} training.${appliedNote}\nTraining usage: ${budget.used}/${budget.budget} chars (${budget.percent}% full).`,
       }
     } catch (e) {
       return {

packages/opencode/src/altimate/tools/training-save.ts

@@ -1,8 +1,8 @@
 // altimate_change - Training save tool for AI Teammate learning
 import z from "zod"
 import { Tool } from "../../tool/tool"
-import { TrainingStore } from "../training"
-import { TrainingKind, TRAINING_MAX_PATTERNS_PER_KIND } from "../training/types"
+import { TrainingStore, TrainingPrompt } from "../training"
+import { TrainingKind, TRAINING_MAX_PATTERNS_PER_KIND, TRAINING_BUDGET } from "../training/types"
 import { CitationSchema } from "../../memory/types"
 
 export const TrainingSaveTool = Tool.define("training_save", {
@@ -25,15 +25,21 @@ export const TrainingSaveTool = Tool.define("training_save", {
       .string()
       .min(1)
       .max(64)
-      .regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/, {
-        message: "Name must be lowercase alphanumeric with hyphens/underscores",
-      })
-      .describe("Short identifier for this training entry (e.g., 'staging-model', 'no-float', 'arr-definition')"),
+      .transform((s) => s.toLowerCase().replace(/\s+/g, "-"))
+      .pipe(
+        z.string().regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/, {
+          message:
+            "Name must be lowercase alphanumeric with hyphens/underscores (e.g., 'staging-model', 'no-float', 'arr')",
+        }),
+      )
+      .describe(
+        "Short identifier for this training entry (e.g., 'staging-model', 'no-float', 'ARR'). Auto-lowercased.",
+      ),
     content: z
       .string()
       .min(1)
-      .max(1800)
-      .describe("The knowledge to save. Be specific and actionable. Use markdown for structure."),
+      .max(2500)
+      .describe("The knowledge to save. Be specific and actionable. Use markdown for structure. Max 2500 chars."),
     scope: z
       .enum(["global", "project"])
       .default("project")
@@ -51,12 +57,21 @@ export const TrainingSaveTool = Tool.define("training_save", {
   }),
   async execute(args, ctx) {
     try {
-      const existing = await TrainingStore.count({ kind: args.kind, scope: args.scope === "global" ? "global" : "project" })
-      if (existing[args.kind] >= TRAINING_MAX_PATTERNS_PER_KIND) {
-        return {
-          title: "Training: limit reached",
-          metadata: { action: "error" as string, kind: args.kind, name: args.name, scope: args.scope },
-          output: `Cannot save: already at ${TRAINING_MAX_PATTERNS_PER_KIND} ${args.kind} entries. Remove an existing one first with training_remove.`,
+      const scopeForCount = args.scope === "global" ? "global" : "project"
+
+      // Check if this is an update to an existing entry
+      const existingEntry = await TrainingStore.get(scopeForCount, args.kind, args.name)
+      const isUpdate = !!existingEntry
+
+      // Only check limit for new entries (not updates)
+      if (!isUpdate) {
+        const existing = await TrainingStore.count({ kind: args.kind, scope: scopeForCount })
+        if (existing[args.kind] >= TRAINING_MAX_PATTERNS_PER_KIND) {
+          return {
+            title: "Training: limit reached",
+            metadata: { action: "error" as string, kind: args.kind, name: args.name, scope: args.scope },
+            output: `Cannot save: already at ${TRAINING_MAX_PATTERNS_PER_KIND} ${args.kind} entries. Remove an existing one first with training_remove.`,
+          }
         }
       }
 
@@ -69,17 +84,40 @@ export const TrainingSaveTool = Tool.define("training_save", {
         citations: args.citations,
       })
 
-      let output = `Saved ${args.kind} "${args.name}" to ${args.scope} training.`
+      // Build response with context
+      let output: string
+      if (isUpdate) {
+        const appliedNote = existingEntry.meta.applied > 0 ? ` (preserving ${existingEntry.meta.applied} prior applications)` : ""
+        output = `Updated ${args.kind} "${args.name}" in ${args.scope} training${appliedNote}.`
+      } else {
+        output = `Saved ${args.kind} "${args.name}" to ${args.scope} training.`
+      }
+
       if (args.scope === "project") {
         output += "\nThis will be shared with your team when committed to git."
       }
+
+      // Show budget usage
+      const budgetUsed = await TrainingPrompt.budgetUsage()
+      output += `\nTraining usage: ${budgetUsed.used}/${budgetUsed.budget} chars (${budgetUsed.percent}% full).`
+      if (budgetUsed.percent >= 80) {
+        output += "\n⚠ Training is getting full. Oldest entries may not fit in context. Consider consolidating."
+      }
+
+      // Show duplicate details
       if (duplicates.length > 0) {
-        output += `\n\nNote: Found ${duplicates.length} similar training block(s). Consider consolidating.`
+        const dupNames = duplicates
+          .map((d) => {
+            const parts = d.id.split("/")
+            return `\`${parts.slice(1).join("/")}\``
+          })
+          .join(", ")
+        output += `\n\nSimilar entries found: ${dupNames}. Run training_remove to consolidate if these are duplicates.`
       }
 
       return {
-        title: `Training: saved "${args.name}" (${args.kind})`,
-        metadata: { action: "saved" as string, kind: args.kind, name: args.name, scope: args.scope },
+        title: `Training: ${isUpdate ? "updated" : "saved"} "${args.name}" (${args.kind})`,
+        metadata: { action: isUpdate ? "updated" : "saved", kind: args.kind, name: args.name, scope: args.scope },
         output,
       }
     } catch (e) {

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

@@ -6,6 +6,7 @@ export {
   TRAINING_TAG,
   TRAINING_ID_PREFIX,
   TRAINING_MAX_PATTERNS_PER_KIND,
+  TRAINING_BUDGET,
   trainingId,
   trainingTags,
   isTrainingBlock,

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

@@ -1,8 +1,6 @@
 // altimate_change - Training prompt injection for AI Teammate learned knowledge
 import { TrainingStore, type TrainingEntry } from "./store"
-import type { TrainingKind } from "./types"
-
-const TRAINING_BUDGET = 6000
+import { TRAINING_BUDGET, type TrainingKind } from "./types"
 
 const KIND_HEADERS: Record<TrainingKind, { header: string; instruction: string }> = {
   pattern: {
@@ -66,4 +64,18 @@ export namespace TrainingPrompt {
 
     return result
   }
+
+  export async function budgetUsage(budget: number = TRAINING_BUDGET): Promise<{
+    used: number
+    budget: number
+    percent: number
+  }> {
+    const injected = await inject(budget)
+    const used = injected.length
+    return {
+      used,
+      budget,
+      percent: budget > 0 ? Math.round((used / budget) * 100) : 0,
+    }
+  }
 }

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

@@ -4,6 +4,7 @@ import z from "zod"
 export const TRAINING_TAG = "training"
 export const TRAINING_ID_PREFIX = "training"
 export const TRAINING_MAX_PATTERNS_PER_KIND = 20
+export const TRAINING_BUDGET = 6000
 
 export const TrainingKind = z.enum(["pattern", "rule", "glossary", "standard"])
 export type TrainingKind = z.infer<typeof TrainingKind>

packages/opencode/test/training/tools.test.ts

@@ -153,13 +153,13 @@ describe("TRAINING_MAX_PATTERNS_PER_KIND", () => {
 })
 
 describe("content length validation", () => {
-  test("content within 1800 chars is acceptable", () => {
-    const content = "x".repeat(1800)
-    expect(content.length).toBeLessThanOrEqual(1800)
+  test("content within 2500 chars is acceptable", () => {
+    const content = "x".repeat(2500)
+    expect(content.length).toBeLessThanOrEqual(2500)
   })
 
-  test("content over 1800 chars should be rejected by tool", () => {
-    const content = "x".repeat(1801)
-    expect(content.length).toBeGreaterThan(1800)
+  test("content over 2500 chars should be rejected by tool", () => {
+    const content = "x".repeat(2501)
+    expect(content.length).toBeGreaterThan(2500)
   })
 })