perf: bound what one model call costs to store

[Astro-Han]

Summary

Every model call stored a copy of the conversation. The prepared provider request was serialized whole into an Artifact, and the record beside it carried up to 256 per-segment rows — so the cost of storing one call grew with the Session it belonged to. Nothing read either: the capture's reader shipped in #1277 and was deleted in #2605, which kept the producer; the per-segment detail's only consumer folded it into four byte totals.

flowchart LR
    REQ(["one provider request"])

    subgraph B["before"]
        direction TB
        CAP["full request body<br/>private Artifact<br/>grows with the conversation"]
        OBS["up to 256 segment rows<br/>index · cacheable · comparison<br/>digest · bytes · role"]
    end
    subgraph A["after"]
        direction TB
        FOLD["4 byte totals<br/>+ capped tool list<br/>1,971 B, flat"]
    end

    REQ --> B
    REQ --> A
    CAP -.- X1["reader deleted · PR 2605"]
    OBS -.- X2["folded by its one reader"]

    classDef dead fill:#fcebeb,stroke:#e24b4a,color:#a32d2d
    classDef live fill:#e1f5ee,stroke:#1d9e75,color:#0f6e56
    class CAP,OBS,X1,X2 dead
    class FOLD live

Loading

This removes both producers, reclaims the captures already on disk, and reseals only the Sessions a mutation touched. #4716 landed the persistence half of #4037 first; this is rebased on it and built on its applyChanges shape.

Closes #4082
Refs #4037
Refs #4704

Before / after

Against this branch's parent 780dc4b4, same machine.

Durable bytes per model call — 60 tools, conversation of N messages. The record is written twice (AgentRun event log, usage_model_call_attempts); the capture is the request stored whole.

conversation	before	after
40 messages	103,723 B	3,942 B	26×
200 messages	229,121 B	3,942 B	58×
600 messages	405,729 B	3,944 B	103×

One Session, every call summed

turns	before	after		prepare CPU
50	5.61 MiB	0.19 MiB	30×	26 → 14 ms
200	44.48 MiB	0.75 MiB	59×	138 → 42 ms
500	193.44 MiB	1.88 MiB	103×	607 → 139 ms

The curve is the point: before, 4× the turns costs 8× the bytes, because each call copies a conversation that is itself growing. After, 4× the turns costs 4×.

One real workspace — 814 MB installation of mine, before this change:

artifacts/                     776.0 MB   436 records
  provider_request_capture     772.7 MB   379 files, 2.04 MB average
  everything else                3.3 MB    57 files
core_agent_run_events           11.6 MB
usage_model_call_attempts       10.6 MB   371 rows

Deduplicating messages by content within their own Session across all 379 capture files: 4.8 MB unique, 763.3 MB re-serialized duplicates (99.4%). Captures are 87% of the Artifact population, which is also what made the metadata write path expensive — the two problems were never independent.

Artifact mutation — real store, 6,000 records across 400 Sessions:

	before	after
one create, mean of 20	39.21 ms	37.82 ms
6,000 creates	193.2 s	175.7 s (−9%)

Modest, and worth stating precisely: the isolated reseal goes 6.90 ms → 0.22 ms at 14,361 records, but end to end that is 3.5% of a create — the rest is ~24 ms of filesystem durability and ~8.8 ms of the read below.

Still open

Step 1 of #4037. Every mutation begins with reloadForMutationUnlocked() → readAll(): full SELECT plus a JSON decode of every row, then a full reseal — 8.8 + 2.3 ms of that 37.8 ms create, both scaling with the store.

That reload dates from the metadata.jsonl era, where re-reading before a mutation was how a writer stayed correct against another process. Making it cheap needs a way to ask whether anything changed since the last read, and SQLite's data_version is not it: the operational-state database is one shared connection per process, so it does not move for a sibling store's writes. Who may invalidate the in-memory mirror is a design question, not a tidy-up, so it belongs in its own change.

What came out

Removed

• ContextDiagnosticsSegmentKind / Segment / Tool / Composition — aliases of the ModelCallAttempt types with no consumer outside the package.
• The opaque flag threaded through every branch of prepared-value normalization. It fed the retired observation's per-segment comparison mode; the one caller left sizes the value and never reads it. request-shape.ts: 430 → 369 lines.
• ProviderRequestTelemetry.observe — the seam the capture machinery hung on. Inlined.
• Two spellings of the fold's four buckets, and a literal 64 beside the constant that sets it.

Kept, every one — captureArtifactId, the provider_request_captured and provider_request_attempt_recorded events, the provider_request_capture source, the conversation-copy rewrite branches, and PreparedRequestObservation with its validator. hasExactShape rejects a record carrying an unknown key, so removing any of these fails exactly the records this PR exists to stop producing more of.

Verification

• format, lint clean. test:dist: @maka/core 804, @maka/runtime 3,216, @maka/storage 1,104, @maka/runtime-host 1,674 — 0 failures. typecheck also on @maka/desktop, @maka/cli, @maka/ui, @maka/protocol.
• Every figure above is measured on both trees on the same machine.
• Not run: full-repo suite, Playwright E2E — no user-visible surface changes. The context panel and /context answer what they answered before, from the same fold.

Review focus

The compatibility boundary: the producers are gone but every decoder stays, because real stores hold these records today.

One caveat on the new store-level test. It audits row writes through a real create, but #4716's WHERE ... IS NOT excluded.* means a store handing over its whole record set would still write no extra rows — so it cannot catch that regression. It catches a create that rewrites rows belonging to other Artifacts, and says so. Guarding the wider property needs a count of statement executions, not row writes.

AI use

Select exactly one:

• No generative tool made a substantive contribution
• Generative tooling made a substantive contribution

Tool(s) and scope: Claude Code — traced the demand chains, wrote the implementation and tests, ran the measurements. Reviewed and verified by me.

Checklist

• Tests cover the change and fail without it
  • New behavior (bounded capture reclamation, the sweep's pacing and stop, prompt-composition decoding) has tests that fail without it. The reseal change preserves behavior exactly and is shown by the measurements rather than a new failing test.
• Lint, format, typecheck and the affected suites pass locally

Does this PR entail a change in behavior?

• Yes — described under Summary above
• No