Your Overnight Session Wakes Up at 3GB — Four Places Memory Piles Up, and How to Tell Them Apart

#!/usr/bin/env bash
# rss-sampler.sh — record RSS of Claude Code and its children every minute
# usage: ./rss-sampler.sh out.csv 60
set -euo pipefail
 
OUT="${1:-rss.csv}"
INTERVAL="${2:-60}"
 
# collect descendant PIDs recursively
descendants() {
  local pid=$1
  local children
  children=$(pgrep -P "$pid" 2>/dev/null || true)
  for c in $children; do
    echo "$c"
    descendants "$c"
  done
}
 
echo "ts,pid,rss_kb,command" > "$OUT"
 
while true; do
  TS=$(date +%Y-%m-%dT%H:%M:%S)
 
  # find claude processes (pick up every session if several are running)
  ROOTS=$(pgrep -f '(^|/)claude( |$)' 2>/dev/null || true)
  if [ -z "$ROOTS" ]; then
    echo "$TS,,,no-process" >> "$OUT"
    sleep "$INTERVAL"
    continue
  fi
 
  for root in $ROOTS; do
    ALL="$root $(descendants "$root")"
    for pid in $ALL; do
      # ps -o rss=,comm= behaves the same on macOS and Linux
      LINE=$(ps -o rss=,comm= -p "$pid" 2>/dev/null || true)
      [ -z "$LINE" ] && continue
      RSS=$(echo "$LINE" | awk '{print $1}')
      CMD=$(echo "$LINE" | awk '{$1=""; sub(/^ /,""); print}')
      echo "$TS,$pid,$RSS,\"$CMD\"" >> "$OUT"
    done
  done
 
  sleep "$INTERVAL"
done

./rss-sampler.sh ~/logs/rss-$(date +%Y%m%d).csv 60 &
SAMPLER=$!
claude -p "$(cat nightly-task.md)" --output-format stream-json > ~/logs/session.jsonl
kill "$SAMPLER"

#!/usr/bin/env python3
"""rss-slope.py — report growth (MB/h) from RSS samples.
usage: python3 rss-slope.py rss.csv
"""
import csv
import sys
from collections import defaultdict
from datetime import datetime
 
def load(path):
    """sum RSS across all processes per timestamp"""
    totals = defaultdict(int)
    per_cmd = defaultdict(lambda: defaultdict(int))
    with open(path, newline="", encoding="utf-8") as f:
        for row in csv.DictReader(f):
            if not row["rss_kb"]:
                continue
            ts = datetime.fromisoformat(row["ts"])
            kb = int(row["rss_kb"])
            totals[ts] += kb
            per_cmd[row["command"].strip('"')][ts] += kb
    return totals, per_cmd
 
def slope_mb_per_hour(series):
    """least squares slope (x = elapsed hours, y = RSS in MB)"""
    items = sorted(series.items())
    if len(items) < 3:
        return None, None, None
    t0 = items[0][0]
    xs = [(t - t0).total_seconds() / 3600 for t, _ in items]
    ys = [kb / 1024 for _, kb in items]
    n = len(xs)
    mx = sum(xs) / n
    my = sum(ys) / n
    denom = sum((x - mx) ** 2 for x in xs)
    if denom == 0:
        return None, None, None
    slope = sum((x - mx) * (y - my) for x, y in zip(xs, ys)) / denom
    return slope, ys[0], max(ys)
 
def main():
    totals, per_cmd = load(sys.argv[1])
    slope, start, peak = slope_mb_per_hour(totals)
    if slope is None:
        print("not enough samples")
        return
    print(f"TOTAL  start {start:7.0f} MB / peak {peak:7.0f} MB / slope {slope:+7.1f} MB/h")
    print("-" * 62)
    rows = []
    for cmd, series in per_cmd.items():
        s, st, pk = slope_mb_per_hour(series)
        if s is None:
            continue
        rows.append((s, cmd, st, pk))
    for s, cmd, st, pk in sorted(rows, reverse=True):
        print(f"{cmd[:28]:28s} start {st:6.0f} / peak {pk:6.0f} / slope {s:+7.1f} MB/h")
 
if __name__ == "__main__":
    main()

// mcp-server/src/truncate.ts
const MAX_ROWS = 60;
const MAX_CHARS = 8_000;
 
type ToolResult = { content: Array<{ type: "text"; text: string }> };
 
/**
 * Cap a tool result on both rows and characters.
 * Always keep the fact of omission and the total count — the number
 * alone is enough for the model to decide it needs to narrow the query.
 */
export function capResult(rows: string[], label: string): ToolResult {
  const total = rows.length;
  let shown = rows.slice(0, MAX_ROWS);
 
  let text = shown.join("\n");
  if (text.length > MAX_CHARS) {
    // over the char budget: trim rows further (insurance against very long lines)
    while (shown.length > 1 && text.length > MAX_CHARS) {
      shown = shown.slice(0, Math.floor(shown.length * 0.8));
      text = shown.join("\n");
    }
  }
 
  const omitted = total - shown.length;
  const footer =
    omitted > 0
      ? `\n\n[${label}: showing ${shown.length} of ${total} / ${omitted} omitted]`
      : `\n\n[${label}: ${total} total]`;
 
  return { content: [{ type: "text", text: text + footer }] };
}

// progress logs off by default; open them with an env var when debugging
const VERBOSE = process.env.MCP_VERBOSE === "1";
 
export function trace(msg: string) {
  if (!VERBOSE) return;
  process.stderr.write(`${new Date().toISOString()} ${msg}\n`);
}

#!/usr/bin/env bash
# rss-watchdog.sh — fold and resume a session when RSS crosses a threshold
# usage: ./rss-watchdog.sh 2048 task.md checkpoint.json
set -euo pipefail
 
THRESHOLD_MB="${1:-2048}"
TASK_FILE="${2:?task file required}"
CHECKPOINT="${3:-checkpoint.json}"
MAX_ROUNDS=6
 
tree_rss_mb() {
  local root=$1 total=0
  local pids
  pids="$root $(pgrep -P "$root" 2>/dev/null || true)"
  for p in $pids; do
    local kb
    kb=$(ps -o rss= -p "$p" 2>/dev/null | tr -d ' ' || true)
    [ -n "${kb:-}" ] && total=$((total + kb))
  done
  echo $((total / 1024))
}
 
for round in $(seq 1 "$MAX_ROUNDS"); do
  echo "[round $round] start"
 
  # hand the checkpoint over so the run is resumable
  claude -p "$(cat "$TASK_FILE")
 
  Read progress from ${CHECKPOINT} and skip anything already done.
  Update ${CHECKPOINT} after every completed step." \
    --output-format stream-json > "session-${round}.jsonl" &
  PID=$!
 
  while kill -0 "$PID" 2>/dev/null; do
    MB=$(tree_rss_mb "$PID")
    if [ "$MB" -gt "$THRESHOLD_MB" ]; then
      echo "[round $round] RSS ${MB}MB > ${THRESHOLD_MB}MB — folding"
      kill -TERM "$PID" 2>/dev/null || true
      sleep 20
      kill -KILL "$PID" 2>/dev/null || true
      break
    fi
    sleep 30
  done
  wait "$PID" 2>/dev/null || true
 
  # stop once the checkpoint reports completion
  if grep -q '"done"[[:space:]]*:[[:space:]]*true' "$CHECKPOINT" 2>/dev/null; then
    echo "finished on round $round"
    exit 0
  fi
  echo "[round $round] resuming"
done
 
echo "hit the round limit — inspect the checkpoint" >&2
exit 1