夜間セッションの常駐メモリが朝には数GB — 蓄積の四つの出どころと、RSS を刻んで切り分ける

#!/usr/bin/env bash
# rss-sampler.sh — Claude Code とその子プロセスの RSS を毎分記録する
# 使い方: ./rss-sampler.sh out.csv 60
set -euo pipefail
 
OUT="${1:-rss.csv}"
INTERVAL="${2:-60}"
 
# 子孫プロセスの PID を再帰的に集める
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)
 
  # claude 本体を探す（複数セッションがあれば全部拾う）
  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 は macOS / Linux 共通で rss(KB) と comm を返す
      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 — RSS サンプルから増加の傾き（MB/h）を出す。
使い方: python3 rss-slope.py rss.csv
"""
import csv
import sys
from collections import defaultdict
from datetime import datetime
 
def load(path):
    """タイムスタンプごとに全プロセスの RSS を合算する"""
    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):
    """最小二乗で傾きを出す（x=経過時間[h], y=RSS[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("サンプルが足りません")
        return
    print(f"合計   起点 {start:7.0f} MB / ピーク {peak:7.0f} MB / 傾き {slope:+7.1f} MB/h")
    print("-" * 58)
    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} 起点 {st:6.0f} / ピーク {pk:6.0f} / 傾き {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 }> };
 
/**
 * ツール結果を「行数」と「文字数」の二重で上限化する。
 * 省略した事実と全体像（総件数）は必ず残す。数だけでも
 * 「絞り込みが必要だ」という判断はモデル側でつきます。
 */
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) {
    // 文字数超過なら行数をさらに削る（1行が長いケースへの保険）
    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}: ${total} 件中 ${shown.length} 件を表示 / ${omitted} 件を省略]`
      : `\n\n[${label}: ${total} 件]`;
 
  return { content: [{ type: "text", text: text + footer }] };
}

// 進捗ログは既定で出さない。必要なときだけ環境変数で開ける
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 — RSS がしきい値を超えたらセッションを畳んで再開する
# 使い方: ./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"
 
  # チェックポイントを渡して再開できる形でタスクを組む
  claude -p "$(cat "$TASK_FILE")
 
  進捗は ${CHECKPOINT} を読み、完了分はスキップしてください。
  1 ステップ終えるごとに ${CHECKPOINT} を更新してください。" \
    --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 — 畳みます"
      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
 
  # チェックポイントが完了を示していれば抜ける
  if grep -q '"done"[[:space:]]*:[[:space:]]*true' "$CHECKPOINT" 2>/dev/null; then
    echo "完了しました（round $round）"
    exit 0
  fi
  echo "[round $round] 再開します"
done
 
echo "上限ラウンドに達しました。checkpoint を確認してください" >&2
exit 1