feat: wire up memory injection into system prompt with telemetry

- Inject memory blocks into system prompt at session start, gated by
  ALTIMATE_DISABLE_MEMORY flag
- Add memory_operation and memory_injection telemetry events to App Insights
- Add memory tool categorization for telemetry
- Document disabling memory for benchmarks/CI
- Add injection integration tests and telemetry event tests

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: anandgupta42

docs/docs/data-engineering/tools/memory-tools.md

@@ -132,16 +132,27 @@ Files are human-readable and editable. You can create, edit, or delete them manu
 
 Blocks are written to a temporary file first, then atomically renamed. This prevents corruption if the process is interrupted mid-write.
 
+## Disabling memory
+
+Set the environment variable to disable all memory functionality — tools and automatic injection:
+
+```bash
+ALTIMATE_DISABLE_MEMORY=true
+```
+
+This is useful for **benchmarks**, CI pipelines, or any environment where persistent memory should not influence agent behavior. When disabled, memory tools are removed from the tool registry and no memory blocks are injected into the system prompt.
+
 ## Context window impact
 
-Altimate Memory injects relevant blocks into the system prompt at session start, subject to a configurable token budget (default: 8,000 characters). Blocks are sorted by last-updated timestamp, so the most recently relevant information is loaded first.
+Altimate Memory automatically injects relevant blocks into the system prompt at session start, subject to a configurable token budget (default: 8,000 characters). Blocks are sorted by last-updated timestamp, so the most recently relevant information is loaded first. The agent also has access to memory tools (`altimate_memory_read`, `altimate_memory_write`, `altimate_memory_delete`) to manage blocks on demand during a session.
 
 **What this means in practice:**
 
 - With a typical block size of 200-500 characters, the default budget comfortably fits 15-40 blocks
 - Memory injection adds a one-time cost at session start — it does not grow during the session
 - If you notice context pressure, reduce the number of blocks or keep them concise
 - The agent's own tool calls and responses consume far more context than memory blocks
+- To disable injection entirely (e.g., for benchmarks), set `ALTIMATE_DISABLE_MEMORY=true`
 
 !!! tip
     Keep blocks concise and focused. A block titled "warehouse-config" with 5 bullet points is better than a wall of text. The agent can always call `altimate_memory_read` to fetch specific blocks on demand.

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

@@ -254,6 +254,26 @@ export namespace Telemetry {
         tool_count: number
         resource_count: number
       }
+    | {
+        type: "memory_operation"
+        timestamp: number
+        session_id: string
+        operation: "write" | "delete"
+        scope: "global" | "project"
+        block_id: string
+        is_update: boolean
+        duplicate_count: number
+        tags_count: number
+      }
+    | {
+        type: "memory_injection"
+        timestamp: number
+        session_id: string
+        block_count: number
+        total_chars: number
+        budget: number
+        scopes_used: string[]
+      }
 
   const FILE_TOOLS = new Set(["read", "write", "edit", "glob", "grep", "bash"])
 
@@ -266,6 +286,7 @@ export namespace Telemetry {
     { category: "dbt", keywords: ["dbt"] },
     { category: "warehouse", keywords: ["warehouse", "connection"] },
     { category: "lineage", keywords: ["lineage", "dag"] },
+    { category: "memory", keywords: ["memory"] },
   ]
 
   export function categorizeToolName(name: string, type: "standard" | "mcp"): string {

packages/opencode/src/memory/prompt.ts

@@ -1,5 +1,6 @@
 import { MemoryStore, isExpired } from "./store"
 import { MEMORY_DEFAULT_INJECTION_BUDGET, type MemoryBlock } from "./types"
+import { Telemetry } from "@/altimate/telemetry"
 
 export namespace MemoryPrompt {
   export function formatBlock(block: MemoryBlock): string {
@@ -26,6 +27,8 @@ export namespace MemoryPrompt {
     const header = "## Altimate Memory\n\nThe following memory blocks were saved from previous sessions:\n"
     let result = header
     let used = header.length
+    let injectedCount = 0
+    const scopesSeen = new Set<string>()
 
     for (const block of blocks) {
       if (isExpired(block)) continue
@@ -34,6 +37,20 @@ export namespace MemoryPrompt {
       if (used + needed > budget) break
       result += "\n" + formatted + "\n"
       used += needed
+      injectedCount++
+      scopesSeen.add(block.scope)
+    }
+
+    if (injectedCount > 0) {
+      Telemetry.track({
+        type: "memory_injection",
+        timestamp: Date.now(),
+        session_id: Telemetry.getContext().sessionId,
+        block_count: injectedCount,
+        total_chars: used,
+        budget,
+        scopes_used: [...scopesSeen],
+      })
     }
 
     return result

packages/opencode/src/memory/store.ts

@@ -4,6 +4,7 @@ import path from "path"
 import { Global } from "@/global"
 import { Instance } from "@/project/instance"
 import { MEMORY_MAX_BLOCK_SIZE, MEMORY_MAX_BLOCKS_PER_SCOPE, MemoryBlockSchema, type MemoryBlock, type Citation } from "./types"
+import { Telemetry } from "@/altimate/telemetry"
 
 const FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/
 
@@ -232,6 +233,18 @@ export namespace MemoryStore {
     const action = isUpdate ? "UPDATE" : "CREATE"
     await appendAuditLog(block.scope, auditEntry(action, block.id, block.scope))
 
+    Telemetry.track({
+      type: "memory_operation",
+      timestamp: Date.now(),
+      session_id: Telemetry.getContext().sessionId,
+      operation: "write",
+      scope: block.scope,
+      block_id: block.id,
+      is_update: isUpdate,
+      duplicate_count: duplicates.length,
+      tags_count: block.tags.length,
+    })
+
     // Auto-clean expired blocks AFTER successful write to avoid data loss
     if (needsCleanup) {
       const expiredBlocks = allBlocks.filter((b) => isExpired(b))
@@ -248,6 +261,17 @@ export namespace MemoryStore {
     try {
       await fs.unlink(filepath)
       await appendAuditLog(scope, auditEntry("DELETE", id, scope))
+      Telemetry.track({
+        type: "memory_operation",
+        timestamp: Date.now(),
+        session_id: Telemetry.getContext().sessionId,
+        operation: "delete",
+        scope,
+        block_id: id,
+        is_update: false,
+        duplicate_count: 0,
+        tags_count: 0,
+      })
       return true
     } catch (e: any) {
       if (e.code === "ENOENT") return false

packages/opencode/src/session/prompt.ts

@@ -17,6 +17,7 @@ import { Bus } from "../bus"
 import { ProviderTransform } from "../provider/transform"
 import { SystemPrompt } from "./system"
 import { InstructionPrompt } from "./instruction"
+import { MemoryPrompt } from "../memory/prompt"
 import { Plugin } from "../plugin"
 import PROMPT_PLAN from "../session/prompt/plan.txt"
 import BUILD_SWITCH from "../session/prompt/build-switch.txt"
@@ -712,8 +713,11 @@ export namespace SessionPrompt {
       await Plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
 
       // Build system prompt, adding structured output instruction if needed
+      // Inject persistent memory blocks from previous sessions (gated by feature flag)
+      const memoryInjection = Flag.ALTIMATE_DISABLE_MEMORY ? "" : await MemoryPrompt.inject()
       const system = [
         ...(await SystemPrompt.environment(model)),
+        ...(memoryInjection ? [memoryInjection] : []),
         ...(await InstructionPrompt.system()),
         ...(lastUser.system ? [lastUser.system] : []),
       ]