Harden tools, compaction, and prompt layers for long-horizon autonomous runs (#118)

* fix(agent): harden tools, compaction, and prompt for long-horizon runs

Audit of jcode vs Claude Code and codex (32 findings, tracked with
per-case status in internal-doc/tooling-audit.md); all confirmed cases
fixed with TDD across four waves:

Tools
- execute: head+tail truncation with dropped-bytes marker, full output
  spilled to ~/.jcode/tasks and the path returned to the model
- exec lifecycle: process-group kill via new internal/procutil (Setpgid
  + Kill(-pid)), WaitDelay=2s with ErrWaitDelay folded to success,
  SSH SIGTERM->SIGKILL grace, Docker in-container pidfile tree kill
- read: 200KB output budget with offset continuation + 2000-byte
  per-line truncation (UTF-8 safe)
- glob: find -name replaced with cd+rg --files --glob --sortr=modified
  (fixes silently-broken ** recursion, adds deterministic mtime order)
- grep: global (not per-file) content limit via streaming early-stop,
  honest capped footer, output_mode enum validation
- edit/write: read-before-edit enforced (ConflictNeverRead; FileTracker
  now actually wired in NewEnv), atomic writes (temp+fsync+rename, SSH
  base64+mv -f), multi-edit overlap/ambiguity guards + per-op
  replace_all, item schemas for edits/todos arrays
- background tasks: head+tail truncation, task log always written and
  its path surfaced to the model
- errors: Fatal/IsFatal layer aborts runs on dead container/SSH,
  subagent safe middleware (panic recovery + error folding + parent
  propagation, async panic no longer crashes the process), ToolError
  hints on high-frequency failures

Compaction
- occupancy reminder now uses last-call total (GetLastTotal) instead of
  the cumulative ledger — fixes permanently >100% "wrap up" pressure
  after any compaction
- crude 500-char threshold strategy demoted to fallback-only behind the
  eino summarizer; compact failure fuse (3 strikes, fail-open)
- output-reserve headroom (EffectiveContextLimit) for trigger math
- compaction persists the kept tail; TUI resume no longer loses it
- reduction config single-sourced (BuildReductionConfig) across
  TUI/ACP/Web, calibrated token estimator (ASCII/3.6 + CJK-aware + EMA
  self-calibration from provider usage) replaces len/4, per-turn
  aggregate tool-result budget (150k chars, copy-on-write)

Prompt
- env/git drift re-collected every 5 iterations and injected as a diff
  (includes date rollover); AGENTS.md hot-reloaded on mtime+hash change;
  externally-modified files reported with a re-read instruction
- system.md: parallel tool-call batching directive + Verification
  discipline section

Verified by ~90 new TDD tests (red first), full-repo go test -count=1,
-race on tools/agent, GOOS=windows build, and a new agent-eval ACP e2e
(robust_huge_output: seq 1 200000 truncated to marker+tail, session
survives, oracle-checked answer) passing against a live model.

Generated with Jack AI bot

* chore: resolve golangci-lint findings in new code

errcheck on discarded Count returns, De Morgan simplification,
embedded-field selector cleanup, and two unparam removals
(execLocal constant timeout, buildRgArgs unused maxResults).

Generated with Jack AI bot

* fix(git): scrub inherited GIT_* env from every git subprocess

git exports an absolute GIT_DIR to hook subprocesses when pushing from a
linked worktree. jcode's git calls (envinfo, web git API, session
baseline/diff stats) and the web test helper inherited it, silently
operating on the outer repository instead of the -C/cwd-selected one —
the web suite's `git init` in a temp dir re-initialized the pushing repo
as bare when run under the pre-push hook.

Add util.ScrubbedGitEnv() (drops GIT_DIR/GIT_WORK_TREE/GIT_INDEX_FILE/
GIT_COMMON_DIR and friends), apply it at all production git call sites,
and pin GIT_DIR/GIT_WORK_TREE to the temp repo in the web test helper.
Regression-tested by running the web suite under a hostile GIT_DIR
against a victim repo (stays non-bare) plus unit tests for the scrubber
and for gitCommand under an inherited GIT_DIR.

Recorded as finding #33 in internal-doc/tooling-audit.md.

Generated with Jack AI bot

* fix(agent): address review findings — live-env reminders, calibration recovery, docker fatal coverage

- reminder: read remote-ness from the live *tools.Env each round (switch_env
  mutates it in place without an agent rebuild on ACP/web); pause the
  env-drift / AGENTS.md / external-file sweeps while remote so local-host
  state is never reported as drift of the remote machine, and resume with
  the same baselines after switching back
- token estimate: a sustained streak of below-peak counts adopts the shrunk
  window as the new full baseline, so calibration resumes after compaction
  instead of freezing on the stale peak
- docker exec: route stream-copy and inspect errors through wrapDockerRunErr
  so a container removed mid-exec is classified Fatal like create/attach
- glob: resolve a relative search path against the tool workspace instead of
  the process cwd; make the mtime-order test deterministic via os.Chtimes
- compaction: refuse to apply an empty strategy result (counts toward the
  fuse instead of wiping the conversation)

Generated with Jack AI bot

---------

Co-authored-by: t <t@example.com>

Author: cnjack

agent-eval/suite/testcases.json

@@ -1007,6 +1007,23 @@
           "path": "hook-ran.txt"
         }
       ]
+    },
+    {
+      "id": "robust_huge_output",
+      "title": "Huge command output is truncated (head+tail+spill), session survives and stays correct",
+      "category": "robustness",
+      "tier": "core",
+      "prompt": "Run the shell command `seq 1 200000` exactly as written (do not paraphrase it, do not pipe it through tail or head on the first run). Its output may be truncated by the tool; the truncation notice preserves the tail of the output and tells you where the full output was saved. Then create a file named answer.txt whose exact contents are the last number that command printed, with no trailing newline.",
+      "fixtures": {},
+      "timeout": 300,
+      "expect_tool_use": true,
+      "oracles": [
+        {
+          "type": "file_equals",
+          "path": "answer.txt",
+          "expected": "200000"
+        }
+      ]
     }
   ]
 }

go.mod

@@ -12,6 +12,7 @@ require (
 	github.com/cloudwego/eino-ext/components/tool/mcp v0.0.8
 	github.com/cloudwego/eino-ext/libs/acl/langfuse v0.1.1
 	github.com/coder/acp-go-sdk v0.13.5
+	github.com/containerd/errdefs v1.0.0
 	github.com/creack/pty v1.1.24
 	github.com/docker/docker v28.5.2+incompatible
 	github.com/google/uuid v1.6.0
@@ -48,7 +49,6 @@ require (
 	github.com/clipperhouse/displaywidth v0.11.0 // indirect
 	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
 	github.com/cloudwego/base64x v0.1.6 // indirect
-	github.com/containerd/errdefs v1.0.0 // indirect
 	github.com/containerd/errdefs/pkg v0.3.0 // indirect
 	github.com/containerd/log v0.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect

internal-doc/tooling-audit.md

@@ -101,7 +101,9 @@ func (s *ThresholdCompactionStrategy) Compact(ctx context.Context, messages []*s
 	summaryMsg, err := s.summarizer.Generate(ctx, summaryInput)
 	if err != nil {
 		config.Logger().Printf("[compaction] summarisation failed: %v", err)
-		return messages, nil // fail-open: return original messages
+		// Propagate the error so the middleware can count it towards its
+		// fuse; the caller keeps the original messages (fail-open).
+		return messages, err
 	}
 
 	summaryMessage := &schema.Message{
@@ -125,13 +127,18 @@ func truncate(s string, maxLen int) string {
 	return s[:maxLen] + "…"
 }
 
+// maxConsecutiveCompactFails is the fuse limit: after this many consecutive
+// compaction failures (summarizer errors or no-shrink results) the middleware
+// stops attempting automatic compaction for the rest of the session, instead
+// of burning tokens and latency on a summarizer that keeps failing.
+const maxConsecutiveCompactFails = 3
+
 // CompactionState tracks compaction history for diagnostics.
 type CompactionState struct {
 	mu               sync.Mutex
 	compactionCount  int
 	savedTokens      int
 	consecutiveFails int
-	tripped          bool
 }
 
 // CompactionCount returns how many compactions have occurred.
@@ -157,6 +164,9 @@ type compactionMiddleware struct {
 	contextLimit int
 	onCompact    func(savedTokens int)
 	tokenUsage   *internalmodel.TokenUsage
+	// fuseLogOnce ensures the "compaction disabled" log fires once per session
+	// instead of on every model call after the fuse blows.
+	fuseLogOnce sync.Once
 }
 
 // NewCompactionMiddleware creates a ChatModelAgentMiddleware that monitors
@@ -193,6 +203,18 @@ func (m *compactionMiddleware) BeforeModelRewriteState(
 		return ctx, state, nil
 	}
 
+	// Fuse: after repeated failures, stop retrying the summarizer for the
+	// rest of the session — each retry costs tokens and latency for nothing.
+	m.state.mu.Lock()
+	fails := m.state.consecutiveFails
+	m.state.mu.Unlock()
+	if fails >= maxConsecutiveCompactFails {
+		m.fuseLogOnce.Do(func() {
+			config.Logger().Printf("[compaction] disabled for this session after %d consecutive failures", fails)
+		})
+		return ctx, state, nil
+	}
+
 	config.Logger().Printf("[compaction] triggered: tokens=%d, limit=%d", currentTokens, m.contextLimit)
 
 	beforeLen := len(state.Messages)
@@ -206,13 +228,23 @@ func (m *compactionMiddleware) BeforeModelRewriteState(
 	}
 
 	saved := beforeLen - len(compacted)
+	if saved <= 0 || len(compacted) == 0 {
+		// Compacted nothing (e.g. a single poison message larger than the
+		// window) — or a strategy returned an empty slice with a nil error,
+		// which would silently wipe the conversation if applied. Both are
+		// non-error failures that still count towards the fuse.
+		config.Logger().Printf("[compaction] no shrink: %d → %d messages", beforeLen, len(compacted))
+		m.state.mu.Lock()
+		m.state.consecutiveFails++
+		m.state.mu.Unlock()
+		return ctx, state, nil
+	}
 	state.Messages = compacted
 
 	m.state.mu.Lock()
 	m.state.compactionCount++
 	m.state.savedTokens += saved
 	m.state.consecutiveFails = 0
-	m.state.tripped = true
 	m.state.mu.Unlock()
 
 	config.Logger().Printf("[compaction] compacted %d messages → %d (saved %d)", beforeLen, len(compacted), saved)

internal/agent/compaction.go

@@ -0,0 +1,184 @@
+package agent
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/cloudwego/eino/adk"
+	einomodel "github.com/cloudwego/eino/components/model"
+	"github.com/cloudwego/eino/schema"
+)
+
+// stubStrategy is a CompactionStrategy whose Compact behaviour is scripted per
+// call, for driving the middleware directly (same style as budget_test.go).
+type stubStrategy struct {
+	compactCalls int
+	fn           func(call int, msgs []*schema.Message) ([]*schema.Message, error)
+}
+
+func (s *stubStrategy) ShouldCompact(currentTokens, limit int) bool { return true }
+
+func (s *stubStrategy) Compact(ctx context.Context, msgs []*schema.Message, keepRecent int) ([]*schema.Message, error) {
+	s.compactCalls++
+	return s.fn(s.compactCalls, msgs)
+}
+
+// errGenModel is a ToolCallingChatModel whose Generate always fails, standing
+// in for a broken summarizer.
+type errGenModel struct{}
+
+func (errGenModel) Generate(context.Context, []*schema.Message, ...einomodel.Option) (*schema.Message, error) {
+	return nil, errors.New("summarizer boom")
+}
+
+func (errGenModel) Stream(context.Context, []*schema.Message, ...einomodel.Option) (*schema.StreamReader[*schema.Message], error) {
+	panic("Stream is not used by the compaction strategy")
+}
+
+func (m errGenModel) WithTools([]*schema.ToolInfo) (einomodel.ToolCallingChatModel, error) {
+	return m, nil
+}
+
+func newTestState(n int) *adk.ChatModelAgentState {
+	msgs := make([]adk.Message, 0, n)
+	for i := 0; i < n; i++ {
+		if i%2 == 0 {
+			msgs = append(msgs, schema.UserMessage("u"))
+		} else {
+			msgs = append(msgs, &schema.Message{Role: schema.Assistant, Content: "a"})
+		}
+	}
+	return &adk.ChatModelAgentState{Messages: msgs}
+}
+
+func asCompactionMiddleware(t *testing.T, strategy CompactionStrategy) *compactionMiddleware {
+	t.Helper()
+	mw := NewCompactionMiddleware(strategy, 100000, nil, nil)
+	m, ok := mw.(*compactionMiddleware)
+	if !ok {
+		t.Fatalf("NewCompactionMiddleware returned %T, want *compactionMiddleware", mw)
+	}
+	return m
+}
+
+// TestCompactionMiddleware_FuseAfterConsecutiveFails: after 3 consecutive
+// compaction failures the middleware must stop calling the summarizer for the
+// rest of the session (fail-open every time, never an error to the run).
+func TestCompactionMiddleware_FuseAfterConsecutiveFails(t *testing.T) {
+	strategy := &stubStrategy{fn: func(int, []*schema.Message) ([]*schema.Message, error) {
+		return nil, errors.New("boom")
+	}}
+	m := asCompactionMiddleware(t, strategy)
+	state := newTestState(6)
+
+	for i := 0; i < 6; i++ {
+		_, got, err := m.BeforeModelRewriteState(context.Background(), state, nil)
+		if err != nil {
+			t.Fatalf("call %d: err = %v, want nil (fail-open)", i+1, err)
+		}
+		if len(got.Messages) != 6 {
+			t.Fatalf("call %d: messages mutated on failure: %d, want 6", i+1, len(got.Messages))
+		}
+	}
+
+	if strategy.compactCalls != 3 {
+		t.Errorf("Compact called %d times, want exactly 3 (fused from the 4th trigger on)", strategy.compactCalls)
+	}
+	m.state.mu.Lock()
+	fails := m.state.consecutiveFails
+	m.state.mu.Unlock()
+	if fails != 3 {
+		t.Errorf("consecutiveFails = %d, want 3", fails)
+	}
+}
+
+// TestCompactionMiddleware_FuseResetOnSuccess: failures below the fuse limit
+// followed by a success must reset the counter and keep compaction available.
+func TestCompactionMiddleware_FuseResetOnSuccess(t *testing.T) {
+	strategy := &stubStrategy{fn: func(call int, msgs []*schema.Message) ([]*schema.Message, error) {
+		if call <= 2 {
+			return nil, errors.New("boom")
+		}
+		return msgs[:len(msgs)-1], nil // success: shrink by one
+	}}
+	m := asCompactionMiddleware(t, strategy)
+	state := newTestState(6)
+
+	for i := 0; i < 4; i++ {
+		_, got, err := m.BeforeModelRewriteState(context.Background(), state, nil)
+		if err != nil {
+			t.Fatalf("call %d: err = %v, want nil", i+1, err)
+		}
+		state = got
+	}
+
+	if strategy.compactCalls != 4 {
+		t.Errorf("Compact called %d times, want 4 (2 fails below the fuse + 2 successes)", strategy.compactCalls)
+	}
+	if len(state.Messages) != 4 {
+		t.Errorf("messages after two successful compactions = %d, want 4", len(state.Messages))
+	}
+	m.state.mu.Lock()
+	fails, count := m.state.consecutiveFails, m.state.compactionCount
+	m.state.mu.Unlock()
+	if fails != 0 {
+		t.Errorf("consecutiveFails = %d, want 0 after success", fails)
+	}
+	if count != 2 {
+		t.Errorf("compactionCount = %d, want 2", count)
+	}
+}
+
+// TestCompactionMiddleware_NoShrinkCountsAsFail: a Compact that returns no
+// fewer messages (compressed nothing) counts towards the fuse instead of being
+// celebrated as a successful compaction.
+func TestCompactionMiddleware_NoShrinkCountsAsFail(t *testing.T) {
+	strategy := &stubStrategy{fn: func(_ int, msgs []*schema.Message) ([]*schema.Message, error) {
+		return msgs, nil // same length, nil error
+	}}
+	m := asCompactionMiddleware(t, strategy)
+	state := newTestState(6)
+
+	_, got, err := m.BeforeModelRewriteState(context.Background(), state, nil)
+	if err != nil {
+		t.Fatalf("err = %v, want nil", err)
+	}
+	if len(got.Messages) != 6 {
+		t.Fatalf("messages = %d, want 6 (unchanged)", len(got.Messages))
+	}
+
+	m.state.mu.Lock()
+	fails, count := m.state.consecutiveFails, m.state.compactionCount
+	m.state.mu.Unlock()
+	if fails != 1 {
+		t.Errorf("consecutiveFails = %d, want 1 (no-shrink counts as failure)", fails)
+	}
+	if count != 0 {
+		t.Errorf("compactionCount = %d, want 0", count)
+	}
+}
+
+// TestThresholdStrategy_PropagatesSummarizerError: the strategy must surface a
+// summarizer error to its caller (the middleware counts it towards the fuse)
+// instead of swallowing it and reporting a successful no-op.
+func TestThresholdStrategy_PropagatesSummarizerError(t *testing.T) {
+	strategy := NewThresholdCompactionStrategy(0.75, errGenModel{}, 2)
+
+	msgs := make([]*schema.Message, 0, 10)
+	for i := 0; i < 10; i++ {
+		if i%2 == 0 {
+			msgs = append(msgs, schema.UserMessage("u"))
+		} else {
+			msgs = append(msgs, &schema.Message{Role: schema.Assistant, Content: "a"})
+		}
+	}
+
+	got, err := strategy.Compact(context.Background(), msgs, 0)
+	if err == nil {
+		t.Fatal("Compact swallowed the summarizer error, want it propagated")
+	}
+	if len(got) != len(msgs) {
+		t.Errorf("Compact returned %d messages on error, want the original %d (fail-open)", len(got), len(msgs))
+	}
+}

internal/agent/compaction_test.go

@@ -121,7 +121,7 @@ func SyncSummarization(cap *SummarizationCapture, history []adk.Message, rec *se
 	newHistory = append(newHistory, kept...)
 
 	if rec != nil {
-		rec.RecordCompact(summary, compactedN)
+		rec.RecordCompact(summary, compactedN, len(kept))
 	}
 	config.Logger().Printf("[summarization] synced history: %d → %d messages", len(history), len(newHistory))
 	return newHistory