feat: session exit hook, configurable cost thresholds, top-level MCP detection

Session exit hook (-session-end):
- Shows cost summary when Claude Code session ends (SessionEnd hook)
- Displays session cost, request count, duration, today's total, and models used
- Uses ANSI escape + exit code 2 to render cleanly in Claude Code's hook output
- Silently exits on any error to never break session teardown

Configurable cost thresholds:
- ~/.goccc.json now supports warn_threshold and alert_threshold fields
- Thresholds auto-swap if user accidentally reverses them
- Applied to terminal output, statusline, and session exit hook

MCP detection:
- Now detects top-level mcpServers in ~/.claude.json (6th detection path)
- Replaced programmatic MCP tests with realistic fixture-based tests
- testdata/mcp/ exercises all 7 source types including disabled filtering

Other:
- Merged initConfig + initCurrency to load ~/.goccc.json once
- configPath is now a var func for testability
- Added Timestamp to dedupRecord for session duration calculation
- parseDateStr returns parsed time.Time alongside date string
- Float epsilon for today vs session cost comparison
- Collapsed README "How It Works" to essentials, kept cache write pricing
- Updated CLAUDE.md structure, conventions, and MCP source count

Author: backstabslash

.gitignore

@@ -1,4 +1,4 @@
 goccc
 dist/
 *.exe
-settings.local.json
+.claude/settings.local.json

CLAUDE.md

@@ -16,13 +16,14 @@ Go 1.26, stdlib only (zero external deps), GoReleaser for cross-platform builds
 ├── pricing.json       # Externalized model pricing data (embedded + fetched from repo)
 ├── format.go          # Terminal and JSON output formatting
 ├── color.go           # ANSI color helpers (custom implementation, no external deps)
-├── statusline.go      # Claude Code statusline mode (reads stdin JSON, outputs formatted cost line)
-├── currency.go        # Currency config (~/.goccc.json), exchange rate fetching/caching, symbol table
+├── statusline.go      # Statusline mode + session exit hook (reads stdin JSON, outputs formatted cost)
+├── currency.go        # Config (~/.goccc.json): currency, exchange rates, cost thresholds
 ├── mcp.go             # MCP server detection, per-project disable filtering, plugin walk
 ├── update.go          # Version update checking and remote pricing cache refresh
 ├── *_test.go          # Table-driven tests for each module
 ├── fixture_test.go    # Integration test against realistic JSONL fixture
-├── testdata/          # Static JSONL fixture (multi-turn convo with subagents)
+├── mcp_fixture_test.go # Integration test against realistic MCP fixture (all sources + disabling)
+├── testdata/          # Static fixtures: JSONL (multi-turn convo with subagents), MCP (home + project layout)
 ├── .goreleaser.yml    # Release config (darwin/linux/windows, amd64/arm64)
 └── README.md          # Usage docs and supported models
 ```
@@ -104,8 +105,9 @@ Independently verified against a Python parser on 272 requests across 11 files (
 - **Shared file parsing** — `parseFile()` in parser.go is used by both `parseLogs` (directory walk) and `parseSession` (statusline single-session)
 - **Local timezone everywhere** — local midnight for cutoffs, `parsed.Local()` for date bucketing. Never use `UTC()` for user-facing date logic
 - **MCP detection is best-effort** — all MCP detection functions return nil/empty on error; statusline never fails due to missing config
-- **MCP sources** — five detection paths: `mcpServers` in settings.json, marketplace `enabledPlugins` with `.mcp.json` walk, project-level `.mcp.json` via `cwd` from transcript, `settings.local.json` in project `.claude/`, and per-project `mcpServers` in `~/.claude.json`
-- **Local currency** — `~/.goccc.json` stores currency code, cached rate, and timestamp; exchange rates auto-fetched and cached for 24h. `-currency-symbol` and `-currency-rate` flags override config (both required together). JSON output cost fields always in USD
+- **MCP sources** — six detection paths: `mcpServers` in settings.json, marketplace `enabledPlugins` with `.mcp.json` walk, project-level `.mcp.json` via `cwd` from transcript, `settings.local.json` in project `.claude/`, top-level `mcpServers` in `~/.claude.json`, and per-project `mcpServers` in `~/.claude.json`
+- **Config file** — `~/.goccc.json` stores currency code, cached rate, timestamp, and cost thresholds (`warn_threshold`/`alert_threshold`). `initConfig()` loads everything once: thresholds first (with swap-correction if misordered), then currency. Exchange rates auto-fetched and cached for 24h. `-currency-symbol` and `-currency-rate` flags override config (both required together). JSON output cost fields always in USD
+- **Session end hook** — `-session-end` reads `SessionEnd` JSON from stdin, parses the session transcript, and outputs a one-line cost summary. Uses `os.Exit(2)` + ANSI escape to overwrite Claude Code's "hook failed" prefix. Silently exits on any error — never breaks session teardown
 
 ## Don't
 

README.md

@@ -15,6 +15,8 @@ Parses JSONL logs from `~/.claude/projects/`, deduplicates streaming responses,
 - [Installation](#installation)
 - [Usage](#usage)
 - [Claude Code Statusline](#claude-code-statusline)
+- [Session Exit Hook](#session-exit-hook)
+- [Configuration](#configuration)
 - [Flags](#flags)
 - [How It Works](#how-it-works)
 - [Preserving Log History](#preserving-log-history)
@@ -82,6 +84,8 @@ goccc -currency-symbol "€" -currency-rate 0.92
 
 JSON output always reports costs in USD for backward compatibility, with a `currency` metadata object when a non-USD currency is active.
 
+> See also: [Configuration](#configuration) for threshold customization.
+
 ## Claude Code Statusline
 
 goccc can serve as a [Claude Code statusline](https://code.claude.com/docs/en/statusline) provider — a live cost dashboard right in your terminal prompt.
@@ -126,6 +130,52 @@ Add to `~/.claude/settings.json`:
 
 To hide the MCP indicator, add `-no-mcp`.
 
+## Session Exit Hook
+
+goccc can show a cost summary when a Claude Code session ends — the feature users miss most since Anthropic removed it.
+
+```text
+💸 $1.87 session (14 reqs, 23m) · 💰 $12.34 today · 🤖 Opus 4.6, Haiku 4.5
+```
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "goccc -session-end"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+The hook runs within Claude Code's 1.5-second timeout. If anything fails, it exits silently — it will never break session teardown.
+
+## Configuration
+
+goccc reads its config from `~/.goccc.json`.
+
+### Cost Thresholds
+
+Cost values are color-coded yellow (warning) and red (alert) when they exceed thresholds. The defaults are $25 and $50 per day. To customize:
+
+```json
+{
+  "warn_threshold": 30,
+  "alert_threshold": 75
+}
+```
+
+Thresholds are in USD (before currency conversion). They apply to the terminal output, statusline, and session exit hook.
+
 ## Flags
 
 | Flag | Short | Default | Description |
@@ -141,6 +191,7 @@ To hide the MCP indicator, add `-no-mcp`.
 | `-json` | | `false` | Output as JSON |
 | `-no-color` | | `false` | Disable colored output (also respects `NO_COLOR` env) |
 | `-base-dir` | | `~/.claude` | Base directory for Claude Code data |
+| `-session-end` | | `false` | Session exit hook mode (reads SessionEnd JSON from stdin) |
 | `-statusline` | | `false` | Statusline mode for Claude Code (reads session JSON from stdin) |
 | `-no-mcp` | | `false` | Hide MCP servers from statusline output |
 | `-currency-symbol` | | | Override currency symbol (requires `-currency-rate`) |
@@ -149,15 +200,7 @@ To hide the MCP indicator, add `-no-mcp`.
 
 ## How It Works
 
-Claude Code stores conversation logs as JSONL files under `~/.claude/projects/<project-slug>/`. Each API call produces one or more log entries — streaming responses generate duplicates with the same `requestId`.
-
-goccc:
-
-1. Walks `.jsonl` files under the projects directory, skipping non-matching project directories and files older than the date range (by mtime)
-2. Pre-filters lines with a byte scan before JSON parsing — only `"type":"assistant"` entries carry billing data (tolerates both compact and spaced JSON formatting)
-3. Deduplicates streaming entries by `requestId` (last entry wins)
-4. Calculates costs using [Anthropic's published pricing](https://platform.claude.com/docs/en/about-claude/pricing), including cache write tiers, long-context premiums (>200K input tokens), and web search costs
-5. Aggregates by model, date (local timezone), project, and month
+goccc parses Claude Code's JSONL conversation logs from `~/.claude/projects/`, deduplicates streaming responses (by `requestId`), and calculates costs using [Anthropic's published pricing](https://platform.claude.com/docs/en/about-claude/pricing) — including cache write tiers, long-context premiums (>200K input), and web search costs.
 
 ### Cache Write Pricing
 

currency.go

@@ -21,9 +21,11 @@ var activeCurrency struct {
 
 // CurrencyConfig represents the persistent config in ~/.goccc.json.
 type CurrencyConfig struct {
-	Currency    string  `json:"currency"`
-	CachedRate  float64 `json:"cached_rate,omitempty"`
-	RateUpdated string  `json:"rate_updated,omitempty"`
+	Currency       string  `json:"currency"`
+	CachedRate     float64 `json:"cached_rate,omitempty"`
+	RateUpdated    string  `json:"rate_updated,omitempty"`
+	WarnThreshold  float64 `json:"warn_threshold,omitempty"`
+	AlertThreshold float64 `json:"alert_threshold,omitempty"`
 }
 
 type currencyInfo struct {
@@ -88,7 +90,7 @@ func symbolForCurrency(code string) (string, bool) {
 	return code, true
 }
 
-func configPath() string {
+var configPath = func() string {
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return ""
@@ -154,11 +156,30 @@ func fetchExchangeRate(currency string) (float64, error) {
 	return rate, nil
 }
 
+// initConfig loads config from ~/.goccc.json: thresholds and currency.
+func initConfig(symbolFlag string, rateFlag float64) error {
+	cfgPath := configPath()
+	cfg := loadCurrencyConfig(cfgPath)
+
+	if cfg.WarnThreshold > 0 {
+		costThresholdYellow = cfg.WarnThreshold
+	}
+	if cfg.AlertThreshold > 0 {
+		costThresholdRed = cfg.AlertThreshold
+	}
+	if costThresholdYellow > costThresholdRed {
+		costThresholdYellow, costThresholdRed = costThresholdRed, costThresholdYellow
+	}
+
+	return initCurrency(symbolFlag, rateFlag, cfgPath, &cfg)
+}
+
 // initCurrency resolves currency from CLI flags or config file and sets activeCurrency.
-func initCurrency(symbolFlag string, rateFlag float64) error {
+func initCurrency(symbolFlag string, rateFlag float64, cfgPath string, cfg *CurrencyConfig) error {
 	if (symbolFlag != "") != (rateFlag != 0) {
 		return fmt.Errorf("-currency-symbol and -currency-rate must be used together")
 	}
+
 	if symbolFlag != "" && rateFlag != 0 {
 		if math.IsNaN(rateFlag) || math.IsInf(rateFlag, 0) || rateFlag <= 0 {
 			return fmt.Errorf("-currency-rate must be a positive number")
@@ -167,10 +188,9 @@ func initCurrency(symbolFlag string, rateFlag float64) error {
 		activeCurrency.Rate = rateFlag
 		return nil
 	}
-	cfgPath := configPath()
-	cfg := loadCurrencyConfig(cfgPath)
+
 	if cfg.Currency != "" {
-		sym, suffix, rate := resolveCurrencyRate(&cfg, cfgPath)
+		sym, suffix, rate := resolveCurrencyRate(cfg, cfgPath)
 		activeCurrency.Code = cfg.Currency
 		activeCurrency.Symbol = sym
 		activeCurrency.Suffix = suffix

currency_test.go

@@ -8,15 +8,18 @@ import (
 
 func TestLoadCurrencyConfig(t *testing.T) {
 	tests := []struct {
-		name     string
-		content  string
-		wantCurr string
-		wantRate float64
+		name      string
+		content   string
+		wantCurr  string
+		wantRate  float64
+		wantWarn  float64
+		wantAlert float64
 	}{
-		{"valid config", `{"currency":"ZAR","cached_rate":18.5,"rate_updated":"2026-03-05T12:00:00Z"}`, "ZAR", 18.5},
-		{"empty currency", `{"currency":""}`, "", 0},
-		{"invalid json", `{not json}`, "", 0},
-		{"currency only", `{"currency":"EUR"}`, "EUR", 0},
+		{"valid config", `{"currency":"ZAR","cached_rate":18.5,"rate_updated":"2026-03-05T12:00:00Z"}`, "ZAR", 18.5, 0, 0},
+		{"empty currency", `{"currency":""}`, "", 0, 0, 0},
+		{"invalid json", `{not json}`, "", 0, 0, 0},
+		{"currency only", `{"currency":"EUR"}`, "EUR", 0, 0, 0},
+		{"with thresholds", `{"warn_threshold":30,"alert_threshold":75}`, "", 0, 30, 75},
 	}
 
 	for _, tt := range tests {
@@ -33,6 +36,12 @@ func TestLoadCurrencyConfig(t *testing.T) {
 			if cfg.CachedRate != tt.wantRate {
 				t.Errorf("CachedRate = %f, want %f", cfg.CachedRate, tt.wantRate)
 			}
+			if cfg.WarnThreshold != tt.wantWarn {
+				t.Errorf("WarnThreshold = %f, want %f", cfg.WarnThreshold, tt.wantWarn)
+			}
+			if cfg.AlertThreshold != tt.wantAlert {
+				t.Errorf("AlertThreshold = %f, want %f", cfg.AlertThreshold, tt.wantAlert)
+			}
 		})
 	}
 }
@@ -130,9 +139,11 @@ func TestSaveCurrencyConfig(t *testing.T) {
 	path := filepath.Join(dir, "config.json")
 
 	cfg := CurrencyConfig{
-		Currency:    "ZAR",
-		CachedRate:  18.5,
-		RateUpdated: "2026-03-05T12:00:00Z",
+		Currency:       "ZAR",
+		CachedRate:     18.5,
+		RateUpdated:    "2026-03-05T12:00:00Z",
+		WarnThreshold:  30,
+		AlertThreshold: 75,
 	}
 	saveCurrencyConfig(path, cfg)
 
@@ -143,6 +154,12 @@ func TestSaveCurrencyConfig(t *testing.T) {
 	if loaded.CachedRate != 18.5 {
 		t.Errorf("CachedRate = %f, want 18.5", loaded.CachedRate)
 	}
+	if loaded.WarnThreshold != 30 {
+		t.Errorf("WarnThreshold = %f, want 30", loaded.WarnThreshold)
+	}
+	if loaded.AlertThreshold != 75 {
+		t.Errorf("AlertThreshold = %f, want 75", loaded.AlertThreshold)
+	}
 }
 
 func TestResolveCurrencyRateUSD(t *testing.T) {
@@ -161,6 +178,40 @@ func TestResolveCurrencyRateEmpty(t *testing.T) {
 	}
 }
 
+func TestInitConfigSwapsThresholds(t *testing.T) {
+	origWarn := costThresholdYellow
+	origAlert := costThresholdRed
+	origCurrency := activeCurrency
+	defer func() {
+		costThresholdYellow = origWarn
+		costThresholdRed = origAlert
+		activeCurrency = origCurrency
+	}()
+
+	dir := t.TempDir()
+	cfgPath := filepath.Join(dir, ".goccc.json")
+	if err := os.WriteFile(cfgPath, []byte(`{"warn_threshold":75,"alert_threshold":30}`), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	origConfigPath := configPath
+	configPath = func() string { return cfgPath }
+	defer func() { configPath = origConfigPath }()
+
+	costThresholdYellow = 25.0
+	costThresholdRed = 50.0
+	if err := initConfig("", 0); err != nil {
+		t.Fatal(err)
+	}
+
+	if costThresholdYellow != 30 {
+		t.Errorf("costThresholdYellow = %f, want 30 (swapped)", costThresholdYellow)
+	}
+	if costThresholdRed != 75 {
+		t.Errorf("costThresholdRed = %f, want 75 (swapped)", costThresholdRed)
+	}
+}
+
 func TestResolveCurrencyRateCached(t *testing.T) {
 	cfg := &CurrencyConfig{
 		Currency:    "ZAR",

format.go

@@ -9,7 +9,7 @@ import (
 	"time"
 )
 
-const (
+var (
 	costThresholdRed    = 50.0
 	costThresholdYellow = 25.0
 )

format_test.go

@@ -88,6 +88,41 @@ func TestFmtDuration(t *testing.T) {
 	}
 }
 
+func TestColorizeCustomThresholds(t *testing.T) {
+	origNoColor := noColorFlag
+	noColorFlag = false
+	origWarn := costThresholdYellow
+	origAlert := costThresholdRed
+	defer func() {
+		noColorFlag = origNoColor
+		costThresholdYellow = origWarn
+		costThresholdRed = origAlert
+	}()
+
+	costThresholdYellow = 10.0
+	costThresholdRed = 20.0
+
+	if colorize("test", 5.0) != "test" {
+		t.Error("below warn threshold should not colorize")
+	}
+	if colorize("test", 15.0) == "test" {
+		t.Error("between warn and alert should colorize (yellow)")
+	}
+	if colorize("test", 25.0) == "test" {
+		t.Error("above alert should colorize (red)")
+	}
+}
+
+func TestColorizeDefaultThresholds(t *testing.T) {
+	origNoColor := noColorFlag
+	noColorFlag = false
+	defer func() { noColorFlag = origNoColor }()
+
+	if colorize("test", 20.0) != "test" {
+		t.Error("$20 should be plain with default $25 warn threshold")
+	}
+}
+
 func TestTotalCacheWrite(t *testing.T) {
 	b := &Bucket{CacheWrite5m: 100, CacheWrite1h: 200}
 	if got := b.TotalCacheWrite(); got != 300 {

main.go

@@ -54,6 +54,7 @@ func main() {
 	noColor := flag.Bool("no-color", false, "Disable colored output")
 	showVersion := flag.Bool("version", false, "Show version")
 	statusline := flag.Bool("statusline", false, "Statusline mode: read session JSON from stdin, output formatted cost line")
+	sessionEnd := flag.Bool("session-end", false, "Session end hook mode: read SessionEnd JSON from stdin, print cost summary")
 	noMCP := flag.Bool("no-mcp", false, "Hide MCP servers from statusline output")
 	cache5m := flag.Bool("cache-5m", false, "Price cache writes at 5-minute tier (1.25x) instead of 1-hour (2x)")
 	currencySymbolFlag := flag.String("currency-symbol", "", "Override currency symbol (requires -currency-rate)")
@@ -96,7 +97,7 @@ func main() {
 		cacheWriteAs1h = false
 	}
 
-	if err := initCurrency(*currencySymbolFlag, *currencyRateFlag); err != nil {
+	if err := initConfig(*currencySymbolFlag, *currencyRateFlag); err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		os.Exit(1)
 	}
@@ -108,6 +109,11 @@ func main() {
 		return
 	}
 
+	if *sessionEnd {
+		runSessionEnd(*baseDir)
+		return
+	}
+
 	updateCh := checkForUpdate(version)
 
 	if *daily && *monthly {