TUI crashes with JavaScript heap OOM during long agentic sessions (25+ tool-call steps)

[gokcanakalin]

SUMMARY:
Environment: Windows 11 Home, PowerShell 7, atomic-agent v0.1.72, cloud mode (DeepSeek via OpenRouter)

Trigger: Single turn with 25 agentic steps reading large source files

Error: FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory at ~4GB V8 heap
NDJSON trace, text export, and screenshot attached

Root cause: TUI retains full conversation + tool outputs in React/Ink state without conversation windowing or pruning

FULL:

The atomic-agent crashed with a
JavaScript heap out of memory (OOM) error after approximately 25+
tool-call steps and 40+ minutes of operation. The crash was caused by
unbounded growth of the conversation state in the agent's TUI, which
retained full conversation history, tool outputs, and internal state
without pruning.

Root Cause:
The atomic-agent's TUI (built with React/Ink) does not implement
conversation windowing or pruning. As the session progresses, the
agent accumulates:

• All user messages
• All agent responses (including internal reasoning)
• All tool outputs (including large JSON responses from MCP servers)
• Internal state (token counts, timing, model metadata)

This results in monotonic memory growth, eventually exhausting the
default 4GB Node.js V8 heap limit.

Evidence from Sanitized Trace:
The sanitized NDJSON trace (trace-sanitized.ndjson) shows:

• 215 total events spanning ~2400 seconds
• Monotonic increase in token counts across events (prompt_tokens,
  completion_tokens)
• Tool outputs growing in size (e.g., web_search results, web_fetch
  content, file reads)
• Final events show token counts in the tens of thousands before crash
• The crash event (FATAL ERROR) occurs after event feat(tui): Send moves inside the composer field #215

Specifically, the trace reveals that the agent's internal state
includes full copies of:

• Web search results (snippets, URLs)
• Web fetched content (full markdown/text)
• File contents (when using read_file or similar)
• Tool invocation details (parameters, results)

Impact:

• Loss of the current agent session, requiring restart
• Potential loss of unsaved work if not persisted elsewhere
• Need to re-establish context after restart
• Disruption to any ongoing automated tasks

Attachments:

1. trace-sanitized.ndjson - Sanitized NDJSON trace (215 events, all PII removed)
2. powershell-crash-sanitized.txt - Sanitized PowerShell crash output
   (GC logs, FATAL ERROR, stack trace)
3. screenshot-sanitized.png - Sanitized screenshot of the agent TUI at
   crash time

powershell-crash-sanitized.txt

trace-sanitized.zip

[yablokolabs]

Fix: #214

Root cause was SessionState.turns[] growing unbounded — the TUI side (feed, messages, reasoning) was already capped by pushRing with ringBufferSize, but turns[] kept every tool_call/tool_result/reply forever.

The fix applies packConversation's token-based windowing at the persistence boundary: after each runTurn, old turns beyond conversationMaxTokens are dropped and replaced with a compact summary line. The next prompt build sees the pruned state. Zero-cost when turns already fit within budget.

[sosidudku1]

Update, and an apology for the wait on #214.

We dug into the crash evidence you attached, and it points somewhere other than conversation state. The process died at 4083 MB against a ~4288 MB ceiling — Node's default, since the SEA build sets no --max-old-space-size. A full mark-compact freed only ~11 MB, so the memory was retained rather than uncollected. And the session was only 6 turns / 30 steps, with roughly 22 of the 34 minutes spent idle between turns. Growth tracked wall-clock, not work.

That last point is the tell. #232 found that the shipped binary was running React's development build: scripts/bundle-sea.ts never baked in NODE_ENV, so the dev reconciler ran on every install. React 19's dev build emits a performance.measure() per component render, Node retains user-timing entries for the life of the process, and the TUI redraws on a timer even while idle. That matches an idle-time leak far better than turn history does.

We measured the TUI reducer state directly (6 turns × 25 steps, 64 KB results): ~0 MB retained. The session transcript at 312 turns: under 1 MB. So SessionState.turns[] is real unbounded growth worth fixing, but it is not what consumed 4 GB here.

Where that leaves your PR: #255 bounds four unbounded-growth paths, including the same conversation-turn.ts windowing you wrote, and adds a heap-pressure warning so this stops being a silent death. It touches the same file, so the two cannot both land. We are going to close #214 in favour of it — not because the code was wrong, but because the retainer turned out to be elsewhere.

Your NDJSON trace and crash log are what made the real diagnosis possible. Thank you for filing this properly.