feat: reduce AI context token consumption by collapsing successful builds, using tail-biased truncation, and relaxing verbatim output instructions

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

Author: killme2008

CLAUDE.md

@@ -89,6 +89,8 @@ devtap captures build/dev output from a separate terminal and delivers it here v
 
 **Multi-source mode:** when devtap drains from multiple sources, tags are prefixed with "host/label |" (for example, `[devtap: myhost/local | make]`). "host" is the machine name, "label" identifies the source. Show these prefixes as-is. If output includes source warnings (for example, source unreachable), show those warnings verbatim and continue with output from reachable sources.
 
-**Output format:** when "get_build_errors" returns content, present it verbatim in a fenced code block, then add one line:
-"Next action: <what you will do>".
+**Output format:** when "get_build_errors" returns content:
+If build succeeded, acknowledge briefly (do not repeat the output).
+If build failed, present the error output verbatim in a fenced code block.
+Then add one line: "Next action: <what you will do>".
 <!-- devtap:end -->

cmd/devtap/drain.go

@@ -110,6 +110,7 @@ func runDrain(cmd *cobra.Command, args []string) error {
 		allMessages = mcp.DedupMessages(allMessages)
 	}
 
+	allMessages = mcp.CollapseSuccessful(allMessages)
 	allMessages = mcp.TruncateMessages(allMessages, maxLines)
 
 	// Handle auto-loop Stop hook (Claude Code specific)
@@ -179,6 +180,7 @@ func runDrainSingleSource(cmd *cobra.Command, filterSQL string, maxLines int, ev
 		return fmt.Errorf("drain: %w", err)
 	}
 
+	messages = mcp.CollapseSuccessful(messages)
 	messages = mcp.TruncateMessages(messages, maxLines)
 
 	if event == "Stop" && autoLoop {

internal/adapter/instructions.go

@@ -29,8 +29,10 @@ devtap captures build/dev output from a separate terminal and delivers it here v
 
 **Multi-source mode:** when devtap drains from multiple sources, tags are prefixed with "host/label |" (for example, "[devtap: myhost/local | make]"). "host" is the machine name, "label" identifies the source. Show these prefixes as-is. If output includes source warnings (for example, source unreachable), show those warnings verbatim and continue with output from reachable sources.
 
-**Output format:** when "get_build_errors" returns content, present it verbatim in a fenced code block, then add one line:
-"Next action: <what you will do>".
+**Output format:** when "get_build_errors" returns content:
+If build succeeded, acknowledge briefly (do not repeat the output).
+If build failed, present the error output verbatim in a fenced code block.
+Then add one line: "Next action: <what you will do>".
 <!-- devtap:end -->`
 
 // InstructionBlockLint is the instruction block for lint-based adapters (aider).

internal/filter/truncate.go

@@ -2,24 +2,45 @@ package filter
 
 import "fmt"
 
-// Truncate applies smart truncation to a list of lines:
-// - If lines exceed maxLines, keeps head and tail with an omission notice in between.
-// - Merges consecutive duplicate lines into "(repeated N times)" markers.
-// maxLines <= 0 means no truncation.
+// Truncate applies smart truncation with a 50/50 head/tail split.
+// See TruncateWithRatio for details.
 func Truncate(lines []string, maxLines int) []string {
+	return TruncateWithRatio(lines, maxLines, 0.5)
+}
+
+// TruncateWithRatio applies smart truncation to a list of lines:
+//   - Merges consecutive duplicate lines into "(repeated N times)" markers.
+//   - If lines exceed maxLines, keeps head and tail with an omission notice in between.
+//   - tailRatio controls what fraction of the budget goes to the tail (0.0–1.0).
+//     For build output where errors appear at the end, use tailRatio=0.8.
+//
+// maxLines <= 0 means no truncation.
+func TruncateWithRatio(lines []string, maxLines int, tailRatio float64) []string {
 	lines = dedup(lines)
 
 	if maxLines <= 0 || len(lines) <= maxLines {
 		return lines
 	}
 
-	// Keep roughly half at the head and half at the tail
-	head := maxLines / 2
-	tail := maxLines - head
-	if tail == 0 {
+	// Budget=1: no room for head + omission marker + tail. Just keep the last line.
+	if maxLines == 1 {
+		return lines[len(lines)-1:]
+	}
+
+	tail := int(float64(maxLines) * tailRatio)
+	if tail > maxLines {
+		tail = maxLines
+	}
+	head := maxLines - tail
+	// Ensure at least 1 line on each side when budget allows.
+	if tail == 0 && maxLines > 1 {
 		tail = 1
 		head = maxLines - 1
 	}
+	if head == 0 && maxLines > 1 {
+		head = 1
+		tail = maxLines - 1
+	}
 
 	omitted := len(lines) - head - tail
 	result := make([]string, 0, head+1+tail)

internal/filter/truncate_test.go

@@ -96,3 +96,99 @@ func TestTruncateSingleLine(t *testing.T) {
 		t.Errorf("unexpected result: %v", result)
 	}
 }
+
+func TestTruncateWithRatio_TailBiased(t *testing.T) {
+	// 20 distinct lines, maxLines=10, tailRatio=0.8 → 2 head + 8 tail
+	lines := make([]string, 20)
+	for i := range lines {
+		lines[i] = fmt.Sprintf("line-%d", i)
+	}
+
+	result := TruncateWithRatio(lines, 10, 0.8)
+
+	// 2 head + 1 omission + 8 tail = 11 entries
+	if len(result) != 11 {
+		t.Fatalf("expected 11 lines, got %d: %v", len(result), result)
+	}
+	// First 2 should be head
+	if result[0] != "line-0" || result[1] != "line-1" {
+		t.Errorf("head: got %q, %q", result[0], result[1])
+	}
+	// Omission marker
+	if result[2] != "... (10 lines omitted)" {
+		t.Errorf("omission: got %q", result[2])
+	}
+	// Last 8 should be tail
+	if result[3] != "line-12" || result[10] != "line-19" {
+		t.Errorf("tail: got first=%q last=%q", result[3], result[10])
+	}
+}
+
+func TestTruncateWithRatio_AllHead(t *testing.T) {
+	lines := make([]string, 10)
+	for i := range lines {
+		lines[i] = fmt.Sprintf("line-%d", i)
+	}
+
+	// tailRatio=0.0 → still gets at least 1 tail line
+	result := TruncateWithRatio(lines, 4, 0.0)
+	// 3 head + 1 omission + 1 tail = 5
+	if len(result) != 5 {
+		t.Fatalf("expected 5 lines, got %d: %v", len(result), result)
+	}
+	if result[4] != "line-9" {
+		t.Errorf("last line should be tail, got %q", result[4])
+	}
+}
+
+func TestTruncateWithRatio_AllTail(t *testing.T) {
+	lines := make([]string, 10)
+	for i := range lines {
+		lines[i] = fmt.Sprintf("line-%d", i)
+	}
+
+	// tailRatio=1.0 → still gets at least 1 head line
+	result := TruncateWithRatio(lines, 4, 1.0)
+	// 1 head + 1 omission + 3 tail = 5
+	if len(result) != 5 {
+		t.Fatalf("expected 5 lines, got %d: %v", len(result), result)
+	}
+	if result[0] != "line-0" {
+		t.Errorf("first line should be head, got %q", result[0])
+	}
+	if result[4] != "line-9" {
+		t.Errorf("last line should be tail, got %q", result[4])
+	}
+}
+
+func TestTruncateWithRatio_NoTruncationNeeded(t *testing.T) {
+	lines := []string{"a", "b", "c"}
+	result := TruncateWithRatio(lines, 10, 0.8)
+	if len(result) != 3 {
+		t.Errorf("expected 3 lines (no truncation), got %d", len(result))
+	}
+}
+
+func TestTruncateWithRatio_SingleMax(t *testing.T) {
+	lines := []string{"a", "b", "c"}
+	result := TruncateWithRatio(lines, 1, 0.8)
+	// maxLines=1: return only the last line, no omission marker
+	if len(result) != 1 {
+		t.Fatalf("expected 1 line, got %d: %v", len(result), result)
+	}
+	if result[0] != "c" {
+		t.Errorf("expected last line %q, got %q", "c", result[0])
+	}
+}
+
+func TestTruncateSingleMax_Legacy(t *testing.T) {
+	// Truncate (50/50 ratio) with maxLines=1 should also return exactly 1 line.
+	lines := []string{"x", "y", "z"}
+	result := Truncate(lines, 1)
+	if len(result) != 1 {
+		t.Fatalf("expected 1 line, got %d: %v", len(result), result)
+	}
+	if result[0] != "z" {
+		t.Errorf("expected last line %q, got %q", "z", result[0])
+	}
+}

internal/mcp/collapse.go

@@ -0,0 +1,88 @@
+package mcp
+
+import (
+	"fmt"
+
+	"github.com/killme2008/devtap/internal/store"
+)
+
+// CollapseSuccessful replaces the output of successful build runs (exit code 0)
+// with a single-line summary to reduce context token consumption.
+//
+// A "run" is a sequence of messages sharing the same tag, bounded by an exit
+// code message. When the same tag appears in multiple runs within a single
+// drain window (e.g. a failed build followed by a successful rebuild), each
+// run is evaluated independently — only runs with exit code 0 are collapsed.
+// Runs with non-zero exit code or no exit code are returned unchanged.
+func CollapseSuccessful(messages []store.LogMessage) []store.LogMessage {
+	type run struct {
+		firstIdx int
+		indices  []int
+		exitCode *int
+		lines    int
+	}
+
+	// Work on a copy so we can replace run heads in-place while preserving the
+	// original global message order.
+	result := make([]store.LogMessage, len(messages))
+	copy(result, messages)
+	removed := make([]bool, len(result))
+
+	// current tracks the active (not yet finalized) run per tag.
+	current := make(map[string]*run)
+
+	for i, msg := range result {
+		tag := msg.Tag
+		if tag == "" {
+			tag = "build"
+		}
+
+		r, exists := current[tag]
+		if !exists {
+			r = &run{firstIdx: i}
+			current[tag] = r
+		}
+
+		r.indices = append(r.indices, i)
+		r.lines += len(msg.Lines)
+		if msg.ExitCode != nil {
+			r.exitCode = msg.ExitCode
+			if *r.exitCode == 0 && r.lines > 0 {
+				// Collapse successful run into a single summary message placed at the
+				// first message position to preserve global ordering.
+				first := result[r.firstIdx]
+				result[r.firstIdx] = store.LogMessage{
+					Timestamp: first.Timestamp,
+					Tag:       first.Tag,
+					Stream:    first.Stream,
+					ExitCode:  r.exitCode,
+					Adapter:   first.Adapter,
+					Host:      first.Host,
+					Lines:     []string{collapseMessage(r.lines)},
+				}
+				for _, idx := range r.indices[1:] {
+					removed[idx] = true
+				}
+			}
+			// Finalize this run; next message for the same tag starts a new run.
+			delete(current, tag)
+		}
+	}
+
+	final := make([]store.LogMessage, 0, len(result))
+	for i, msg := range result {
+		if !removed[i] {
+			final = append(final, msg)
+		}
+	}
+
+	return final
+}
+
+func collapseMessage(lineCount int) string {
+	noun := "lines"
+	if lineCount == 1 {
+		noun = "line"
+	}
+	return fmt.Sprintf("(%d %s of output omitted — build succeeded)", lineCount, noun)
+}