fix: restore custom compaction logic and fix CI test failures

- Restore our `isOverflow` formula with safety guard and unified headroom
  (upstream simplified it but introduced a bug with small-context models
  where `context == maxOutput` causes `usable=0` and premature compaction)
- Restore observation masks, telemetry tracking, compaction attempt
  counting, and Data Context section in compaction prompt
- Fix `project.test.ts`: source writes `.git/opencode` (internal identifier
  in `preservePatterns`), not `.git/altimate` — tests were over-branded
- Fix `publish-package.test.ts`: `bin["altimate"]` points to
  `./bin/altimate-code`, not `./bin/altimate`

All custom additions marked with `altimate_change` comments for merge safety.

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

Author: anandgupta42

packages/opencode/src/session/compaction.ts

@@ -14,11 +14,55 @@ import { Agent } from "@/agent/agent"
 import { Plugin } from "@/plugin"
 import { Config } from "@/config/config"
 import { ProviderTransform } from "@/provider/transform"
+import { Telemetry } from "@/telemetry"
 import { ModelID, ProviderID } from "@/provider/schema"
 
 export namespace SessionCompaction {
   const log = Log.create({ service: "session.compaction" })
 
+  // altimate_change: observation masks for pruned tool outputs
+  function formatBytes(bytes: number): string {
+    if (bytes < 1024) return `${bytes} B`
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+  }
+
+  function truncateArgs(input: Record<string, any> | null | undefined, maxLen: number): string {
+    if (!input || typeof input !== "object") return ""
+    let str: string
+    try {
+      str = Object.entries(input)
+        .map(([k, v]) => `${k}: ${JSON.stringify(v)}`)
+        .join(", ")
+    } catch {
+      return "[unserializable]"
+    }
+    if (str.length <= maxLen) return str
+    let end = maxLen
+    const code = str.charCodeAt(end - 1)
+    if (code >= 0xd800 && code <= 0xdbff) end--
+    return str.slice(0, end) + "…"
+  }
+
+  export function createObservationMask(part: MessageV2.ToolPart): string {
+    const output =
+      (part.state.status === "completed" ? part.state.output : "") || ""
+    const lines = output.split("\n").length
+    const bytes = Buffer.byteLength(output, "utf8")
+    const args = truncateArgs(
+      part.state.status === "completed" ||
+        part.state.status === "running" ||
+        part.state.status === "error"
+        ? part.state.input
+        : {},
+      80,
+    )
+    const firstLine = output.split("\n")[0]?.slice(0, 80) || ""
+    const fingerprint = firstLine ? ` — "${firstLine}"` : ""
+    return `[Tool output cleared — ${part.tool}(${args}) returned ${lines} lines, ${formatBytes(bytes)}${fingerprint}]`
+  }
+  // end altimate_change
+
   export const Event = {
     Compacted: BusEvent.define(
       "session.compacted",
@@ -30,6 +74,8 @@ export namespace SessionCompaction {
 
   const COMPACTION_BUFFER = 20_000
 
+  // altimate_change: improved isOverflow formula with safety guard and unified headroom
+  // See PR #35 — fixes upstream bugs with limit.input models and small-context models
   export async function isOverflow(input: { tokens: MessageV2.Assistant["tokens"]; model: Provider.Model }) {
     const config = await Config.get()
     if (config.compaction?.auto === false) return false
@@ -40,13 +86,14 @@ export namespace SessionCompaction {
       input.tokens.total ||
       input.tokens.input + input.tokens.output + input.tokens.cache.read + input.tokens.cache.write
 
-    const reserved =
-      config.compaction?.reserved ?? Math.min(COMPACTION_BUFFER, ProviderTransform.maxOutputTokens(input.model))
-    const usable = input.model.limit.input
-      ? input.model.limit.input - reserved
-      : context - ProviderTransform.maxOutputTokens(input.model)
-    return count >= usable
+    const maxOutput = ProviderTransform.maxOutputTokens(input.model)
+    const reserved = config.compaction?.reserved ?? COMPACTION_BUFFER
+    const headroom = Math.max(reserved, maxOutput)
+    const base = input.model.limit.input ?? context
+    if (base <= headroom) return false
+    return count >= base - headroom
   }
+  // end altimate_change
 
   export const PRUNE_MINIMUM = 20_000
   export const PRUNE_PROTECT = 40_000
@@ -91,14 +138,34 @@ export namespace SessionCompaction {
     if (pruned > PRUNE_MINIMUM) {
       for (const part of toPrune) {
         if (part.state.status === "completed") {
+          // altimate_change: observation masks for pruned tool outputs
+          const mask = createObservationMask(part)
           part.state.time.compacted = Date.now()
+          part.state.metadata = {
+            ...part.state.metadata,
+            observation_mask: mask,
+          }
+          // end altimate_change
           await Session.updatePart(part)
         }
       }
       log.info("pruned", { count: toPrune.length })
+      // altimate_change: telemetry for pruning
+      Telemetry.track({
+        type: "tool_outputs_pruned",
+        timestamp: Date.now(),
+        session_id: input.sessionID,
+        count: toPrune.length,
+        tokens_pruned: pruned,
+      })
+      // end altimate_change
     }
   }
 
+  // altimate_change: compaction attempt tracking for loop protection
+  const compactionAttempts = new Map<string, number>()
+  // end altimate_change
+
   export async function process(input: {
     parentID: MessageID
     messages: MessageV2.WithParts[]
@@ -107,6 +174,20 @@ export namespace SessionCompaction {
     auto: boolean
     overflow?: boolean
   }) {
+    // altimate_change: telemetry and attempt tracking
+    const attempt = (compactionAttempts.get(input.sessionID) ?? 0) + 1
+    compactionAttempts.set(input.sessionID, attempt)
+    input.abort.addEventListener("abort", () => {
+      compactionAttempts.delete(input.sessionID)
+    }, { once: true })
+    Telemetry.track({
+      type: "compaction_triggered",
+      timestamp: Date.now(),
+      session_id: input.sessionID,
+      trigger: input.auto ? "overflow_detection" : "error_recovery",
+      attempt,
+    })
+    // end altimate_change
     const userMessage = input.messages.findLast((m) => m.info.id === input.parentID)!.info as MessageV2.User
 
     let messages = input.messages
@@ -186,6 +267,15 @@ When constructing the summary, try to stick to this template:
 - [What important instructions did the user give you that are relevant]
 - [If there is a plan or spec, include information about it so next agent can continue using it]
 
+## Data Context
+
+- [What warehouse(s) or database(s) are we connected to?]
+- [What schemas, tables, or columns were discovered or are relevant?]
+- [What dbt models, sources, or tests are involved?]
+- [Any lineage findings (upstream/downstream dependencies)?]
+- [Any query patterns, anti-patterns, or optimization opportunities found?]
+- [Skip this section entirely if the task is not data-engineering related]
+
 ## Discoveries
 
 [What notable things were learned during this conversation that would be useful for the next agent to know when continuing the work]
@@ -289,8 +379,12 @@ When constructing the summary, try to stick to this template:
         })
       }
     }
-    if (processor.message.error) return "stop"
+    if (processor.message.error) {
+      compactionAttempts.delete(input.sessionID) // altimate_change
+      return "stop"
+    }
     Bus.publish(Event.Compacted, { sessionID: input.sessionID })
+    compactionAttempts.delete(input.sessionID) // altimate_change
     return "continue"
   }
 

packages/opencode/test/install/publish-package.test.ts

@@ -42,7 +42,7 @@ describe("publish package validation", () => {
   test("bin entries are correct", () => {
     const pkg = JSON.parse(fs.readFileSync(path.join(REPO_PKG_DIR, "package.json"), "utf-8"))
     expect(pkg.bin).toBeDefined()
-    expect(pkg.bin["altimate"]).toBe("./bin/altimate")
+    expect(pkg.bin["altimate"]).toBe("./bin/altimate-code")
     expect(pkg.bin["altimate-code"]).toBe("./bin/altimate-code")
   })
 

packages/opencode/test/project/project.test.ts

@@ -80,7 +80,7 @@ describe("Project.fromDirectory", () => {
     expect(project.vcs).toBe("git")
     expect(project.worktree).toBe(tmp.path)
 
-    const opencodeFile = path.join(tmp.path, ".git", "altimate")
+    const opencodeFile = path.join(tmp.path, ".git", "opencode")
     const fileExists = await Filesystem.exists(opencodeFile)
     expect(fileExists).toBe(false)
   })
@@ -96,7 +96,7 @@ describe("Project.fromDirectory", () => {
     expect(project.vcs).toBe("git")
     expect(project.worktree).toBe(tmp.path)
 
-    const opencodeFile = path.join(tmp.path, ".git", "altimate")
+    const opencodeFile = path.join(tmp.path, ".git", "opencode")
     const fileExists = await Filesystem.exists(opencodeFile)
     expect(fileExists).toBe(true)
   })
@@ -105,11 +105,11 @@ describe("Project.fromDirectory", () => {
     const p = await loadProject()
     await using tmp = await tmpdir({ git: true })
 
-    // First call creates .git/altimate with the project id
+    // First call creates .git/opencode with the project id
     const { project: first } = await p.fromDirectory(tmp.path)
     expect(first.id).not.toBe("global")
 
-    const newFile = path.join(tmp.path, ".git", "altimate")
+    const newFile = path.join(tmp.path, ".git", "opencode")
     const legacyFile = path.join(tmp.path, ".git", "altimate-code")
 
     // Move the new file to the legacy location to simulate an old installation