filter to CC >=2.1.139 (header-keyed grouping); +2 traces (98 total)

README.md

@@ -23,166 +23,148 @@ configs:
 
 # CC Traces — Weka, With Subagents, v5 only (May 18 2026)
 
-A collection of **96 multi-turn agentic traces** drawn from real production
-traffic against the Claude Code CLI ≥ 2.1.139. Each trace captures the full
+A collection of **98 multi-turn agentic traces** drawn from real production
+traffic against Claude Code CLI ≥ 2.1.139. Each trace captures the full
 request/response sequence of a single agent session, including per-request
 KV block hashes AND the original sub-agent fan-out structure (Task-tool
 spawned sub-agents grouped into `WekaSubagentEntry` blocks).
 
-**With-subagents, v5-only variant.** Companion to
+**With-subagents, v5-only, CC ≥ 2.1.139 variant.** Companion to
 [cc-traces-weka-no-subagents-051826](https://huggingface.co/datasets/semianalysisai/cc-traces-weka-no-subagents-051826),
-which is the same 96 traces with all `WekaSubagentEntry` blocks stripped.
+which is the same 98 traces with all `WekaSubagentEntry` blocks stripped.
 
-Use this dataset when you want to:
-- Simulate the full agentic-coding workload including parallel Task-tool
-  sub-agent fan-out
-- Study sub-agent dispatch patterns, instance counts, durations
-- Replay against an inference engine that should see the same concurrent-
-  request structure a real Claude Code session generates
-
-Use the **no-subagents sibling** when you want a single linear main-agent
-stream per trace and don't care about the parent / child fan-out.
-
-Same filters as the sibling:
+Three filters:
 
 1. **v5 only.** Every replayable request in every included session has
-   `trace_version = 5` (the latest proxy schema, o200k_base tokenizer).
-   Sessions containing any earlier-format request are excluded entirely.
-2. **≥ 20 main-agent turns.** Per-trace main-agent stream (the would-be
-   no-subagents stream) must have at least 20 turns. Sub-agent fan-out
-   is on top of that.
-
-- **Traces:** 96
-- **Top-level entries:** 22,184 (21,566 main turns + 618 subagent groups)
-- **Sub-agent inner requests:** 16,200
-- **Total individual model requests:** 37,766
+   `trace_version = 5` (latest proxy schema, o200k_base tokenizer).
+2. **Claude Code CLI ≥ 2.1.139.** Every successful request in every
+   included session is on a CC build that ships the
+   `x-claude-code-agent-id` HTTP header — the canonical signal sub-agent
+   grouping depends on. Sessions without it would have unreliable
+   grouping (legacy stretch-based fallback can mis-group concurrent
+   same-label sub-agents) and are excluded entirely.
+3. **≥ 20 main-agent turns** post-strip. Sub-agent fan-out is on top of that.
+
+- **Traces:** 98
+- **Top-level entries:** 23,443 (22,822 main turns + 621 subagent groups)
+- **Sub-agent inner requests:** 16,332
+- **Total individual model requests:** 39,154
 - **Models:** `claude-opus-4-7`, `claude-haiku-4-5-20251001`, `claude-opus-4-6`, `claude-sonnet-4-6`
 - **KV block size:** 64 tokens
-- **Hash scope:** `local` — block hash IDs are only comparable *within*
-  a single trace; they are not a global content-addressable identity.
+- **Hash scope:** `local`
 
-## Important: tokenizer caveat
+## Sub-agent grouping
 
-The `in` field on each request and the `hash_ids` array are both
-measured in **the proxy's tokenizer** (`o200k_base`, GPT-4o family).
-Anthropic typically reports ~60 % of the o200k token count for the same
-content. So the ISL numbers below are larger than what the Anthropic
-API would have billed for the same prompt — but they're self-consistent
-between `in` and `hash_ids`, which is what matters for KV-cache replay
-simulation.
+Identical algorithm to the proxy dashboard's
+[`buildRequestRuns`](https://github.com/SemiAnalysisAI/semianalysis-claude-code-proxy/blob/main/packages/app/src/lib/subagent-runs.ts).
+Two passes over chronologically-sorted DB rows:
 
-## What's in each trace
+1. **Pre-collect header-keyed groups:** for every row with
+   `x-claude-code-agent-id`, gather ALL rows with the same id into one
+   group across the entire session (not just contiguous stretches).
+   Background sub-agents that overlap with main-agent turns collapse
+   correctly.
+
+2. **Emit chronologically:**
+   - `subagent_label IS NULL` → main turn at position
+   - has agent-id, first sighting → emit the pre-collected group
+   - has agent-id, already emitted → skip
+   - has label but no agent-id → fallback contiguous-stretch grouping
 
-Top-level trace fields:
+For CC ≥ 2.1.139 all groups go through the header-keyed path; the
+fallback isn't exercised. That's why we require CC ≥ 2.1.139 — the
+fallback can mis-group concurrent same-label sub-agents.
 
-| field           | type             | description                                         |
-|-----------------|------------------|-----------------------------------------------------|
-| `id`            | str              | Trace identifier (the proxy session id)             |
-| `models`        | list[str]        | Models used by the trace                            |
-| `block_size`    | int              | KV block size used to derive `hash_ids` (64)        |
-| `hash_id_scope` | str              | `local` — hash IDs are per-trace, not global        |
-| `requests`      | list[object]     | Ordered list of per-request records OR `WekaSubagentEntry` groups |
+## Tokenizer caveat
 
-Each entry in `requests` is one of two shapes:
+`in` and `hash_ids` are in proxy tokenizer (`o200k_base`). Anthropic
+reports ~60 % of the o200k count for the same content. ISL numbers
+are bigger than what Anthropic would bill, but self-consistent between
+`in` and `hash_ids` for cache-hit simulation.
+
+## What's in each trace
+
+Top-level: `id`, `models`, `block_size: 64`, `hash_id_scope: "local"`, `requests: list`.
 
 ### Main-agent request (`type: "n"` or `"s"`)
 
-| field         | type      | description                                                              |
-|---------------|-----------|--------------------------------------------------------------------------|
-| `t`           | float     | Seconds since start of trace                                             |
-| `type`        | str       | `n` (non-streaming) or `s` (streaming)                                   |
-| `model`       | str       | Target model for this request                                            |
-| `in`          | int       | Effective prompt tokens covered by `hash_ids` (proxy tokenizer)          |
-| `out`         | int       | Output tokens (Anthropic-reported)                                       |
-| `hash_ids`    | list[int] | Per-trace local block-hash IDs for the input, one per 64-token block     |
-| `api_time`    | float     | End-to-end server time for this call (seconds)                           |
-| `think_time`  | float?    | Wall-clock gap from previous request's end (seconds)                     |
-| `ttft`        | float?    | Time to first token (streaming requests only)                            |
+| field | type | description |
+|---|---|---|
+| `t` | float | seconds since trace start |
+| `type` | str | `n` (non-streaming) or `s` (streaming) |
+| `model` | str | target model |
+| `in` | int | input tokens (proxy tokenizer) |
+| `out` | int | output tokens |
+| `hash_ids` | list[int] | per-trace local block IDs |
+| `api_time` | float | end-to-end server seconds |
+| `think_time` | float? | gap from previous request's end |
+| `ttft` | float? | streaming only |
 
 ### Sub-agent group (`type: "subagent"`)
 
-| field           | type           | description                                            |
-|-----------------|----------------|--------------------------------------------------------|
-| `t`             | float          | Start time (seconds since trace start)                 |
-| `type`          | str            | Always `"subagent"`                                    |
-| `agent_id`      | str            | Stable per-trace sub-agent instance id (slug + suffix) |
-| `subagent_type` | str            | Sub-agent label (`"Subagent"` for Claude Code ≥ 2.1.139, else the original proxy label) |
-| `duration_ms`   | int            | Wall-clock span first→last inner request              |
-| `total_tokens`  | int            | Sum of `in + out` across inner requests                |
-| `tool_use_count`| null           | Not tracked in the proxy DB                            |
-| `status`        | str            | Always `"completed"`                                   |
-| `requests`      | list[object]   | Inner main-shape entries (type `n` — sub-agents are non-streaming) |
-| `models`        | list[str]      | Distinct models used inside this sub-agent run         |
-
-Sub-agent groups are emitted at the position of the first inner request
-in the chronological stream. Their inner requests have absolute `t`
-values (not relative to the group start), making sub-agent and main-
-agent timelines directly interleavable for replay.
-
-`hash_ids` make the dataset unusually useful for KV-cache work: the
-contiguous common prefix between turn *t* and turn *t − 1* exactly
-measures the portion of the input that a local prefix cache would be
-able to reuse. The same accounting applies to sub-agent inner requests
-within their group, and to the dispatching parent request that
-triggered them.
+| field | type | description |
+|---|---|---|
+| `t` | float | start of the group |
+| `type` | str | `"subagent"` |
+| `agent_id` | str | stable id (slug + 8-char suffix from `x-claude-code-agent-id`) |
+| `subagent_type` | str | `"Subagent"` for CC ≥ 2.1.139 |
+| `duration_ms` | int | first→last inner wall-clock |
+| `total_tokens` | int | Σ(in+out) across inners |
+| `tool_use_count` | null | not tracked |
+| `status` | str | `"completed"` |
+| `requests` | list | inner Shape-A entries (all `type: "n"`) |
+| `models` | list[str] | distinct models inside |
+
+Inner requests carry **absolute `t` values**, so flattening + chronological
+re-sort works directly: `sorted(main + flatten(inner), key=lambda x: x['t'])`.
 
 ## Summary statistics
 
-Across **all** requests (main + sub-agent inner = 37,766 requests):
+Across **all** requests (main + sub-agent inner = 39,154):
 
 |                              |   p50    |   p75    |   p90    |   p95    |   p99    |   mean   |
 |------------------------------|---------:|---------:|---------:|---------:|---------:|---------:|
-| ISL (tokens)                 |  100,902 |  229,982 |  443,856 |  580,438 |  803,019 |  172,848 |
-| OSL (tokens)                 |      224 |      478 |    1,150 |    1,907 |    5,461 |      530 |
-| Top entries/trace            |      115 |        — |        — |      678 |    1,141 |      231 |
+| ISL (tokens)                 |  103,026 |  231,708 |  440,033 |  573,767 |  799,819 |  173,073 |
+| OSL (tokens)                 |      223 |      476 |    1,152 |    1,907 |    5,413 |      527 |
+| Top entries/trace            |      126 |      304 |      571 |      733 |    1,120 |      239 |
 
 ## Plots
 
 ### Main-agent stream
 
-Histograms across all 21,566 main-agent turns (sub-agent groups skipped).
-Same view as the [no-subagents sibling](https://huggingface.co/datasets/semianalysisai/cc-traces-weka-no-subagents-051826) — the two datasets share an identical main-agent stream.
+Histograms across all 22,822 main-agent turns (sub-agent groups skipped). Identical to the [no-subagents sibling](https://huggingface.co/datasets/semianalysisai/cc-traces-weka-no-subagents-051826).
 
 ![Main-stream distributions — log x](plots/distributions_log.png)
 ![Main-stream distributions — linear x](plots/distributions_linear.png)
 
 ### Sub-agent fan-out analysis
 
-Histograms across all 618 sub-agent groups (and their 16,200 inner requests). Companion to the main-stream plots — answers questions about how often sub-agents are spawned, how deep their tool-loops go, how long they take, and how much intra-group prefix cache reuse exists.
+Histograms across all 621 sub-agent groups and their 16,332 inner requests.
 
 ![Sub-agent distributions — log x](plots/subagent_distributions_log.png)
 ![Sub-agent distributions — linear x](plots/subagent_distributions_linear.png)
 
-Six panels:
-
-1. **Sub-agent groups per trace** — distribution of how many distinct sub-agent invocations each session spawns
-2. **Inner requests per group** — depth of each sub-agent's tool-use loop
-3. **Group wall-clock duration** — first→last inner span (seconds)
-4. **Group total tokens** — `Σ(in + out)` across each group's inner requests
-5. **Inner-request ISL** — per-call input length INSIDE sub-agent loops (smaller than main-agent turns because sub-agents work on focused sub-problems with trimmed context)
-6. **Intra-group cache hit rate** — for each non-first inner request, fraction of `hash_ids` already seen in earlier inners of the SAME group. Captures how much KV-cache reuse a local prefix cache would get out of a sub-agent's tool-use loop (typically high — sub-agents iterate on a stable prompt)
+Six panels: groups per trace · inner requests per group · group wall-clock duration · group total tokens · inner-request ISL · intra-group cache hit rate.
 
 ## Model composition
 
 | model | requests (main + subagent inner) |
 |-------|---------:|
-| `claude-opus-4-7` | 36,637 |
+| `claude-opus-4-7` | 38,058 |
 | `claude-haiku-4-5-20251001` | 702 |
 | `claude-opus-4-6` | 343 |
-| `claude-sonnet-4-6` | 84 |
+| `claude-sonnet-4-6` | 51 |
 
 ## Source
 
 Same proxy → weka pipeline as the
 [no-subagents sibling](https://huggingface.co/datasets/semianalysisai/cc-traces-weka-no-subagents-051826),
-just without the post-step that strips `WekaSubagentEntry` blocks.
+without the post-step that strips `WekaSubagentEntry` blocks.
 
-  1. `utils/sample_proxy_traces.py --min-trace-version 5 --min-main-turns 20 --privacy-mode anon`
-  2. `utils/proxy_to_weka.py` (subagent grouping per the dashboard's
-     algorithm)
-  3. Concatenate the resulting weka JSONs into `traces.jsonl` — one trace
-     per line.
+  1. `utils/sample_proxy_traces.py --min-trace-version 5 --min-main-turns 20 --require-cli-min 2.1.139 --privacy-mode anon`
+  2. `utils/proxy_to_weka.py` (subagent grouping per [proxy `lib/subagent-runs.ts`](https://github.com/SemiAnalysisAI/semianalysis-claude-code-proxy/blob/main/packages/app/src/lib/subagent-runs.ts))
+  3. Concatenate the resulting weka JSONs into `traces.jsonl` — one trace per line.
 
-The same-96-trace contract with the no-subagents sibling makes the two
-variants safe to A/B compare for any benchmark that cares about
-sub-agent fan-out's impact on cache-hit-rate or throughput.
+The same-98-trace contract with the no-subagents sibling makes the two
+variants safe to A/B compare for any benchmark that cares about sub-agent
+fan-out's impact on cache-hit-rate or throughput.

traces.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:93f7e9e7d4c888ffb4e73423c88dc2184a54a72c52b8630b8f9fcbe78f11d521
-size 650260538
+oid sha256:fea00ec35ac395c830683d1e5b38a4809c77d4eb32c6305a9f28804fa7d3c941
+size 674903956