refactor(token-meter): simplify singleton service (round 1)

docs/architecture.md

@@ -24,7 +24,7 @@ A harness is one [Cordis](cordis-primer.md) context. Packages contribute service
 | ctx key | Package family | Role |
 |---|---|---|
 | `ctx.llm` | [`llm/`](../packages/llm/README.md) | adapter registry and streaming model calls |
-| `ctx.tokenMeter` | [`llm/token-meter`](../packages/llm/token-meter/README.md) | replay-aware request/surface pressure per model |
+| `ctx.tokenMeter` | [`llm/token-meter`](../packages/llm/token-meter/README.md) | singleton replay-aware request/surface pressure |
 | `ctx.bash` | [`bash/`](../packages/bash/README.md) | foreground/background command execution |
 | `ctx.sandbox` | [`sandbox/`](../packages/sandbox/README.md) | same-world process confinement (argv wrapping, per-call policy) |
 | `ctx.codeRuntime` | [`code-runtime/`](../packages/code-runtime/README.md) | model-written program execution |

docs/capability-seams.md

@@ -194,7 +194,7 @@ flowchart LR
 | ctx key | Role | Owner | Implementations | Direct consumers | Companion plugins | Note |
 | --- | --- | --- | --- | --- | --- | --- |
 | `ctx.llm` | `seam` | [`llm`](../packages/llm/llm) | [`llm-deepseek`](../packages/llm/llm-deepseek), [`llm-pi-ai`](../packages/llm/llm-pi-ai), [`llm-replay`](../packages/support/llm-replay) | [`agent-loop`](../packages/core/agent-loop), [`compact-basic`](../packages/compact/compact-basic) | - | Adapters register provider implementations; the loop and compaction call the provider-neutral stream service. |
-| `ctx.tokenMeter` | `core` | [`token-meter`](../packages/llm/token-meter) | - | [`compact-basic`](../packages/compact/compact-basic) | - | Owns isolated per-model/session replay folds; pressure consumers share immutable revisioned measurements. |
+| `ctx.tokenMeter` | `core` | [`token-meter`](../packages/llm/token-meter) | - | [`compact-basic`](../packages/compact/compact-basic) | - | Owns isolated per-session replay folds; pressure consumers share immutable revisioned measurements. |
 | `ctx.sessions` | `core` | [`session`](../packages/core/session) | - | [`agent-loop`](../packages/core/agent-loop), [`agent`](../packages/core/agent), [`session-persistence`](../packages/session-persistence/session-persistence), [`session-query`](../packages/session-query/session-query), [`subagent-inprocess`](../packages/subagent/subagent-inprocess), [`invariants`](../packages/support/invariants) | - | Owns append-only Session instances and emits the durable session event feed. |
 | `ctx.sessionPersistence` | `seam` | [`session-persistence`](../packages/session-persistence/session-persistence) | [`session-persistence-jsonl`](../packages/session-persistence/session-persistence-jsonl), [`session-persistence-sqlite`](../packages/session-persistence/session-persistence-sqlite) | [`agent-loop`](../packages/core/agent-loop), [`acp`](../packages/ui/acp), [`session-query`](../packages/session-query/session-query) | - | Backends persist the same SessionEvent vocabulary; apps choose a backend at composition time. |
 | `ctx.sessionQuery` | `seam` | [`session-query`](../packages/session-query/session-query) | - | - | - | Resolves live and optional persisted logs into one logical corpus for exact reads. |

docs/config-catalog.md

@@ -226,8 +226,10 @@ Requires: `llm` · `tokenMeter`
 ```ts config-catalog
 /** Basic compaction configuration; every common field has a deployment default. */
 export interface BasicCompactConfig {
-  /** Field-wise pressure/retention overrides keyed by configured token-meter model name. */
-  models?: Record<string, ModelCompactConfig>
+  /** Compact at this fraction of the token meter's context window. Defaults to `0.8`. */
+  thresholdRatio?: number
+  /** Recent surface tokens retained verbatim. Defaults to `floor(contextWindow * 0.16)`. */
+  retainTokens?: number
   /** Summary model; `''` resolves the latest routed model, then `AgentOptions.model`. Defaults to `''`. */
   summarizationModel?: string
   /** Provider generation cap for summarization. Defaults to `8192`. */
@@ -237,17 +239,9 @@ export interface BasicCompactConfig {
   /** Enable the automatic `agent/pre-step` pressure listener. Defaults to `true`. */
   auto?: boolean
 }
-
-/** Optional pressure and retention policy for one metered model. */
-export interface ModelCompactConfig {
-  /** Compact at this fraction of the model's configured context window. Defaults to `0.8`. */
-  thresholdRatio?: number
-  /** Recent surface tokens retained verbatim. Defaults to `floor(contextWindow * 0.16)`. */
-  retainTokens?: number
-}
 ```
 
-Source: [`packages/compact/compact-basic/src/types.ts:16`](../packages/compact/compact-basic/src/types.ts)
+Source: [`packages/compact/compact-basic/src/types.ts:8`](../packages/compact/compact-basic/src/types.ts)
 
 ## `@deepseek-ai/dsh-fs-local`
 
@@ -875,20 +869,12 @@ Source: [`packages/context/time-context/src/index.ts:22`](../packages/context/ti
 ```ts config-catalog
 /** Token-meter plugin configuration. */
 export interface TokenMeterConfig {
-  /** Built-in field overrides and custom model profiles, keyed by routed model name. */
-  models?: Record<string, ModelTokenMeterConfig>
-}
-
-/** Optional pricing fields for one configured model. */
-export interface ModelTokenMeterConfig {
-  /** Provider context-window capacity in tokens. Required for a custom model. */
+  /** Service-wide context-window capacity in tokens. Defaults to `128000`. */
   contextWindow?: number
-  /** Heuristic text density in characters per token. Defaults to `4`. */
-  charsPerToken?: number
 }
 ```
 
-Source: [`packages/llm/token-meter/src/types.ts:19`](../packages/llm/token-meter/src/types.ts)
+Source: [`packages/llm/token-meter/src/types.ts:10`](../packages/llm/token-meter/src/types.ts)
 
 ## `@deepseek-ai/dsh-tool-bash`
 

docs/cordis-catalog/services.md

@@ -263,13 +263,17 @@ Source: [`packages/tasks/tasks/src/index.ts:76`](../../packages/tasks/tasks/src/
 
 ## `ctx.tokenMeter` — `TokenMeterService`
 
-Concrete registry and replay owner for all configured model meters.
+Replay owner for one service-wide estimator and isolated per-session folds.
 
 ```ts cordis-catalog
-resolve(model: string): ModelTokenMeter
+measure(session: Session, requestHeader?: EpochHeader): TokenMeasurement
+measureSurface(session: Session): TokenSurfaceMeasurement
+estimateMessage(message: Message): number
 ```
 
-Source: [`packages/llm/token-meter/src/index.ts:145`](../../packages/llm/token-meter/src/index.ts)
+Types: [Message](../core-data-structures/core.md)
+
+Source: [`packages/llm/token-meter/src/index.ts:92`](../../packages/llm/token-meter/src/index.ts)
 
 ## `ctx.tools` — `ToolRegistry`
 

docs/core-data-structures/compaction.md

@@ -50,7 +50,7 @@ interface CompactionResult {
 
 ## The service
 
-`CompactService` exposes `compactIfNeeded(...)` for pressure-triggered compaction, returning `null` when no compaction is needed, and `compactRegion(...)` for an explicit inclusive surface range. The pre-step caller supplies the agent, full prompt, session prefix, and abort signal; implementations must forward that signal to summarization. The seam owns no pricing API: `dsh-compact-basic` resolves the routed model through [`ctx.tokenMeter`](token-meter.md), whose model-bound handle owns estimation and replay, while the backend owns retention, event sequencing, and summarization.
+`CompactService` exposes `compactIfNeeded(...)` for pressure-triggered compaction, returning `null` when no compaction is needed, and `compactRegion(...)` for an explicit inclusive surface range. The pre-step caller supplies the agent, full prompt, session prefix, and abort signal; implementations must forward that signal to summarization. The seam owns no pricing API: [`ctx.tokenMeter`](token-meter.md) directly owns estimation and replay, while `dsh-compact-basic` owns retention, event sequencing, routed summarization calls, and their configuration.
 
 Auto-compaction runs at serial `agent/pre-step`, before the step and request derivation, so it can replace surface nodes while keeping trace events outside the step. Region boundaries preserve tool-call/result pairing but do not preserve whole turns, allowing early closed steps of one oversized turn to compact. `dsh-compact-basic` owns the retention and failure details.
 

docs/core-data-structures/token-meter.md

@@ -8,8 +8,6 @@ Source: [`packages/llm/token-meter/src/types.ts`](../../packages/llm/token-meter
 
 ```ts type-equiv
 interface TokenMeasurement {
-  /** Model profile used for every heuristic component. */
-  readonly model: string
   /** Number of durable events consumed; equal to the next unread event seq. */
   readonly logRevision: number
   /** Provider or heuristic anchor used for this measurement. */
@@ -21,7 +19,7 @@ interface TokenMeasurement {
 }
 ```
 
-`baseline.kind === 'usage'` means a successful provider call has the same model and canonical envelope. `estimated` means the meter repriced the complete envelope and surface. Signed `surfaceDeltaTokens` preserves growth and shrinkage relative to a matching provider or estimated anchor.
+`baseline.kind === 'usage'` means the latest successful provider call has the same canonical request envelope. `estimated` means the service priced the complete envelope and surface with its fixed heuristic. A later successful request replaces the earlier anchor; signed `surfaceDeltaTokens` preserves growth and shrinkage relative to a matching anchor.
 
 ## `TokenSurfaceNode`
 
@@ -38,8 +36,6 @@ interface TokenSurfaceNode {
 
 ```ts type-equiv
 interface TokenSurfaceMeasurement {
-  /** Model profile used to price every node. */
-  readonly model: string
   /** Number of durable events consumed; equal to the next unread event seq. */
   readonly logRevision: number
   /** Total heuristic tokens across the current surface. */

docs/rfc/implemented/architecture/2026-07-15-replay-token-meter-service.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write
-2026-07-15-replay-token-meter-service.md: 4452c151e122c4a4ad72e3f0bc2616cd2fa28b9d
-2026-07-15-replay-token-meter-service.zh.md: 23edc11ffd19b9cfaeb794f3608e9ced4e7dbb7b
+2026-07-15-replay-token-meter-service.md: 981e789a51bbe7e2b09d47a76d71ac79fe14c999
+2026-07-15-replay-token-meter-service.zh.md: 85565b6f3db77ab81712f9c128e570c7a16bae8d

docs/rfc/implemented/architecture/2026-07-15-replay-token-meter-service.md

@@ -6,52 +6,52 @@ English | [中文](2026-07-15-replay-token-meter-service.zh.md)
 
 ## Problem
 
-Context pressure is useful outside compaction. A compaction backend, an overflow guard, or a future request-policy plugin can all need the same answer: how much of one model's window does the durable request consume? Keeping that fold inside `dsh-compact-basic` duplicates replay logic, makes measurement unavailable without compaction, and encourages callers to reuse accounting from the wrong model.
+Context pressure is useful outside compaction. A compaction backend, an overflow guard, or a future request-policy plugin can all need the same answer: how much of the configured context window does the durable request consume? Keeping that fold inside `dsh-compact-basic` duplicates replay logic, makes measurement unavailable without compaction, and encourages callers to reuse stale accounting.
 
-Provider usage is not a complete answer. It describes one successful call under one exact request envelope, while the current surface can grow, shrink, or be replaced afterward. Sessions also switch models, old logs can lack chunk provenance, and provider fields separate input, cache-read, cache-write, output, and reasoning counts. A useful service therefore combines exact anchors with conservative model-specific repricing and exposes the log revision consumed by each result.
+Provider usage is not a complete answer. It describes one successful call under one exact request envelope, while the current surface can grow, shrink, or be replaced afterward. Sessions also switch models, old logs can lack chunk provenance, and provider fields separate input, cache-read, cache-write, output, and reasoning counts. A useful service therefore combines the latest exact anchor with conservative heuristic repricing and exposes the log revision consumed by each result.
 
 ## Decision
 
 ### One concrete LLM-family service
 
-`@deepseek-ai/dsh-token-meter` is one concrete package under `packages/llm/` and registers `ctx.tokenMeter`. It is not split into an interface and backend before a second implementation exists. Its public entry point resolves an exact model name to a stable `ModelTokenMeter`; unknown names throw `TokenMeterError` with `TOKEN_METER_MODEL_UNCONFIGURED` instead of inheriting a universal window.
+`@deepseek-ai/dsh-token-meter` is one concrete package under `packages/llm/` and registers `ctx.tokenMeter`. It is not split into an interface and backend before a second implementation exists. `TokenMeterService` itself exposes `contextWindow`, `measure(session, requestHeader?)`, `measureSurface(session)`, and `estimateMessage(message)`; consumers call the singleton service directly.
 
-The built-in `deepseek-v4-flash` and `deepseek-v4-pro` profiles use a 128,000-token context window and four characters per estimated token. `models` overrides merge field-by-field. A custom name requires `contextWindow`, while `charsPerToken` defaults to four. Direct construction reports typed profile errors; Loader mounts first apply the package's Schemastery shape validation.
+The service has one `contextWindow`, defaulting to 128,000 tokens and configurable as a positive integer. Estimation uses a fixed four-characters-per-token heuristic plus structural overhead. There are no model profiles, density settings, tokenizer backends, or language-specific strategies.
 
-### Model-bound replay folds
+### Per-session replay folds
 
-Each model/session pair owns an isolated incremental fold. Active folds advance from `session/event`; every read catches up through the durable tail, so listener ordering, seeded sessions, and service reload do not change the answer. The fold tracks canonical request headers and deltas, step boundaries, surface appends and replacements, assistant usage, and assistant-chunk provenance. A malformed next event fails transactionally and remains unread rather than partially mutating state.
+Each session owns one isolated incremental fold. Active folds advance from `session/event`; every read catches up through the durable tail, so listener ordering, seeded sessions, and service reload do not change the answer. The fold tracks canonical request headers and deltas, step boundaries, surface appends and replacements, assistant usage, and assistant-chunk provenance. A malformed next event fails transactionally and remains unread rather than partially mutating state.
 
-`measure(session, requestHeader?)` returns scalar pressure. `measureSurface(session)` returns positional per-node prices for retention and replacement decisions. `estimateMessage(message)` applies the handle's profile without session state. Results are detached, deeply immutable snapshots carrying `logRevision`; a consumer compares scalar and surface revisions before making one decision.
+`measure(session, requestHeader?)` returns scalar pressure. `measureSurface(session)` returns positional per-node prices for retention and replacement decisions. `estimateMessage(message)` applies the fixed heuristic without session state. Results are detached, deeply immutable snapshots carrying `logRevision`; a consumer compares scalar and surface revisions before making one decision.
 
-Provider usage is reused only when the handle's model and canonical request envelope equal the successful-call anchor. Any system, prefix, tool, or call-config change causes complete repricing under the requested model. Surface changes remain a signed delta from a matching anchor, including negative values after a shrinking replacement. A success by another model changes the shared surface but never overwrites this model's anchor.
+Provider usage is reused only when the measured canonical request envelope equals the latest successful-call anchor. Any model, system, prefix, tool, or call-config change causes complete heuristic repricing. Surface changes remain a signed delta from a matching anchor, including negative values after a shrinking replacement. A later successful request replaces the earlier anchor, including across model switches.
 
 Usage sums the disjoint input, cache-read, cache-write, and output buckets. Reasoning is not added a second time. Every successful model call records an `assistant/message`, including content-less and max-token calls, with its exact earlier chunk seqs. An explicit empty provenance list means a known empty provider stream; absent legacy provenance conservatively treats the durable assistant output as provider output.
 
 ### Compact-basic consumes, but does not own, measurement
 
-`dsh-compact-basic` requires `ctx.tokenMeter`; `CompactService` gains no token methods or types. The backend is factored into configuration, automatic triggering, region transaction, and summarizer modules, while `summarize()` remains its sole subclass hook. The conversation model's meter consistently prices pressure, retention, shadowed content, provenance, and non-shrinking-summary rejection.
+`dsh-compact-basic` requires `ctx.tokenMeter`; `CompactService` gains no token methods or types. The backend is factored into configuration, automatic triggering, region transaction, and summarizer modules, while `summarize()` remains its sole subclass hook. The singleton service consistently prices pressure, retention, shadowed content, provenance, and non-shrinking-summary rejection.
 
-Every metered model receives a compact policy with defaults: threshold ratio `0.8`, retained tail `floor(contextWindow × 0.16)`, summarization model `''`, maximum summary output `8192`, one extra compaction attempt, and automatic triggering enabled. Per-model compact overrides merge `thresholdRatio` and `retainTokens`; retention must remain below the resulting threshold. Empty summarization model resolves the latest logged routed model, then `AgentOptions.model`.
+Compact policy has service-wide defaults: threshold ratio `0.8`, retained tail `floor(contextWindow × 0.16)`, summarization model `''`, maximum summary output `8192`, one extra compaction attempt, and automatic triggering enabled. Top-level `thresholdRatio` and `retainTokens` override the pressure policy; retention must remain below the resulting threshold. Empty summarization model resolves the latest logged routed model, then `AgentOptions.model`.
 
-The pre-step trigger measures a provisional envelope: the current prompt and prefix override logged values, while the latest logged header supplies model, tools, and other call config. A model-less router-only agent skips that provisional check because `agent/request` can route later; naming an unknown model remains an error.
+The pre-step trigger measures a provisional envelope: the current prompt and prefix override logged values, while the latest logged header supplies model, tools, and other call config. A model-less router-only agent skips that provisional check because `agent/request` can route later; any routed model name can use the singleton estimator.
 
 ## Testing
 
-Unit coverage pins profiles, field-wise overrides, custom and unknown models, envelope invalidation, model switching, usage and missing-usage paths, seeded append/replace replay, signed deltas, provenance modes, malformed boundaries, immutable snapshots, listener ordering, reload, compact defaults, routing fallback, retention, convergence, and transaction rollback. A real Loader/Include YAML fixture loads the exact zero-config token-meter and compact-basic package names in dependency order.
+Unit coverage pins service configuration, fixed estimation, envelope invalidation, latest-anchor replacement across model switches, usage and missing-usage paths, seeded append/replace replay, signed deltas, provenance modes, malformed boundaries, immutable snapshots, listener ordering, reload, compact defaults, routing fallback, retention, convergence, and transaction rollback. A real Loader/Include YAML fixture loads the exact zero-config token-meter and compact-basic package names in dependency order.
 
 ## Alternatives considered
 
 - **Keep estimation inside `CompactService`** — rejected because measurement has consumers and replay semantics independent of compaction; it would also force every compactor to expose the same unrelated API.
 - **Split a token-meter interface from a heuristic backend immediately** — rejected because only one implementation exists. One concrete service preserves the future seam without speculative packages or configuration.
-- **Give unknown models a 128,000-token fallback** — rejected because a plausible but wrong capacity can trigger destructive policy at the wrong point. Unknown routed names fail with their exact name.
+- **Keep model-keyed windows and density profiles** — rejected because the deployment currently has one context policy and one estimator. Model registries, unknown-model failures, and configurable density add branches without a second behavior to select.
 - **Copy complete history into each scalar result** — rejected because below-threshold reads are common. Immutable revisioned scalars and a separate surface snapshot preserve consistency without an O(history) copy.
-- **Treat provider usage as portable between models or envelopes** — rejected because tokenization, context capacity, tools, prefixes, and call config are model/request facts. Mismatch reprices the whole current request.
+- **Treat provider usage as portable between envelopes** — rejected because model, tools, prefixes, and call config are request facts. Mismatch reprices the whole current request.
 
 ## Consequences
 
 - Token pressure has one replay-aware owner that compaction and future plugins can share.
-- Defaults make the bundled DeepSeek composition usable with two zero-config plugin entries, while custom models must state the one fact that cannot be guessed safely: context capacity.
-- Heuristic density and provider usage remain estimates of provider behavior. Maintainers must update built-in profiles and overflow wording as models evolve.
+- The default makes the bundled composition usable with two zero-config plugin entries; deployments override one context capacity when needed.
+- Fixed heuristic pricing remains an estimate of provider behavior and is not an exact tokenizer or request serializer.
 - Measurements fail loudly on malformed durable boundaries. This turns corrupted replay into a named integration failure instead of silently drifting pressure.
 - The pre-step compact integration can skip a router-only first check and can miss tool or routing changes applied later in request middleware.

docs/rfc/implemented/architecture/2026-07-15-replay-token-meter-service.zh.md

@@ -1,4 +1,4 @@
-# RFC: 重放式 token 计量服务
+# RFC: 回放式 token 计量服务
 
 Status: implemented
 
@@ -6,52 +6,52 @@ Status: implemented
 
 ## 问题
 
-上下文压力并不只对压缩有用。压缩后端、溢出保护或未来的请求策略插件都可能需要回答同一个问题：持久请求占用了某个模型多少上下文窗口？如果把该折叠逻辑留在 `dsh-compact-basic` 内部，就会重复实现重放逻辑，使未加载压缩的调用方无法使用计量，并诱使调用方错误复用其他模型的核算结果。
+上下文压力并不只对压缩有用。压缩后端、溢出保护或未来的请求策略插件都可能需要回答同一个问题：持久请求占用了已配置上下文窗口的多少容量？如果把该折叠逻辑留在 `dsh-compact-basic` 内部，就会重复实现回放逻辑，使未加载压缩的调用方无法使用计量，并诱使调用方复用陈旧的核算结果。
 
-提供方 usage 也不是完整答案。它只描述某个精确请求信封下的一次成功调用，而当前表层之后还可能增长、缩小或被替换。会话也可能切换模型，旧日志可能缺少 chunk 来源，提供方字段还会分别报告输入、缓存读取、缓存写入、输出与推理计数。因此，可用的服务必须把精确锚点与保守的逐模型重新定价结合起来，并公开每个结果已经消费的日志修订号。
+提供方 usage 也不是完整答案。它只描述某个精确请求信封下的一次成功调用，而当前表层之后还可能增长、缩小或被替换。会话也可能切换模型，旧日志可能缺少分片来源，提供方字段还会分别报告输入、缓存读取、缓存写入、输出与推理计数。因此，可用的服务必须把最新精确锚点与保守的启发式重新定价结合起来，并公开每个结果已经消费的日志修订号。
 
 ## 决策
 
 ### 一个具体的 LLM 家族服务
 
-`@deepseek-ai/dsh-token-meter` 是 `packages/llm/` 下的单个具体 package，并注册 `ctx.tokenMeter`。在第二种实现出现之前，它不会被拆成接口与后端。公开入口把精确模型名解析为稳定的 `ModelTokenMeter`；未知名称抛出带 `TOKEN_METER_MODEL_UNCONFIGURED` 的 `TokenMeterError`，而不是继承通用窗口。
+`@deepseek-ai/dsh-token-meter` 是 `packages/llm/` 下的单个具体包，并注册 `ctx.tokenMeter`。在第二种实现出现之前，它不会被拆成接口与后端。`TokenMeterService` 本身公开 `contextWindow`、`measure(session, requestHeader?)`、`measureSurface(session)` 与 `estimateMessage(message)`；消费方直接调用这个单例服务。
 
-内置的 `deepseek-v4-flash` 与 `deepseek-v4-pro` profile 都采用 128,000 token 上下文窗口，以及每 token 四个字符的估算密度。`models` 覆盖按字段合并。自定义名称必须提供 `contextWindow`，而 `charsPerToken` 默认为四。直接构造会报告类型化 profile 错误；Loader 挂载则先应用 package 的 Schemastery 形状校验。
+服务只有一个 `contextWindow`，默认值为 128,000 token，并允许配置为正整数。估算采用固定的每 token 四个字符启发式规则，并加上结构开销。服务不提供模型 profile、密度设置、分词器后端或语言专用策略。
 
-### 绑定模型的重放折叠
+### 逐会话回放折叠
 
-每个模型/会话对都有隔离的增量折叠。活跃折叠通过 `session/event` 前进；每次读取都会追到持久日志尾部，因此监听器顺序、种子会话与服务重载不会改变答案。折叠跟踪规范请求头及其增量、步骤边界、表层追加与替换、assistant usage，以及 assistant chunk 来源。下一个畸形事件会以事务方式失败并保持未读，不会让状态只修改一半。
+每个会话都有一个隔离的增量折叠。活跃折叠通过 `session/event` 前进；每次读取都会追到持久日志尾部，因此监听器顺序、种子会话与服务重载不会改变答案。折叠跟踪规范请求头及其增量、步骤边界、表层追加与替换、assistant usage，以及 assistant 分片来源。下一个畸形事件会以事务方式失败并保持未读，不会让状态只修改一半。
 
-`measure(session, requestHeader?)` 返回标量压力。`measureSurface(session)` 返回用于保留与替换决策的逐位置节点价格。`estimateMessage(message)` 不依赖会话状态，直接应用该 handle 的 profile。结果是分离且深度不可变的快照，并携带 `logRevision`；消费者在一次联合决策前比较标量与表层修订号。
+`measure(session, requestHeader?)` 返回标量压力。`measureSurface(session)` 返回用于保留与替换决策的逐位置节点价格。`estimateMessage(message)` 不依赖会话状态，直接应用固定启发式规则。结果是分离且深度不可变的快照，并携带 `logRevision`；消费方在一次联合决策前比较标量与表层修订号。
 
-只有当 handle 的模型与规范请求信封都等于成功调用锚点时，服务才复用提供方 usage。系统提示词、前缀、工具或调用配置任一变化都会在请求模型下重新定价完整当前请求。表层变化相对匹配锚点保留有符号增量，包括缩小替换后的负值。其他模型的成功调用会改变共享表层，但绝不会覆盖当前模型的锚点。
+只有当待计量的规范请求信封等于最近一次成功调用的锚点时，服务才复用提供方 usage。模型、系统提示词、前缀、工具或调用配置任一变化都会触发完整的启发式重新定价。表层变化相对匹配锚点保留有符号增量，包括缩小替换后的负值。后续成功请求会替换先前锚点，模型切换时也一样。
 
-Usage 会对互不重叠的输入、缓存读取、缓存写入与输出 bucket 求和，不会再次加入推理计数。每次成功模型调用都会记录 `assistant/message`，包括无内容调用与达到 token 上限的调用，并带上精确的更早 chunk seq。显式空来源列表表示已知为空的提供方流；旧日志中缺失的来源则保守地把持久 assistant 输出视为提供方输出。
+Usage 会对互不重叠的输入、缓存读取、缓存写入与输出 bucket 求和，不会再次加入推理计数。每次成功模型调用都会记录 `assistant/message`，包括无内容调用与达到 token 上限的调用，并带上精确的更早分片 seq。显式空来源列表表示已知为空的提供方流；旧日志中缺失的来源则保守地把持久 assistant 输出视为提供方输出。
 
 ### compact-basic 消费计量，但不拥有计量
 
-`dsh-compact-basic` 要求 `ctx.tokenMeter`；`CompactService` 不增加 token 方法或类型。后端拆分为配置、自动触发、区域事务与摘要器模块，而 `summarize()` 仍是唯一的子类 hook。会话模型的 meter 一致用于压力、保留、被遮蔽内容、来源以及非缩小摘要拒绝。
+`dsh-compact-basic` 要求 `ctx.tokenMeter`；`CompactService` 不增加 token 方法或类型。后端拆分为配置、自动触发、区域事务与摘要器模块，而 `summarize()` 仍是唯一的子类 hook。单例服务一致用于压力、保留、被遮蔽内容、来源以及非缩小摘要拒绝的定价。
 
-每个已计量模型都会获得默认压缩策略：阈值比例 `0.8`、保留尾部 `floor(contextWindow × 0.16)`、摘要模型 `''`、摘要最大输出 `8192`、一次额外压缩尝试，以及启用自动触发。逐模型压缩覆盖按字段合并 `thresholdRatio` 与 `retainTokens`；保留值必须小于最终阈值。空摘要模型先解析最近记录的实际路由模型，再使用 `AgentOptions.model`。
+压缩策略采用服务级默认值：阈值比例 `0.8`、保留尾部 `floor(contextWindow × 0.16)`、摘要模型 `''`、摘要最大输出 `8192`、一次额外压缩尝试，以及启用自动触发。顶层 `thresholdRatio` 与 `retainTokens` 覆盖压力策略；保留值必须小于最终阈值。空摘要模型先解析最近记录的实际路由模型，再使用 `AgentOptions.model`。
 
-pre-step 触发器计量临时请求信封：当前提示词与前缀覆盖日志值，最近记录的请求头提供模型、工具及其他调用配置。没有模型的纯路由 agent 会跳过该临时检查，因为 `agent/request` 仍可稍后路由；显式命名未知模型仍然报错。
+pre-step 触发器计量临时请求信封：当前提示词与前缀覆盖日志值，最近记录的请求头提供模型、工具及其他调用配置。没有模型的纯路由 agent（智能体）会跳过该临时检查，因为 `agent/request` 仍可稍后路由；任意路由模型名都可使用这个单例估算器。
 
 ## 测试
 
-单元覆盖固定 profile、按字段覆盖、自定义与未知模型、信封失效、模型切换、有无 usage 的路径、种子追加/替换重放、有符号增量、来源模式、畸形边界、不可变快照、监听器顺序、重载、压缩默认值、路由回退、保留、收敛与事务回滚。真实 Loader/Include YAML fixture 按依赖顺序加载精确的零配置 token-meter 与 compact-basic package 名称。
+单元覆盖固定服务配置、固定估算、信封失效、模型切换时替换最新锚点、有无 usage 的路径、种子追加/替换回放、有符号增量、来源模式、畸形边界、不可变快照、监听器顺序、重载、压缩默认值、路由回退、保留、收敛与事务回滚。真实 Loader/Include YAML fixture 按依赖顺序加载精确的零配置 token-meter 与 compact-basic 包名称。
 
 ## 考虑过的替代方案
 
-- **把估算保留在 `CompactService` 内**——不予采纳，因为计量拥有独立于压缩的消费者与重放语义；它还会强迫每个压缩器暴露同一套无关 API。
-- **立即把 token meter 拆成接口与启发式后端**——不予采纳，因为目前只有一种实现。单个具体服务保留未来接缝，同时避免推测性的 package 与配置。
-- **给未知模型提供 128,000 token 回退**——不予采纳，因为看似合理但错误的容量会在错误时点触发破坏性策略。未知路由名称会携带精确名称失败。
+- **把估算保留在 `CompactService` 内**——不予采纳，因为计量拥有独立于压缩的消费方与回放语义；它还会强迫每个压缩器暴露同一套无关 API。
+- **立即把 token meter 拆成接口与启发式后端**——不予采纳，因为目前只有一种实现。单个具体服务保留未来接缝，同时避免推测性的包与配置。
+- **保留模型键控的窗口与密度 profile**——不予采纳，因为当前部署只有一种上下文策略与一个估算器。模型注册表、未知模型错误和可配置密度只增加分支，却没有第二种行为可供选择。
 - **在每个标量结果中复制完整历史**——不予采纳，因为低于阈值的读取很常见。不可变且带修订号的标量与独立表层快照，在不进行 O(history) 复制的情况下保持一致性。
-- **在模型或信封之间移用提供方 usage**——不予采纳，因为分词、上下文容量、工具、前缀与调用配置都是模型/请求事实。不匹配时会重新定价完整当前请求。
+- **在不同信封之间移用提供方 usage**——不予采纳，因为模型、工具、前缀与调用配置都是请求事实。不匹配时会重新定价完整当前请求。
 
 ## 后果
 
-- Token 压力拥有一个可供压缩与未来插件共享的重放感知所有者。
-- 默认值让内置 DeepSeek 组合只需两个零配置插件条目即可使用，而自定义模型必须声明唯一不能安全猜测的事实：上下文容量。
-- 启发式密度与提供方 usage 仍然只是提供方行为的估计。随着模型演进，维护者必须更新内置 profile 与溢出措辞。
-- 遇到畸形持久边界时，计量会明确失败。这会把损坏的重放转化为具名集成错误，而不是让压力静默漂移。
+- Token 压力拥有一个可供压缩与未来插件共享的回放感知所有者。
+- 默认值让内置组合只需两个零配置插件条目即可使用；部署需要时只覆盖一个上下文容量。
+- 固定启发式定价仍然只是提供方行为的估计，并不是精确分词器或请求序列化器。
+- 遇到畸形持久边界时，计量会明确失败。这会把损坏的回放转化为具名集成错误，而不是让压力静默漂移。
 - pre-step 压缩集成可能跳过纯路由的首次检查，也可能错过请求中间件稍后应用的工具或路由变化。

docs/rfc/implemented/feature/2026-06-18-compaction-capability-seam.md

@@ -64,7 +64,7 @@ Auto-compaction always starts at the surface head, merging the prior checkpoint
 
 ### Approximate convergence invariant
 
-`resolveConfig` supplies usable common defaults: threshold ratio `0.8`, retained tail `floor(contextWindow × 0.16)`, empty summarization-model override, `maxTokens: 8192`, `compactionRetries: 1`, and `auto: true`. Optional per-model threshold/retention fields merge over those defaults and must name a configured meter profile; retained tokens must be below the resulting threshold. Convergence remains dynamic because provider output caps can be spent on hidden or surfaced reasoning tokens and summary size is unpredictable. If the compacted surface remains over threshold, `compactIfNeeded()` re-compacts the head checkpoint up to the configured retry count, but each committed summary must be smaller than what it shadows.
+`resolveConfig` supplies usable defaults: threshold ratio `0.8`, retained tail `floor(contextWindow × 0.16)`, empty summarization-model override, `maxTokens: 8192`, `compactionRetries: 1`, and `auto: true`. Optional top-level `thresholdRatio` and `retainTokens` override the policy for the token meter's single context window; retention must remain below the resulting threshold. Convergence remains dynamic because provider output caps can be spent on hidden or surfaced reasoning tokens and summary size is unpredictable. If the compacted surface remains over threshold, `compactIfNeeded()` re-compacts the head checkpoint up to the configured retry count, but each committed summary must be smaller than what it shadows.
 
 ### Surface replacement: `compact/*` events are log-only; one `user/message` carries the summary
 
@@ -115,7 +115,7 @@ Two failure paths, both documented:
 - **`SessionEventMap`** gains `compact/start` / `compact/summary` / `compact/end` by declaration merging (merge-extensible); `SurfaceEventType` is **not** touched. These are session events, not cordis `Events`, so the event-taxonomy gate needs no entry.
 - **`dsh-compact`** owns `toolPairingBalancedBefore(session, node)` and `toolPairingBalancedAfter(session, node)`, the cached surface-edge checks that `compactRegion` and `compactIfNeeded` use to avoid splitting a tool-call/result pair. The cache validates current membership by seq and resolves after-edges from its positional successor map instead of trusting a caller-retained `node.next`; stale or missing seqs and orphan results reject. `dsh-session` continues to own the surface `replace` operation, positional nodes, and rewrite generation.
 - **`dsh-invariants`** drops its `surface replace: start must be <= end` assertion: a head-anchored compaction lands a high-seq replacement node at an older range's *position*, so `start > end` numerically is normal and valid (the range is positional, validated by the surface's `indexOf` checks that remain). The turn-enclosure invariant is reused unchanged.
-- **Wiring**: `examples/coding-agent/cordis.yml` loads zero-config `dsh-token-meter` before `dsh-compact-basic`; bundled DeepSeek profiles and compact defaults make the pair usable without repeated numeric policy.
+- **Wiring**: `examples/coding-agent/cordis.yml` loads zero-config `dsh-token-meter` before `dsh-compact-basic`; the service-wide window and compact defaults make the pair usable without repeated numeric policy.
 
 ## Testing
 

examples/coding-agent/cordis.yml

@@ -46,12 +46,12 @@
       Verify your work by running the code or tests. Keep answers brief and
       factual.
 
-# Replay-aware request pressure for the bundled DeepSeek model profiles.
+# Replay-aware request pressure with one service-wide context window.
 - id: token-meter
   name: '@deepseek-ai/dsh-token-meter'
 
 # Summarize an older range when measured history approaches the context window.
-# Built-in model policies provide the ordinary threshold and retained-tail defaults.
+# Service-wide policy provides the ordinary threshold and retained-tail defaults.
 - id: compact-basic
   name: '@deepseek-ai/dsh-compact-basic'
 

examples/coding-agent/tests/compaction.e2e.ts

@@ -34,14 +34,11 @@ describe.skipIf(!process.env.DEEPSEEK_API_KEY)('compaction: a long session compa
     ctx = await codingHarness(workdir, {
       persona: SYSTEM_PROMPT,
       tokenMeter: {
-        models: {
-          'deepseek-v4-flash': { contextWindow: 2000 },
-        },
+        contextWindow: 2000,
       },
       compact: {
-        models: {
-          'deepseek-v4-flash': { thresholdRatio: 0.5, retainTokens: 400 },
-        },
+        thresholdRatio: 0.5,
+        retainTokens: 400,
         summarizationModel: '',
         maxTokens: 1024,
         compactionRetries: 1,

examples/coding-agent/tests/harness.ts

@@ -48,7 +48,7 @@ export interface CodingHarnessOptions {
    * compaction plugin (the default suites run without it).
    */
   compact?: BasicCompactConfig
-  /** Optional meter profiles loaded before compact-basic. */
+  /** Optional token-meter capacity loaded before compact-basic. */
   tokenMeter?: TokenMeterConfig
 }
 
@@ -65,7 +65,7 @@ export async function codingHarness(workdir: string, options: CodingHarnessOptio
   await ctx.plugin(ToolBash)
   await ctx.plugin(ToolTodo)
   // Compaction is opt-in: only the compaction e2e loads the reusable meter and
-  // backend, with a lowered profile window so a short real session crosses the threshold.
+  // backend, with a lower context window so a short real session crosses the threshold.
   if (options.compact !== undefined) {
     await ctx.plugin(TokenMeterService, options.tokenMeter)
     await ctx.plugin(BasicCompactService, options.compact)

packages/compact/compact-basic/README.md

@@ -8,7 +8,7 @@ This is the implementation tier of the compaction capability — see the [interf
 
 This backend owns the compaction policy:
 
-- **Measurement** — the effective conversation model's `ModelTokenMeter` prices the provisional request envelope and current surface at one consumed-log revision. The current prompt and prefix override their logged values; the pre-step boundary reuses logged tools and call config.
+- **Measurement** — the singleton `ctx.tokenMeter` prices the provisional request envelope and current surface at one consumed-log revision. The current prompt and prefix override their logged values; the pre-step boundary reuses logged tools and call config.
 - **Retention** — compact the oldest whole surface units while preserving a recent tail and balanced tool-call/result cuts through the [`dsh-compact` boundary helpers](../compact/README.md#tool-pairing-boundaries). Turn boundaries do not protect old steps inside a runaway turn. An open indivisible tail declines until it closes; a single unit larger than the budget remains out of scope.
 - **Convergence** — retry head-checkpoint compaction up to `compactionRetries`; reject a summary that does not shrink its source, and throw if retries cannot return below threshold.
 - **Summarization** — a direct `llm/stream` call uses the configured model and cap without running the loop-only `agent/request` seam. The input transcript preserves non-text blocks as tagged placeholders; only returned text enters the checkpoint, excluding reasoning and tool calls that would leak private reasoning or create an orphaned call.
@@ -16,16 +16,16 @@ This backend owns the compaction policy:
 - **Lifecycle** — `compactRegion()` requires its agent to own the exact target session and rejects mismatch before resolution or mutation; a valid call records its start, summary, replacement, and end. The serial `agent/pre-step` listener checks pressure before every step, outside an open step, so a tool-heavy turn remains compactable and the loop derives history once after mutation.
 - **Failure handling** — an unmatched `compact/start` is an inert crash marker because no replacement landed. Recoverable failure records an error end and leaves the surface unchanged.
 
-`summarize()` is the sole subclass hook. A template- or remote-summarizer subclass can override it while pressure, retention, provenance, shrink validation, and shadowed-token accounting stay on the conversation model's meter. The hook returns the summary blocks together with the call envelope it used (`{ summary, model, maxTokens? }`), which is logged on `compact/summary`.
+`summarize()` is the sole subclass hook. A template- or remote-summarizer subclass can override it while pressure, retention, provenance, shrink validation, and shadowed-token accounting stay on `ctx.tokenMeter`. The hook returns the summary blocks together with the call envelope it used (`{ summary, model, maxTokens? }`), which is logged on `compact/summary`.
 
 ## Config (`BasicCompactConfig`)
 
-Every common setting is optional. Every model known to `ctx.tokenMeter` receives the default compact policy lazily; named overrides merge only the fields supplied and must name a configured meter profile.
+Every setting is optional. The pressure and retention policy applies to the token meter's single context window.
 
 | Key | Required | Meaning |
 |---|---|---|
-| `models.<model>.thresholdRatio` | no (default `0.8`) | Compact at `floor(contextWindow × ratio)`. |
-| `models.<model>.retainTokens` | no (default `floor(contextWindow × 0.16)`) | Recent surface budget kept verbatim; must be below the threshold. |
+| `thresholdRatio` | no (default `0.8`) | Compact at `floor(contextWindow × ratio)`. |
+| `retainTokens` | no (default `floor(contextWindow × 0.16)`) | Recent surface budget kept verbatim; must be below the threshold. |
 | `summarizationModel` | no (default `''`) | Empty resolves the latest logged routed model, then `AgentOptions.model`. |
 | `maxTokens` | no (default `8192`) | Provider generation cap for the summarization call; may include reasoning tokens. |
 | `compactionRetries` | no (default `1`) | Extra attempts after the first when pressure remains above threshold. |
@@ -116,7 +116,7 @@ Rules:
 ## Known Limitations and Deferred Work
 
 - **Pre-step sees a provisional request envelope** — the current prompt and prefix are exact, but routing and tool changes made later in `agent/request` are not logged yet. A router-only agent with no provisional model skips that check.
-- **Meter accuracy follows the selected profile** — missing provider usage falls back to the token meter's configured character density and structural overhead.
+- **Meter accuracy follows the fixed heuristic** — missing reusable provider usage falls back to character count plus structural overhead rather than exact tokenization.
 - **`compactRegion` requires an open turn** — a manual call on a fully-closed session throws ("no open turn") rather than compacting.
 - **Summarization failure fails closed with full, over-budget history** — including truncation at the summarization `maxTokens`, which hidden reasoning tokens can consume; the auto path logs a warning and proceeds.
 - **The summarization call has no transcript-snapshot coverage** — `dsh-llm-replay` derives calls from `assistant/chunk` events, so this chunk-less direct `ctx.llm.stream()` call cannot replay (named deferred replay infrastructure in [the seam RFC](../../../docs/rfc/implemented/feature/2026-06-18-compaction-capability-seam.md)).

packages/compact/compact-basic/src/automatic.ts

@@ -7,10 +7,6 @@
 import type { Context } from 'cordis'
 import type { CompactionResult } from '@deepseek-ai/dsh-compact'
 import type { Message } from '@deepseek-ai/dsh-llm'
-import {
-  TOKEN_METER_MODEL_UNCONFIGURED,
-  TokenMeterError,
-} from '@deepseek-ai/dsh-token-meter'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 
 interface AutomaticCompactor {
@@ -49,10 +45,6 @@ export function registerAutomaticCompaction(
         )
       }
     } catch (error: unknown) {
-      // A named routed model without a meter profile is configuration failure,
-      // not an optional operational compaction miss.
-      if (error instanceof TokenMeterError
-        && error.code === TOKEN_METER_MODEL_UNCONFIGURED) throw error
       const message = error instanceof Error ? error.message : String(error)
       ctx.logger.warn(`compaction failed: ${message}; proceeding with full history`)
     }

packages/compact/compact-basic/src/config.ts

@@ -1,63 +1,49 @@
 /**
- * Runtime defaulting and per-model policy validation for compact-basic.
+ * Runtime defaulting and policy validation for compact-basic.
  *
  * @module @deepseek-ai/dsh-compact-basic/config
  */
 
 import { deepFreeze } from '@deepseek-ai/dsh-llm'
-import type { ModelTokenMeter, TokenMeterService } from '@deepseek-ai/dsh-token-meter'
-import type {
-  BasicCompactConfig,
-  ModelCompactConfig,
-  ResolvedConfig,
-  ResolvedModelCompactConfig,
-} from './types.ts'
+import type { TokenMeterService } from '@deepseek-ai/dsh-token-meter'
+import type { BasicCompactConfig, ResolvedConfig } from './types.ts'
 
-/** Default request-pressure fraction for every metered model. */
+/** Default request-pressure fraction of the token meter's context window. */
 const DEFAULT_THRESHOLD_RATIO = 0.8
 
-/** Default verbatim-tail fraction of a model's context window. */
+/** Default verbatim-tail fraction of the token meter's context window. */
 const DEFAULT_RETAIN_RATIO = 0.16
 
 /**
- * Resolve common defaults and validate every named model override.
+ * Resolve defaults and validate the service-wide compaction policy.
  * @param config - raw compact-basic configuration.
- * @param tokenMeter - owning meter service used to reject unknown override names.
- * @returns a detached deeply immutable top-level configuration.
+ * @param tokenMeter - token meter supplying the context capacity.
+ * @returns a detached deeply immutable configuration.
  */
 export function resolveConfig(
   config: BasicCompactConfig = {},
   tokenMeter: TokenMeterService,
 ): ResolvedConfig {
-  const configuredModels: unknown = config.models
-  const models = configuredModels === undefined ? {} : configuredModels
-  if (typeof models !== 'object' || models === null || Array.isArray(models)) {
-    throw new Error('BasicCompactConfig: models must be an object')
-  }
-
-  const detachedModels: Record<string, ModelCompactConfig> = {}
-  for (const [model, override] of Object.entries(models as Record<string, unknown>)) {
-    if (typeof override !== 'object' || override === null || Array.isArray(override)) {
-      throw new Error(`BasicCompactConfig: models.${model} must be an object`)
-    }
-    const meter = tokenMeter.resolve(model)
-    detachedModels[model] = { ...override as ModelCompactConfig }
-    resolveModelConfig({
-      models: detachedModels,
-      summarizationModel: '',
-      maxTokens: 8192,
-      compactionRetries: 1,
-      auto: true,
-    }, meter)
-  }
-
+  const thresholdRatio = config.thresholdRatio ?? DEFAULT_THRESHOLD_RATIO
+  const retainTokens = config.retainTokens
+    ?? Math.floor(tokenMeter.contextWindow * DEFAULT_RETAIN_RATIO)
   const resolved: ResolvedConfig = {
-    models: detachedModels,
+    thresholdRatio,
+    retainTokens,
     summarizationModel: config.summarizationModel ?? '',
     maxTokens: config.maxTokens ?? 8192,
     compactionRetries: config.compactionRetries ?? 1,
     auto: config.auto ?? true,
   }
+
+  assertRatio('thresholdRatio', resolved.thresholdRatio)
+  assertNonNegativeInteger('retainTokens', resolved.retainTokens)
+  const thresholdTokens = Math.floor(tokenMeter.contextWindow * resolved.thresholdRatio)
+  if (resolved.retainTokens >= thresholdTokens) {
+    throw new Error(
+      `BasicCompactConfig: retainTokens (${resolved.retainTokens}) must be less than threshold tokens ${thresholdTokens}`,
+    )
+  }
   assertPositiveInteger('maxTokens', resolved.maxTokens)
   assertNonNegativeInteger('compactionRetries', resolved.compactionRetries)
   if (typeof resolved.summarizationModel !== 'string') {
@@ -66,36 +52,7 @@ export function resolveConfig(
   if (typeof resolved.auto !== 'boolean') {
     throw new Error('BasicCompactConfig: auto must be a boolean')
   }
-  return deepFreeze(structuredClone(resolved))
-}
-
-/**
- * Resolve one effective model's default policy plus optional field overrides.
- * @param config - validated compact-basic configuration.
- * @param meter - effective model's token-meter handle and context capacity.
- * @returns a detached immutable model policy.
- */
-export function resolveModelConfig(
-  config: ResolvedConfig,
-  meter: ModelTokenMeter,
-): ResolvedModelCompactConfig {
-  const override = config.models[meter.model]
-  const thresholdRatio = override?.thresholdRatio ?? DEFAULT_THRESHOLD_RATIO
-  const retainTokens = override?.retainTokens ?? Math.floor(meter.contextWindow * DEFAULT_RETAIN_RATIO)
-  assertRatio(`models.${meter.model}.thresholdRatio`, thresholdRatio)
-  assertNonNegativeInteger(`models.${meter.model}.retainTokens`, retainTokens)
-  const thresholdTokens = Math.floor(meter.contextWindow * thresholdRatio)
-  if (retainTokens >= thresholdTokens) {
-    throw new Error(
-      `BasicCompactConfig: models.${meter.model}.retainTokens (${retainTokens}) must be less than threshold tokens ${thresholdTokens}`,
-    )
-  }
-  return deepFreeze({
-    model: meter.model,
-    contextWindow: meter.contextWindow,
-    thresholdRatio,
-    retainTokens,
-  })
+  return deepFreeze(resolved)
 }
 
 function assertPositiveInteger(name: string, value: number): void {

packages/compact/compact-basic/src/index.ts

@@ -11,24 +11,20 @@ import type { CompactionResult } from '@deepseek-ai/dsh-compact'
 import { canonicalHeader } from '@deepseek-ai/dsh-session'
 import type { EpochHeader, Session } from '@deepseek-ai/dsh-session'
 import type { ContentBlock, Message } from '@deepseek-ai/dsh-llm'
-import type { ModelTokenMeter } from '@deepseek-ai/dsh-token-meter'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import { registerAutomaticCompaction } from './automatic.ts'
-import { resolveConfig, resolveModelConfig } from './config.ts'
+import { resolveConfig } from './config.ts'
 import { compactSurfaceRegion, selectCompactableRange } from './region.ts'
 import { summarizeWithLlm } from './summarizer.ts'
 import type {
   BasicCompactConfig,
   ResolvedConfig,
-  ResolvedModelCompactConfig,
 } from './types.ts'
 
-export { resolveConfig, resolveModelConfig } from './config.ts'
+export { resolveConfig } from './config.ts'
 export type {
   BasicCompactConfig,
-  ModelCompactConfig,
   ResolvedConfig,
-  ResolvedModelCompactConfig,
 } from './types.ts'
 
 /** Resolve the latest actual routed model, then the agent's configured fallback. */
@@ -61,28 +57,24 @@ function provisionalHeader(
  * retention, provenance, and summary-convergence pricing.
  *
  * `summarize()` is the sole subclass customization hook; the replay and durable
- * mutation strategy stays fixed so every pricing decision uses one effective
- * conversation-model meter.
+ * mutation strategy stays fixed so every pricing decision uses the singleton
+ * token meter.
  */
 export class BasicCompactService extends CompactService {
   static inject = ['llm', 'tokenMeter']
 
   static Config: z<BasicCompactConfig> = z.object({
-    models: z.dict(z.object({
-      thresholdRatio: z.number(),
-      retainTokens: z.number().step(1),
-    })),
+    thresholdRatio: z.number().default(0.8),
+    retainTokens: z.number().step(1),
     summarizationModel: z.string().default(''),
     maxTokens: z.number().step(1).min(1).default(8192),
     compactionRetries: z.number().step(1).min(0).default(1),
     auto: z.boolean().default(true),
   })
 
-  /** Resolved and validated common configuration plus named partial overrides. */
+  /** Resolved and validated compaction configuration. */
   readonly config: ResolvedConfig
 
-  private readonly modelConfigs = new Map<string, ResolvedModelCompactConfig>()
-
   constructor(ctx: Context, config: BasicCompactConfig = {}) {
     super(ctx)
     this.config = resolveConfig(config, ctx.tokenMeter)
@@ -107,9 +99,8 @@ export class BasicCompactService extends CompactService {
 
   /**
    * Check replayed pressure for the provisional pre-step envelope and compact
-   * a tool-balanced head until it falls below the effective model threshold.
-   * A genuinely model-less router-first step skips this provisional check;
-   * naming an unconfigured model throws the token meter's typed error.
+   * a tool-balanced head until it falls below the service-wide threshold.
+   * A genuinely model-less router-first step skips this provisional check.
    * @param agent - agent whose session and provisional model are measured.
    * @param fullSystemPrompt - current assembled system prompt override.
    * @param sessionPrefix - current request-only prefix override.
@@ -124,10 +115,9 @@ export class BasicCompactService extends CompactService {
   ): Promise<CompactionResult | null> {
     const model = effectiveModel(agent)
     if (model === undefined || model.length === 0) return null
-    const meter = this.ctx.tokenMeter.resolve(model)
-    const policy = this._modelConfig(meter)
+    const meter = this.ctx.tokenMeter
     const requestHeader = provisionalHeader(model, agent.session, fullSystemPrompt, sessionPrefix)
-    const threshold = Math.floor(policy.contextWindow * policy.thresholdRatio)
+    const threshold = Math.floor(meter.contextWindow * this.config.thresholdRatio)
     let measurement = meter.measure(agent.session, requestHeader)
     if (measurement.totalTokens < threshold) return null
 
@@ -139,7 +129,7 @@ export class BasicCompactService extends CompactService {
           `compaction: pressure revision ${measurement.logRevision} does not match surface revision ${surface.logRevision}`,
         )
       }
-      const range = selectCompactableRange(agent.session, surface, policy.retainTokens)
+      const range = selectCompactableRange(agent.session, surface, this.config.retainTokens)
       if (range === null) {
         /* v8 ignore else -- concrete replacement preserves a compactable checkpoint; subclass hooks cannot mutate it. */
         if (result === null) return null
@@ -159,12 +149,12 @@ export class BasicCompactService extends CompactService {
 
   /**
    * Compact one inclusive positional surface range using the effective
-   * conversation model for all retention and shrink pricing. Reject an agent
-   * that does not own the exact target before any resolution or mutation.
+   * token meter for all retention and shrink pricing. Reject an agent that does
+   * not own the exact target before any mutation.
    * @param session - session whose surface is mutated; must equal `agent.session`.
    * @param start - inclusive first surface-node seq.
    * @param end - inclusive last surface-node seq.
-   * @param agent - owner of the target session, used by the summarizer and model resolver.
+   * @param agent - owner of the target session, used by the summarizer.
    * @param signal - optional summarization cancellation signal.
    * @returns the successful durable compaction result.
    */
@@ -178,27 +168,11 @@ export class BasicCompactService extends CompactService {
     if (session !== agent.session) {
       throw new Error('compactRegion: agent.session must be the exact target session')
     }
-    const model = effectiveModel(agent)
-    if (model === undefined || model.length === 0) {
-      throw new Error('compactRegion: no routed or configured conversation model is available for token pricing')
-    }
-    const meter = this.ctx.tokenMeter.resolve(model)
-    this._modelConfig(meter)
     return compactSurfaceRegion({
-      meter,
+      meter: this.ctx.tokenMeter,
       summarize: (text, owner, abort) => this.summarize(text, owner, abort),
     }, session, start, end, agent, signal)
   }
-
-  /** Resolve and memoize one lazy default/override model policy. */
-  private _modelConfig(meter: ModelTokenMeter): ResolvedModelCompactConfig {
-    let modelConfig = this.modelConfigs.get(meter.model)
-    if (modelConfig === undefined) {
-      modelConfig = resolveModelConfig(this.config, meter)
-      this.modelConfigs.set(meter.model, modelConfig)
-    }
-    return modelConfig
-  }
 }
 
 export default BasicCompactService

packages/compact/compact-basic/src/region.ts

@@ -10,14 +10,14 @@ import {
   toolPairingBalancedBefore,
 } from '@deepseek-ai/dsh-compact'
 import type { CompactionResult } from '@deepseek-ai/dsh-compact'
-import type { ModelTokenMeter, TokenSurfaceMeasurement } from '@deepseek-ai/dsh-token-meter'
+import type { TokenMeterService, TokenSurfaceMeasurement } from '@deepseek-ai/dsh-token-meter'
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import { frameSummary } from './summarizer.ts'
 import type { SummaryResult } from './summarizer.ts'
 
 interface RegionDependencies {
-  readonly meter: ModelTokenMeter
+  readonly meter: TokenMeterService
   summarize(text: string, agent: Agent, signal?: AbortSignal): Promise<SummaryResult>
 }
 

packages/compact/compact-basic/src/types.ts

@@ -4,18 +4,12 @@
  * @module @deepseek-ai/dsh-compact-basic/types
  */
 
-/** Optional pressure and retention policy for one metered model. */
-export interface ModelCompactConfig {
-  /** Compact at this fraction of the model's configured context window. Defaults to `0.8`. */
+/** Basic compaction configuration; every common field has a deployment default. */
+export interface BasicCompactConfig {
+  /** Compact at this fraction of the token meter's context window. Defaults to `0.8`. */
   thresholdRatio?: number
   /** Recent surface tokens retained verbatim. Defaults to `floor(contextWindow * 0.16)`. */
   retainTokens?: number
-}
-
-/** Basic compaction configuration; every common field has a deployment default. */
-export interface BasicCompactConfig {
-  /** Field-wise pressure/retention overrides keyed by configured token-meter model name. */
-  models?: Record<string, ModelCompactConfig>
   /** Summary model; `''` resolves the latest routed model, then `AgentOptions.model`. Defaults to `''`. */
   summarizationModel?: string
   /** Provider generation cap for summarization. Defaults to `8192`. */
@@ -26,19 +20,12 @@ export interface BasicCompactConfig {
   auto?: boolean
 }
 
-/** Validated top-level defaults plus detached per-model partial overrides. */
+/** Validated and detached compaction configuration. */
 export interface ResolvedConfig {
-  readonly models: Readonly<Record<string, Readonly<ModelCompactConfig>>>
+  readonly thresholdRatio: number
+  readonly retainTokens: number
   readonly summarizationModel: string
   readonly maxTokens: number
   readonly compactionRetries: number
   readonly auto: boolean
 }
-
-/** Fully resolved pressure/retention policy for one effective model. */
-export interface ResolvedModelCompactConfig {
-  readonly model: string
-  readonly contextWindow: number
-  readonly thresholdRatio: number
-  readonly retainTokens: number
-}

packages/compact/compact-basic/tests/compact-basic.spec.ts

@@ -1,31 +1,21 @@
 import { describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
-import BasicCompactService, {
-  resolveConfig,
-  resolveModelConfig,
-} from '@deepseek-ai/dsh-compact-basic'
+import BasicCompactService, { resolveConfig } from '@deepseek-ai/dsh-compact-basic'
 import type { BasicCompactConfig } from '@deepseek-ai/dsh-compact-basic'
 import { selectCompactableRange } from '@deepseek-ai/dsh-compact-basic/src/region.ts'
 import type { CompactionResult } from '@deepseek-ai/dsh-compact'
 import LlmService, { CallId, LlmAdapter } from '@deepseek-ai/dsh-llm'
 import type { ContentBlock, GenerateOptions, Message, StreamChunk } from '@deepseek-ai/dsh-llm'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
-import TokenMeterService, {
-  TOKEN_METER_MODEL_UNCONFIGURED,
-  TokenMeterError,
-} from '@deepseek-ai/dsh-token-meter'
+import TokenMeterService from '@deepseek-ai/dsh-token-meter'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 
 const SIGNAL = new AbortController().signal
 const MODEL = 'test-model'
 
-function createContext(
-  models: Record<string, { contextWindow?: number; charsPerToken?: number }> = {
-    [MODEL]: { contextWindow: 100, charsPerToken: 1_000 },
-  },
-): Context {
+function createContext(contextWindow = 1_000): Context {
   const ctx = new Context()
-  void new TokenMeterService(ctx, { models })
+  void new TokenMeterService(ctx, { contextWindow })
   return ctx
 }
 
@@ -34,7 +24,7 @@ function agent(session: Session, model?: string): Agent {
 }
 
 /** Closed two-message turns followed by one open turn for durable compaction events. */
-function conversation(turns = 4, text = 'fixture'): Session {
+function conversation(turns = 4, text = 'fixture '.repeat(40).trim()): Session {
   const session = new Session(SessionId(`conversation-${turns}`))
   for (let turn = 1; turn <= turns; turn += 1) {
     session.append('turn/start', { turn, trigger: { kind: 'message', source: { kind: 'user' } } })
@@ -128,83 +118,64 @@ async function compactIfNeeded(
 }
 
 describe('compact configuration and defaults', () => {
-  it('uses low-friction common and per-profile defaults', () => {
-    const ctx = createContext({
-      [MODEL]: { contextWindow: 100, charsPerToken: 1_000 },
-      large: { contextWindow: 1_000, charsPerToken: 4 },
-    })
+  it('uses low-friction service-wide defaults', () => {
+    const ctx = createContext()
     const resolved = resolveConfig({}, ctx.tokenMeter)
 
     expect(resolved).toEqual({
-      models: {},
+      thresholdRatio: 0.8,
+      retainTokens: 160,
       summarizationModel: '',
       maxTokens: 8192,
       compactionRetries: 1,
       auto: true,
     })
-    expect(resolveModelConfig(resolved, ctx.tokenMeter.resolve(MODEL))).toEqual({
-      model: MODEL,
-      contextWindow: 100,
-      thresholdRatio: 0.8,
-      retainTokens: 16,
-    })
-    expect(resolveModelConfig(resolved, ctx.tokenMeter.resolve('large')).retainTokens).toBe(160)
     expect(Object.isFrozen(resolved)).toBe(true)
   })
 
-  it('merges threshold and retention overrides field-wise', () => {
+  it('resolves threshold and retention overrides independently', () => {
     const ctx = createContext()
     const thresholdOnly = resolveConfig({
-      models: { [MODEL]: { thresholdRatio: 0.5 } },
+      thresholdRatio: 0.5,
     }, ctx.tokenMeter)
-    expect(resolveModelConfig(thresholdOnly, ctx.tokenMeter.resolve(MODEL))).toMatchObject({
+    expect(thresholdOnly).toMatchObject({
       thresholdRatio: 0.5,
-      retainTokens: 16,
+      retainTokens: 160,
     })
 
     const retentionOnly = resolveConfig({
-      models: { [MODEL]: { retainTokens: 7 } },
+      retainTokens: 70,
     }, ctx.tokenMeter)
-    expect(resolveModelConfig(retentionOnly, ctx.tokenMeter.resolve(MODEL))).toMatchObject({
+    expect(retentionOnly).toMatchObject({
       thresholdRatio: 0.8,
-      retainTokens: 7,
+      retainTokens: 70,
     })
   })
 
-  it('validates common values and model policy invariants', () => {
+  it('validates common values and pressure-policy invariants', () => {
     const ctx = createContext()
     const bad = [
       [{ maxTokens: 0 }, /maxTokens/],
       [{ compactionRetries: -1 }, /compactionRetries/],
       [{ auto: 'yes' }, /auto must be a boolean/],
       [{ summarizationModel: 1 }, /summarizationModel must be a string/],
-      [{ models: null }, /models must be an object/],
-      [{ models: { [MODEL]: null } }, /must be an object/],
-      [{ models: { [MODEL]: { thresholdRatio: 0 } } }, /number in \(0, 1\]/],
-      [{ models: { [MODEL]: { thresholdRatio: 1.1 } } }, /number in \(0, 1\]/],
-      [{ models: { [MODEL]: { retainTokens: -1 } } }, /non-negative integer/],
-      [{ models: { [MODEL]: { thresholdRatio: 0.5, retainTokens: 50 } } }, /less than threshold/],
+      [{ thresholdRatio: 0 }, /number in \(0, 1\]/],
+      [{ thresholdRatio: 1.1 }, /number in \(0, 1\]/],
+      [{ retainTokens: -1 }, /non-negative integer/],
+      [{ thresholdRatio: 0.5, retainTokens: 500 }, /less than threshold/],
     ] as Array<[unknown, RegExp]>
 
     for (const [config, pattern] of bad) {
       expect(() => resolveConfig(config as BasicCompactConfig, ctx.tokenMeter)).toThrow(pattern)
     }
   })
-
-  it('rejects an override for an unknown meter profile with the exact typed error', () => {
-    const ctx = createContext()
-    expect(() => resolveConfig({ models: { missing: { retainTokens: 1 } } }, ctx.tokenMeter))
-      .toThrow(expect.objectContaining({
-        code: TOKEN_METER_MODEL_UNCONFIGURED,
-        model: 'missing',
-      }))
-  })
 })
 
 describe('pressure measurement and retention', () => {
   const compactConfig: BasicCompactConfig = {
     auto: false,
-    models: { [MODEL]: { thresholdRatio: 0.5, retainTokens: 18 } },
+    thresholdRatio: 0.5,
+    retainTokens: 180,
   }
 
   it('skips the provisional check only when no routed or fallback model exists', async () => {
@@ -214,10 +185,10 @@ describe('pressure measurement and retention', () => {
     expect(compact.calls).toHaveLength(0)
   })
 
-  it('throws for a named unconfigured model instead of swallowing it', async () => {
+  it('meters any routed model without profile resolution', async () => {
     const compact = service(compactConfig)
-    await expect(compactIfNeeded(compact, conversation(), 'missing'))
-      .rejects.toMatchObject({ code: TOKEN_METER_MODEL_UNCONFIGURED, model: 'missing' })
+    await expect(compactIfNeeded(compact, conversation(), 'unlisted-model'))
+      .resolves.not.toBeNull()
   })
 
   it('does nothing below threshold and compacts a priced head above threshold', async () => {
@@ -234,38 +205,39 @@ describe('pressure measurement and retention', () => {
   it('counts the current prompt and request prefix without putting either on the surface', async () => {
     const compact = service({
       auto: false,
-      models: { [MODEL]: { thresholdRatio: 0.7, retainTokens: 9 } },
+      thresholdRatio: 0.7,
+      retainTokens: 50,
     })
-    const session = conversation(2, 'x'.repeat(2_000))
+    const session = conversation(2, 'x'.repeat(200))
     expect(await compactIfNeeded(compact, session)).toBeNull()
 
     const prefix: Message[] = [{
       role: 'user',
-      content: [{ type: 'text', text: 'p'.repeat(10_000) }],
+      content: [{ type: 'text', text: 'p'.repeat(1_000) }],
     }]
-    const result = await compactIfNeeded(compact, session, MODEL, 's'.repeat(5_000), prefix)
+    const result = await compactIfNeeded(compact, session, MODEL, 's'.repeat(1_000), prefix)
     expect(result).not.toBeNull()
     expect(prefix).toHaveLength(1)
     expect(session.events.some(event => event.type === 'context/message')).toBe(false)
   })
 
-  it('uses the latest logged routed model instead of AgentOptions.model', async () => {
-    const ctx = createContext({
-      actual: { contextWindow: 100, charsPerToken: 1_000 },
-      fallback: { contextWindow: 10_000, charsPerToken: 1_000 },
-    })
+  it('uses the latest logged routed model in the provisional request envelope', async () => {
+    const ctx = createContext()
     const compact = service({
       auto: false,
-      models: { actual: { thresholdRatio: 0.5, retainTokens: 18 } },
+      thresholdRatio: 0.5,
+      retainTokens: 180,
     }, ctx)
     const session = conversation(4)
     session.append('request/header', {
       header: { config: { model: 'actual' } },
       reason: 'initial',
     })
+    const measure = vi.spyOn(ctx.tokenMeter, 'measure')
 
     const result = await compactIfNeeded(compact, session, 'fallback')
     expect(result).not.toBeNull()
+    expect(measure.mock.calls[0]?.[1]?.config.model).toBe('actual')
   })
 
   it('declines when envelope pressure is high but the surface has no compactable range', async () => {
@@ -279,7 +251,7 @@ describe('pressure measurement and retention', () => {
 
   it('detects scalar/surface revision disagreement', async () => {
     const ctx = createContext()
-    const meter = ctx.tokenMeter.resolve(MODEL)
+    const meter = ctx.tokenMeter
     const original = meter.measureSurface.bind(meter)
     vi.spyOn(meter, 'measureSurface').mockImplementation((session) => {
       const measurement = original(session)
@@ -294,7 +266,8 @@ describe('pressure measurement and retention', () => {
     const compact = service({
       auto: false,
       compactionRetries: 0,
-      models: { [MODEL]: { thresholdRatio: 0.5, retainTokens: 18 } },
+      thresholdRatio: 0.3,
+      retainTokens: 180,
     })
     compact.summary = Array.from({ length: 7 }, (_, index) => ({
       type: 'text',
@@ -308,8 +281,9 @@ describe('pressure measurement and retention', () => {
   it('rounds a retention cut head-ward to preserve tool-call/result pairing', async () => {
     const compact = service({
       auto: false,
-      models: { [MODEL]: { thresholdRatio: 0.8, retainTokens: 8 } },
-    })
+      thresholdRatio: 0.8,
+      retainTokens: 80,
+    }, createContext(4_000))
     const session = toolConversation()
     const result = await compactIfNeeded(compact, session)
     expect(result).not.toBeNull()
@@ -327,7 +301,7 @@ describe('pressure measurement and retention', () => {
   it('rejects a priced surface that is not the current positional surface', () => {
     const ctx = createContext()
     const session = conversation(2)
-    const priced = ctx.tokenMeter.resolve(MODEL).measureSurface(session)
+    const priced = ctx.tokenMeter.measureSurface(session)
     expect(() => selectCompactableRange(session, {
       ...priced,
       nodes: priced.nodes.slice(1),
@@ -355,7 +329,7 @@ describe('pressure measurement and retention', () => {
     }, { surfaceOp: 'append' })
     session.append('step/end', { turn: 1, step: 1 })
 
-    const priced = ctx.tokenMeter.resolve(MODEL).measureSurface(session)
+    const priced = ctx.tokenMeter.measureSurface(session)
     expect(selectCompactableRange(session, priced, 1)).toBeNull()
   })
 })
@@ -497,7 +471,7 @@ describe('compaction region transaction', () => {
 
   it('rejects a meter snapshot that changed before summarization began', async () => {
     const ctx = createContext()
-    const meter = ctx.tokenMeter.resolve(MODEL)
+    const meter = ctx.tokenMeter
     const original = meter.measureSurface.bind(meter)
     vi.spyOn(meter, 'measureSurface').mockImplementationOnce((session) => {
       const measurement = original(session)
@@ -569,7 +543,7 @@ describe('compaction region transaction', () => {
 
   it('rejects a non-shrinking framed summary under the conversation meter', async () => {
     const compact = service()
-    compact.summary = Array.from({ length: 20 }, (_, index) => ({
+    compact.summary = Array.from({ length: 100 }, (_, index) => ({
       type: 'text',
       text: `verbose ${index}`,
     }))
@@ -585,7 +559,7 @@ describe('compaction region transaction', () => {
     expect(session.events.some(event => event.type === 'compact/summary')).toBe(false)
   })
 
-  it('requires a conversation model for pricing', async () => {
+  it('lets a model-independent custom summarizer compact without a conversation model', async () => {
     const compact = service()
     const session = conversation(1)
     const nodes = session.surface.nodes
@@ -594,7 +568,7 @@ describe('compaction region transaction', () => {
       nodes[0]!.seq,
       nodes[1]!.seq,
       agent(session),
-    )).rejects.toThrow(/no routed or configured conversation model/)
+    )).resolves.toMatchObject({ shadowedSeqs: [nodes[0]!.seq, nodes[1]!.seq] })
   })
 })
 
@@ -632,7 +606,7 @@ async function summarizerHarness(
 ): Promise<{ ctx: Context; adapter: ScriptedAdapter; compact: BasicCompactService }> {
   const ctx = new Context()
   await ctx.plugin(LlmService)
-  void new TokenMeterService(ctx, { models: { [model]: { contextWindow: 100 } } })
+  void new TokenMeterService(ctx, { contextWindow: 1_000 })
   const adapter = new ScriptedAdapter(blocks, finish)
   ctx.llm.registerAdapter([model], adapter)
   const compact = new BasicCompactService(ctx, config)
@@ -724,7 +698,8 @@ describe('automatic listener and loader composition', () => {
   it('compacts above threshold and remains idle below it', async () => {
     const ctx = createContext()
     const compact = new TestCompactService(ctx, {
-      models: { [MODEL]: { thresholdRatio: 0.5, retainTokens: 18 } },
+      thresholdRatio: 0.5,
+      retainTokens: 180,
     })
     const pressured = conversation(4)
     await preStep(ctx, agent(pressured, MODEL))
@@ -741,7 +716,8 @@ describe('automatic listener and loader composition', () => {
     const warnings: string[] = []
     ctx.logger.warn = ((message: string) => void warnings.push(message)) as typeof ctx.logger.warn
     const compact = new TestCompactService(ctx, {
-      models: { [MODEL]: { thresholdRatio: 0.5, retainTokens: 18 } },
+      thresholdRatio: 0.5,
+      retainTokens: 180,
     })
     compact.error = 'temporary failure'
     const session = conversation(4)
@@ -751,20 +727,12 @@ describe('automatic listener and loader composition', () => {
     expect(session.events.some(event => event.type === 'compact/summary')).toBe(false)
   })
 
-  it('propagates a named unknown-model configuration failure', async () => {
-    const ctx = createContext()
-    void new TestCompactService(ctx)
-    await expect(preStep(ctx, agent(conversation(4), 'missing'))).rejects.toMatchObject({
-      code: TOKEN_METER_MODEL_UNCONFIGURED,
-      model: 'missing',
-    })
-  })
-
   it('auto:false installs no listener', async () => {
     const ctx = createContext()
     void new TestCompactService(ctx, {
       auto: false,
-      models: { [MODEL]: { thresholdRatio: 0.5, retainTokens: 18 } },
+      thresholdRatio: 0.5,
+      retainTokens: 180,
     })
     const session = conversation(4)
     await preStep(ctx, agent(session, MODEL))
@@ -777,7 +745,7 @@ describe('automatic listener and loader composition', () => {
     const meterFiber = await ctx.plugin(TokenMeterService)
     const compactFiber = await ctx.plugin(BasicCompactService, { auto: false })
 
-    expect(ctx.tokenMeter.resolve('deepseek-v4-flash').contextWindow).toBe(128_000)
+    expect(ctx.tokenMeter.contextWindow).toBe(128_000)
     expect(ctx.get('compact')).toBeInstanceOf(BasicCompactService)
     await compactFiber.dispose()
     expect(ctx.get('compact')).toBeUndefined()
@@ -788,11 +756,10 @@ describe('automatic listener and loader composition', () => {
   it('removes its automatic listener with the plugin fiber', async () => {
     const ctx = new Context()
     await ctx.plugin(LlmService)
-    await ctx.plugin(TokenMeterService, {
-      models: { [MODEL]: { contextWindow: 100, charsPerToken: 1_000 } },
-    })
+    await ctx.plugin(TokenMeterService, { contextWindow: 1_000 })
     const fiber = await ctx.plugin(TestCompactService, {
-      models: { [MODEL]: { thresholdRatio: 0.5, retainTokens: 18 } },
+      thresholdRatio: 0.5,
+      retainTokens: 180,
     })
     await fiber.dispose()
 
@@ -801,17 +768,3 @@ describe('automatic listener and loader composition', () => {
     expect(session.events.some(event => event.type === 'compact/start')).toBe(false)
   })
 })
-
-describe('typed unknown-model boundary', () => {
-  it('uses TokenMeterError identity rather than message matching', () => {
-    const ctx = createContext()
-    let thrown: unknown
-    try {
-      ctx.tokenMeter.resolve('missing')
-    } catch (error: unknown) {
-      thrown = error
-    }
-    expect(thrown).toBeInstanceOf(TokenMeterError)
-    expect(thrown).toMatchObject({ code: TOKEN_METER_MODEL_UNCONFIGURED })
-  })
-})

packages/compact/compact-basic/tests/compact-loop-repro.spec.ts

@@ -62,9 +62,7 @@ async function harness(toolSteps: number): Promise<{ ctx: Context; compact: Repr
   await ctx.plugin(ToolRegistry)
   await ctx.plugin(AgentRegistry)
   await ctx.plugin(AgentLoop, { agents: [] })
-  await ctx.plugin(TokenMeterService, {
-    models: { mock: { contextWindow: 64, charsPerToken: 1_000 } },
-  })
+  await ctx.plugin(TokenMeterService, { contextWindow: 400 })
   ctx.llm.registerAdapter(['mock'], new StepwiseToolAdapter(toolSteps))
   ctx.tools.register(defineTool({
     name: 'work',
@@ -74,11 +72,12 @@ async function harness(toolSteps: number): Promise<{ ctx: Context; compact: Repr
       return [{ type: 'text', text: 'work result' }]
     },
   }))
-  // Tiny window so a couple of tool steps cross the threshold and compaction
-  // fires within the runaway turn.
+  // Small window so several tool steps cross the threshold and compaction
+  // fires within the runaway turn after enough history can shrink.
   const compact = new ReproCompactService(ctx, {
     auto: true,
-    models: { mock: { thresholdRatio: 0.5, retainTokens: 20 } },
+    thresholdRatio: 0.5,
+    retainTokens: 50,
     summarizationModel: '',
     maxTokens: 8192,
     compactionRetries: 1,

packages/compact/compact-basic/tests/loader-composition.spec.ts

@@ -57,10 +57,7 @@ describe('real Loader composition', () => {
       .filter(entry => entry.fiber === undefined && !entry.disabled)
       .map(entry => entry.options.name)
     expect(unloaded).toEqual([])
-    expect(context.tokenMeter.resolve('deepseek-v4-flash')).toMatchObject({
-      contextWindow: 128_000,
-      charsPerToken: 4,
-    })
+    expect(context.tokenMeter.contextWindow).toBe(128_000)
     expect(context.get('compact')).toBeInstanceOf(BasicCompactService)
   })
 })

packages/cordis/tool-cordis/src/api-catalog.ts

@@ -224,9 +224,11 @@ export const SERVICE_API: readonly ServiceApiEntry[] = [
   },
   {
     key: 'tokenMeter',
-    summary: 'Concrete registry and replay owner for all configured model meters.',
+    summary: 'Replay owner for one service-wide estimator and isolated per-session folds.',
     methods: [
-      'resolve(model: string): ModelTokenMeter',
+      'measure(session: Session, requestHeader?: EpochHeader): TokenMeasurement',
+      'measureSurface(session: Session): TokenSurfaceMeasurement',
+      'estimateMessage(message: Message): number',
     ],
   },
   {
@@ -760,10 +762,6 @@ export const TYPE_API: readonly TypeApiEntry[] = [
     name: 'MessageSourceMap',
     declaration: 'export interface MessageSourceMap {\n    user: {\n        kind: \'user\';\n    };\n    plugin: {\n        kind: \'plugin\';\n        plugin: string;\n    };\n}',
   },
-  {
-    name: 'ModelTokenMeter',
-    declaration: 'export interface ModelTokenMeter {\n    readonly model: string;\n    readonly contextWindow: number;\n    readonly charsPerToken: number;\n    measure(session: Session, requestHeader?: EpochHeader): TokenMeasurement;\n    measureSurface(session: Session): TokenSurfaceMeasurement;\n    estimateMessage(message: Message): number;\n}',
-  },
   {
     name: 'PresetOption',
     declaration: 'export interface PresetOption {\n    value: string;\n    name: string;\n    description?: string;\n}',
@@ -994,7 +992,7 @@ export const TYPE_API: readonly TypeApiEntry[] = [
   },
   {
     name: 'TokenMeasurement',
-    declaration: 'export interface TokenMeasurement {\n    readonly model: string;\n    readonly logRevision: number;\n    readonly baseline: TokenMeasurementBaseline;\n    readonly surfaceDeltaTokens: number;\n    readonly totalTokens: number;\n}',
+    declaration: 'export interface TokenMeasurement {\n    readonly logRevision: number;\n    readonly baseline: TokenMeasurementBaseline;\n    readonly surfaceDeltaTokens: number;\n    readonly totalTokens: number;\n}',
   },
   {
     name: 'TokenMeasurementBaseline',
@@ -1002,7 +1000,7 @@ export const TYPE_API: readonly TypeApiEntry[] = [
   },
   {
     name: 'TokenSurfaceMeasurement',
-    declaration: 'export interface TokenSurfaceMeasurement {\n    readonly model: string;\n    readonly logRevision: number;\n    readonly totalTokens: number;\n    readonly nodes: readonly TokenSurfaceNode[];\n}',
+    declaration: 'export interface TokenSurfaceMeasurement {\n    readonly logRevision: number;\n    readonly totalTokens: number;\n    readonly nodes: readonly TokenSurfaceNode[];\n}',
   },
   {
     name: 'TokenSurfaceNode',

packages/llm/README.md

@@ -5,7 +5,7 @@ The LLM seam and its provider adapters. The interface package (`llm`) owns the a
 | Package | Role | ctx key |
 |---|---|---|
 | `llm/` | Abstract LLM service + content-block vocabulary + chunk assembler | `ctx.llm` |
-| `token-meter/` | Replay-aware, per-model request and surface token measurement | `ctx.tokenMeter` |
+| `token-meter/` | Replay-aware request and surface token measurement | `ctx.tokenMeter` |
 | `llm-deepseek/` | DeepSeek API adapter (hand-rolled fetch/SSE) | (registers on `ctx.llm`) |
 | `llm-pi-ai/` | DeepSeek adapter via `@earendil-works/pi-ai` (design twin) | (registers on `ctx.llm`) |
 

packages/llm/token-meter/README.md

@@ -1,29 +1,26 @@
 # @deepseek-ai/dsh-token-meter
 
-Replay-aware token measurement through `ctx.tokenMeter`. The service binds one stable meter to each configured model and advances isolated per-model/per-session folds from the durable session log. Compaction consumes it today; other pressure-sensitive plugins can reuse the same accounting without depending on `CompactService`.
+Replay-aware token measurement through the singleton `ctx.tokenMeter` service. It advances one isolated fold per session from the durable log, so compaction and other pressure-sensitive plugins can share accounting without depending on `CompactService`.
 
-## Profiles and configuration
-
-The built-in `deepseek-v4-flash` and `deepseek-v4-pro` profiles each use a 128,000-token context window and four characters per estimated token. `models` merges overrides field-by-field, so changing only density keeps the built-in window. A custom model requires `contextWindow`; its `charsPerToken` defaults to `4`.
+## Configuration
 
 | Key | Default | Contract |
 |---|---:|---|
-| `models.<built-in>.contextWindow` | `128000` | Positive integer provider capacity. |
-| `models.<model>.charsPerToken` | `4` | Positive finite heuristic density. |
+| `contextWindow` | `128000` | Positive integer service-wide context capacity. |
 
-Resolving an unknown model throws `TokenMeterError` with code `TOKEN_METER_MODEL_UNCONFIGURED` and preserves the exact model name. Direct-construction profile validation uses `TOKEN_METER_INVALID_CONFIG`; Loader mounts first apply the package's Schemastery shape validation. There is no universal fallback window.
+The estimator intentionally uses one fixed heuristic: four characters per token plus structural overhead for roles, blocks, and request-envelope fields. `contextWindow` is the only deployment setting. Direct construction validates it; Loader mounts first apply the package's Schemastery shape validation.
 
 ## Measurement contract
 
-`ctx.tokenMeter.resolve(model)` returns a `ModelTokenMeter` with three operations:
+`ctx.tokenMeter` directly exposes three operations:
 
 - `measure(session, requestHeader?)` returns scalar request pressure at one consumed-log revision.
 - `measureSurface(session)` returns current surface nodes and their per-node prices at the same kind of revision.
-- `estimateMessage(message)` prices one detached message under that profile.
+- `estimateMessage(message)` prices one message with the fixed heuristic.
 
 Measurements are detached and deeply immutable. A caller that needs a consistent scalar/surface decision compares their `logRevision` values instead of copying the full history on every read.
 
-The fold tracks request headers and deltas, step boundaries, surface appends and replacements, successful assistant messages, provider usage, and assistant-chunk provenance. Provider usage is reused only when the handle's model and the canonical request envelope match the successful-call anchor. Otherwise the complete current envelope and surface are repriced under the requested model. Surface changes remain signed relative to a matching anchor, including negative deltas after shrinking replacements.
+The fold tracks request headers and deltas, step boundaries, surface appends and replacements, successful assistant messages, provider usage, and assistant-chunk provenance. Provider usage is reused only when the latest successful call's canonical request envelope matches the measured envelope; a later success replaces the earlier anchor. Otherwise the complete current envelope and surface are estimated. Surface changes remain signed relative to a matching anchor, including negative deltas after shrinking replacements.
 
 Usage accounting sums disjoint input, cache-read, cache-write, and output buckets; reasoning is not added again. Every successful call records an assistant anchor, including content-less calls. An explicit empty provenance list means a known empty provider stream, while absent legacy provenance conservatively treats the durable assistant output as provider output.
 
@@ -34,16 +31,12 @@ Usage accounting sums disjoint input, cache-read, cache-write, and output bucket
 - name: '@deepseek-ai/dsh-compact-basic'
 ```
 
-Both plugins have usable defaults for the bundled DeepSeek profiles. Custom deployments can override only the fields that differ:
+Both plugins have usable defaults. A deployment with a different capacity configures the meter once:
 
 ```yaml
 - name: '@deepseek-ai/dsh-token-meter'
   config:
-    models:
-      deepseek-v4-flash:
-        charsPerToken: 2
-      local-model:
-        contextWindow: 32768
+    contextWindow: 32768
 ```
 
 ## Model Experience
@@ -52,6 +45,6 @@ Indirectly, through consumers such as `dsh-compact-basic`; the service itself ad
 
 ## Known Limitations and Deferred Work
 
-- **Heuristic density still needs maintenance** — message content without provider usage is priced by configured character density plus structural overhead, not an exact provider tokenizer. CJK-heavy or provider-specific formats may need profile overrides.
-- **Provider usage is only reusable for an identical canonical envelope** — prompt, prefix, tools, or call-config changes deliberately fall back to full heuristic repricing.
+- **The fixed heuristic is approximate** — content without reusable provider usage is priced by character count plus structural overhead, not an exact provider tokenizer or request serializer.
+- **Provider usage is only reusable for an identical canonical envelope** — prompt, prefix, tools, model, or call-config changes deliberately fall back to full heuristic estimation.
 - **Legacy provenance is conservative** — assistant messages without `sourceEventSeqs` cannot distinguish provider output from listener rewrites, so the fold avoids claiming a known empty or exact chunk stream.

packages/llm/token-meter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepseek-ai/dsh-token-meter",
-  "description": "Replay-aware per-model token measurement service (ctx.tokenMeter) for the DeepSeek Harness",
+  "description": "Replay-aware token measurement service (ctx.tokenMeter) for the DeepSeek Harness",
   "version": "0.0.1",
   "private": true,
   "type": "module",

packages/llm/token-meter/src/index.ts

@@ -1,192 +1,414 @@
 /**
- * Replay token-meter service with model-specific context capacity and pricing.
+ * Single replay-aware token-meter service for request and surface pressure.
  *
  * @module @deepseek-ai/dsh-token-meter
  */
 
 import { Context, Service } from 'cordis'
 import z from 'schemastery'
-import { HarnessError, deepFreeze } from '@deepseek-ai/dsh-llm'
-import type { Session } from '@deepseek-ai/dsh-session'
-import { ReplayModelTokenMeter } from './replay.ts'
-import type { ModelTokenProfile } from './replay.ts'
+import { BlockAssembler, deepFreeze } from '@deepseek-ai/dsh-llm'
+import type { ContentBlock, Message, TokenUsage } from '@deepseek-ai/dsh-llm'
+import type { EpochHeader, Session, SessionEvent, SurfaceEvent } from '@deepseek-ai/dsh-session'
+import { applyHeaderDelta, canonicalHeader, headerEquals, isSurfaceEvent } from '@deepseek-ai/dsh-session'
 import type {
-  ModelTokenMeter,
-  ModelTokenMeterConfig,
+  TokenMeasurement,
+  TokenMeasurementBaseline,
   TokenMeterConfig,
+  TokenSurfaceMeasurement,
+  TokenSurfaceNode,
 } from './types.ts'
 
 export type * from './types.ts'
 
-/** Exact error code for resolving a model without a configured profile. */
-export const TOKEN_METER_MODEL_UNCONFIGURED = 'TOKEN_METER_MODEL_UNCONFIGURED'
-
-/** Exact error code for invalid token-meter configuration. */
-export const TOKEN_METER_INVALID_CONFIG = 'TOKEN_METER_INVALID_CONFIG'
-
-/** Closed machine-routable token-meter failure taxonomy. */
-export type TokenMeterErrorCode =
-  | typeof TOKEN_METER_MODEL_UNCONFIGURED
-  | typeof TOKEN_METER_INVALID_CONFIG
-
-/** Built-in DeepSeek model profiles available with zero configuration. */
-const BUILTIN_TOKEN_PROFILES: Readonly<Record<string, Readonly<ModelTokenProfile>>> = deepFreeze({
-  'deepseek-v4-flash': {
-    model: 'deepseek-v4-flash',
-    contextWindow: 128_000,
-    charsPerToken: 4,
-  },
-  'deepseek-v4-pro': {
-    model: 'deepseek-v4-pro',
-    contextWindow: 128_000,
-    charsPerToken: 4,
-  },
-})
-
-/** Typed token-meter failure with the affected model preserved for callers. */
-export class TokenMeterError extends HarnessError {
-  declare readonly code: TokenMeterErrorCode
-  /** Exact model name involved in this error, when applicable. */
-  readonly model: string | undefined
-
-  constructor(message: string, code: TokenMeterErrorCode, model?: string, options?: ErrorOptions) {
-    super(message, code, options)
-    this.name = 'TokenMeterError'
-    this.model = model
-  }
-}
+/** Default service-wide provider context capacity. */
+const DEFAULT_CONTEXT_WINDOW = 128_000
 
-declare module 'cordis' {
-  interface Context {
-    tokenMeter: TokenMeterService
-  }
-}
+/** Fixed text-density estimate used until exact tokenization is needed. */
+const CHARS_PER_TOKEN = 4
 
-/** Validate and detach all configured model profiles. */
-function resolveProfiles(config: TokenMeterConfig): readonly ModelTokenProfile[] {
-  const profiles = new Map<string, ModelTokenProfile>()
-  for (const profile of Object.values(BUILTIN_TOKEN_PROFILES)) {
-    profiles.set(profile.model, { ...profile })
-  }
+/** Per-block structural overhead for JSON framing and type tags. */
+const BLOCK_OVERHEAD = 4
 
-  const configuredValue: unknown = config.models
-  const configuredModels = configuredValue === undefined ? {} : configuredValue
-  if (typeof configuredModels !== 'object'
-    || configuredModels === null
-    || Array.isArray(configuredModels)) {
-    throw new TokenMeterError(
-      'TokenMeterConfig: models must be an object',
-      TOKEN_METER_INVALID_CONFIG,
-    )
-  }
+/** Role-field framing overhead added to every priced message. */
+const ROLE_OVERHEAD = 4
 
-  for (const [model, override] of Object.entries(configuredModels as Record<string, unknown>)) {
-    if (model.length === 0) {
-      throw new TokenMeterError(
-        'TokenMeterConfig: model names must not be empty',
-        TOKEN_METER_INVALID_CONFIG,
-        model,
-      )
-    }
-    assertProfileObject(model, override)
-    const builtIn = profiles.get(model)
-    const contextWindow = override.contextWindow ?? builtIn?.contextWindow
-    const charsPerToken = override.charsPerToken ?? builtIn?.charsPerToken ?? 4
-    if (contextWindow === undefined) {
-      throw new TokenMeterError(
-        `TokenMeterConfig: custom model "${model}" requires contextWindow`,
-        TOKEN_METER_INVALID_CONFIG,
-        model,
-      )
-    }
-    assertPositiveInteger(model, 'contextWindow', contextWindow)
-    assertPositiveFinite(model, 'charsPerToken', charsPerToken)
-    profiles.set(model, { model, contextWindow, charsPerToken })
-  }
+interface MeasurementAnchor {
+  readonly header: EpochHeader | undefined
+  readonly surfaceTokens: number
+  readonly baseline: Exclude<TokenMeasurementBaseline, { kind: 'none' }>
+}
 
-  for (const profile of profiles.values()) {
-    assertPositiveInteger(profile.model, 'contextWindow', profile.contextWindow)
-    assertPositiveFinite(profile.model, 'charsPerToken', profile.charsPerToken)
-  }
-  return deepFreeze([...profiles.values()].map(profile => ({ ...profile })))
+interface ReplayState {
+  consumedEvents: number
+  header: EpochHeader | undefined
+  surface: TokenSurfaceNode[]
+  surfaceTokens: number
+  stepStart: { turn: number; step: number; surfaceTokens: number } | undefined
+  anchor: MeasurementAnchor | undefined
 }
 
-function assertProfileObject(model: string, value: unknown): asserts value is ModelTokenMeterConfig {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    throw new TokenMeterError(
-      `TokenMeterConfig: profile "${model}" must be an object`,
-      TOKEN_METER_INVALID_CONFIG,
-      model,
-    )
-  }
+interface PreparedSurfaceMutation {
+  readonly tokens: number
+  commit(state: ReplayState): void
 }
 
-function assertPositiveInteger(model: string, name: string, value: number): void {
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new TokenMeterError(
-      `TokenMeterConfig: ${model}.${name} (${value}) must be a positive integer`,
-      TOKEN_METER_INVALID_CONFIG,
-      model,
+/** Sum disjoint provider usage buckets without double-counting reasoning output. */
+function usageTokens(usage: TokenUsage): number {
+  return usage.inputTokens
+    + (usage.cacheReadTokens ?? 0)
+    + (usage.cacheWriteTokens ?? 0)
+    + usage.outputTokens
+}
+
+/** Compare optional envelopes so a headerless estimate can track later surface deltas. */
+function optionalHeaderEquals(
+  left: EpochHeader | undefined,
+  right: EpochHeader | undefined,
+): boolean {
+  if (left === undefined || right === undefined) return left === right
+  return headerEquals(left, right)
+}
+
+/** Resolve and validate the one service-wide context capacity. */
+function resolveContextWindow(config: TokenMeterConfig): number {
+  const contextWindow = config.contextWindow === undefined
+    ? DEFAULT_CONTEXT_WINDOW
+    : config.contextWindow
+  if (!Number.isInteger(contextWindow) || contextWindow <= 0) {
+    throw new Error(
+      `TokenMeterConfig: contextWindow (${contextWindow}) must be a positive integer`,
     )
   }
+  return contextWindow
 }
 
-function assertPositiveFinite(model: string, name: string, value: number): void {
-  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
-    throw new TokenMeterError(
-      `TokenMeterConfig: ${model}.${name} (${value}) must be a positive finite number`,
-      TOKEN_METER_INVALID_CONFIG,
-      model,
-    )
+declare module 'cordis' {
+  interface Context {
+    tokenMeter: TokenMeterService
   }
 }
 
-/** Concrete registry and replay owner for all configured model meters. */
+/** Replay owner for one service-wide estimator and isolated per-session folds. */
 export class TokenMeterService extends Service {
   static Config: z<TokenMeterConfig> = z.object({
-    models: z.dict(z.object({
-      contextWindow: z.number(),
-      charsPerToken: z.number(),
-    })),
+    contextWindow: z.number().step(1).min(1).default(DEFAULT_CONTEXT_WINDOW),
   })
 
-  private readonly meters = new Map<string, ReplayModelTokenMeter>()
+  /** Provider context-window capacity used by pressure consumers. */
+  readonly contextWindow: number
+
+  private readonly states = new WeakMap<Session, ReplayState>()
 
   constructor(ctx: Context, config: TokenMeterConfig = {}) {
     super(ctx, 'tokenMeter')
-    for (const profile of resolveProfiles(config)) {
-      this.meters.set(profile.model, new ReplayModelTokenMeter(profile))
-    }
+    this.contextWindow = resolveContextWindow(config)
 
     // Readers catch up independently, while eager observation bounds ordinary
-    // read latency. A reader in an earlier listener consumes the new event;
-    // this listener then sees the same revision and performs no duplicate fold.
+    // read latency without creating state for sessions no consumer has read.
     ctx.on('session/event', (session) => {
-      this._observe(session)
+      if (this.states.has(session)) this._sync(session)
     })
   }
 
   /**
-   * Resolve one stable model-bound replay handle.
-   * @param model - exact routed model name.
-   * @throws {@link TokenMeterError} with `TOKEN_METER_MODEL_UNCONFIGURED` when no profile exists.
-   * @returns the configured handle for this model.
+   * Measure current request pressure through the session's durable tail.
+   *
+   * Provider usage is reused only when the latest successful call's canonical
+   * request envelope matches `requestHeader`; otherwise the complete envelope
+   * and surface are heuristically repriced.
+   *
+   * @param session - session to replay through its current durable tail.
+   * @param requestHeader - optional effective request envelope replacing the latest logged header.
+   * @returns a detached deeply immutable pressure measurement.
+   */
+  measure(session: Session, requestHeader?: EpochHeader): TokenMeasurement {
+    const state = this._sync(session)
+    const header = requestHeader === undefined
+      ? state.header
+      : canonicalHeader(requestHeader)
+    const anchor = state.anchor
+
+    let baseline: TokenMeasurementBaseline
+    let surfaceDeltaTokens: number
+    if (anchor !== undefined && optionalHeaderEquals(anchor.header, header)) {
+      baseline = anchor.baseline
+      surfaceDeltaTokens = state.surfaceTokens - anchor.surfaceTokens
+    } else if (header === undefined && state.surfaceTokens === 0) {
+      baseline = { kind: 'none', tokens: 0 }
+      surfaceDeltaTokens = 0
+    } else {
+      baseline = {
+        kind: 'estimated',
+        tokens: this._estimateHeader(header) + state.surfaceTokens,
+      }
+      surfaceDeltaTokens = 0
+    }
+
+    return deepFreeze(structuredClone({
+      logRevision: state.consumedEvents,
+      baseline,
+      surfaceDeltaTokens,
+      totalTokens: Math.max(0, baseline.tokens + surfaceDeltaTokens),
+    }))
+  }
+
+  /**
+   * Price the current surface for retention and replacement decisions.
+   * @param session - session to replay through its current durable tail.
+   * @returns a detached deeply immutable positional surface measurement.
+   */
+  measureSurface(session: Session): TokenSurfaceMeasurement {
+    const state = this._sync(session)
+    return deepFreeze(structuredClone({
+      logRevision: state.consumedEvents,
+      totalTokens: state.surfaceTokens,
+      nodes: state.surface,
+    }))
+  }
+
+  /**
+   * Heuristically price one model-visible message.
+   * @param message - message to price without mutation.
+   * @returns content and role-framing tokens under the fixed service heuristic.
    */
-  resolve(model: string): ModelTokenMeter {
-    const meter = this.meters.get(model)
-    if (meter === undefined) {
-      throw new TokenMeterError(
-        `token meter has no profile for model "${model}"`,
-        TOKEN_METER_MODEL_UNCONFIGURED,
-        model,
+  estimateMessage(message: Message): number {
+    return this._estimateContent(message.content) + ROLE_OVERHEAD
+  }
+
+  /** Catch one session's fold up to the current durable tail. */
+  private _sync(session: Session): ReplayState {
+    let state = this.states.get(session)
+    if (state === undefined) {
+      state = {
+        consumedEvents: 0,
+        header: undefined,
+        surface: [],
+        surfaceTokens: 0,
+        stepStart: undefined,
+        anchor: undefined,
+      }
+      this.states.set(session, state)
+    }
+
+    while (state.consumedEvents < session.events.length) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- contiguous session seqs index the durable log
+      const event = session.events[state.consumedEvents]!
+      this._foldEvent(session, state, event)
+      state.consumedEvents += 1
+    }
+    return state
+  }
+
+  /**
+   * Validate and prepare every fallible part before mutating replay state.
+   * A malformed event remains unread on every retry instead of partially
+   * applying the same mutation more than once.
+   */
+  private _foldEvent(session: Session, state: ReplayState, event: SessionEvent): void {
+    let nextHeader = state.header
+    let nextStepStart = state.stepStart
+    let nextAnchor = state.anchor
+
+    switch (event.type) {
+      case 'request/header':
+        nextHeader = canonicalHeader(event.data.header)
+        break
+      case 'request/header-delta':
+        if (state.header === undefined) {
+          throw new Error(`token meter: request/header-delta at seq ${event.seq} has no preceding header`)
+        }
+        nextHeader = applyHeaderDelta(state.header, event.data)
+        break
+      case 'step/start':
+        if (state.stepStart !== undefined) {
+          throw new Error(
+            `token meter: step/start at seq ${event.seq} arrived before turn ${state.stepStart.turn}/step ${state.stepStart.step} ended`,
+          )
+        }
+        nextStepStart = { ...event.data, surfaceTokens: state.surfaceTokens }
+        break
+      case 'step/end':
+        if (state.stepStart === undefined
+          || state.stepStart.turn !== event.data.turn
+          || state.stepStart.step !== event.data.step) {
+          throw new Error(`token meter: step/end at seq ${event.seq} has no matching step/start boundary`)
+        }
+        nextStepStart = undefined
+        break
+      default:
+        break
+    }
+
+    const surface = isSurfaceEvent(event)
+      ? this._prepareSurfaceMutation(session, state, event)
+      : undefined
+
+    if (event.type === 'assistant/message') {
+      const stepStart = state.stepStart
+      if (stepStart === undefined
+        || stepStart.turn !== event.data.turn
+        || stepStart.step !== event.data.step) {
+        throw new Error(`token meter: assistant/message at seq ${event.seq} has no matching step/start boundary`)
+      }
+
+      // assistant/message is surface-mandatory at every append/seed boundary.
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const eventTokens = surface!.tokens
+      if (event.data.usage !== undefined && nextHeader !== undefined) {
+        const providerAssistantTokens = this._estimateProviderAssistant(
+          session,
+          event,
+          eventTokens,
+        )
+        nextAnchor = {
+          header: nextHeader,
+          surfaceTokens: stepStart.surfaceTokens + providerAssistantTokens,
+          baseline: {
+            kind: 'usage',
+            tokens: usageTokens(event.data.usage),
+            usage: event.data.usage,
+          },
+        }
+      } else {
+        const anchorSurfaceTokens = stepStart.surfaceTokens + eventTokens
+        nextAnchor = {
+          header: nextHeader,
+          surfaceTokens: anchorSurfaceTokens,
+          baseline: {
+            kind: 'estimated',
+            tokens: this._estimateHeader(nextHeader) + anchorSurfaceTokens,
+          },
+        }
+      }
+    }
+
+    state.header = nextHeader
+    state.stepStart = nextStepStart
+    if (surface !== undefined) surface.commit(state)
+    state.anchor = nextAnchor
+  }
+
+  /** Validate one surface operation and return its allocation-light commit. */
+  private _prepareSurfaceMutation(
+    session: Session,
+    state: ReplayState,
+    event: SurfaceEvent,
+  ): PreparedSurfaceMutation {
+    const tokens = this._estimateSurfaceEvent(session, event)
+    const op = event.surfaceOp
+    if (op === 'append') {
+      return {
+        tokens,
+        commit(target) {
+          target.surface.push({ seq: event.seq, tokens })
+          target.surfaceTokens += tokens
+        },
+      }
+    }
+
+    const startIdx = state.surface.findIndex(node => node.seq === op.start)
+    const endIdx = state.surface.findIndex(node => node.seq === op.end)
+    if (startIdx === -1 || endIdx === -1 || startIdx > endIdx) {
+      throw new Error(
+        `token meter: replace at seq ${event.seq} has invalid current range ${op.start}-${op.end}`,
       )
     }
-    return meter
+    const removedTokens = state.surface
+      .slice(startIdx, endIdx + 1)
+      .reduce((total, node) => total + node.tokens, 0)
+    return {
+      tokens,
+      commit(target) {
+        target.surface.splice(startIdx, endIdx - startIdx + 1, { seq: event.seq, tokens })
+        target.surfaceTokens += tokens - removedTokens
+      },
+    }
+  }
+
+  /** Price one current surface event exactly as it projects to a request. */
+  private _estimateSurfaceEvent(session: Session, event: SurfaceEvent): number {
+    const message = session.deriveEventMessage(event)
+    return message === null ? 0 : this.estimateMessage(message)
+  }
+
+  /**
+   * Reassemble provider output from exact chunk provenance for a usage anchor.
+   * Missing legacy provenance conservatively treats the durable output as the
+   * provider output; explicit empty provenance prices a known empty stream.
+   */
+  private _estimateProviderAssistant(
+    session: Session,
+    event: SessionEvent<'assistant/message'>,
+    durableEventTokens: number,
+  ): number {
+    const sourceSeqs = event.sourceEventSeqs
+    if (sourceSeqs === undefined) return durableEventTokens
+
+    const assembler = new BlockAssembler()
+    const seen = new Set<number>()
+    for (const seq of sourceSeqs) {
+      if (seq >= event.seq) {
+        throw new Error(`token meter: assistant/message at seq ${event.seq} source seq ${seq} is not earlier`)
+      }
+      if (seen.has(seq)) {
+        throw new Error(`token meter: assistant/message at seq ${event.seq} repeats source seq ${seq}`)
+      }
+      seen.add(seq)
+      // Session construction validates contiguous seqs, and the explicit
+      // earlier-than-assistant check above therefore guarantees existence.
+      const source = session.events[seq]
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const sourceEvent = source!
+      if (sourceEvent.type !== 'assistant/chunk') {
+        throw new Error(`token meter: assistant/message at seq ${event.seq} source seq ${seq} is not assistant/chunk`)
+      }
+      if (sourceEvent.data.turn !== event.data.turn || sourceEvent.data.step !== event.data.step) {
+        throw new Error(`token meter: assistant/message at seq ${event.seq} source seq ${seq} belongs to another step`)
+      }
+      assembler.push(sourceEvent.data.chunk)
+    }
+    const providerMessage = assembler.message()
+    return providerMessage.content.length === 0 ? 0 : this.estimateMessage(providerMessage)
   }
 
-  /** Advance every configured model's isolated replay fold. */
-  private _observe(session: Session): void {
-    for (const meter of this.meters.values()) meter.observeIfActive(session)
+  /** Price content blocks recursively under the fixed density heuristic. */
+  private _estimateContent(blocks: readonly ContentBlock[]): number {
+    let tokens = 0
+    for (const block of blocks) {
+      switch (block.type) {
+        case 'text':
+        case 'reasoning':
+          tokens += Math.ceil(block.text.length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD
+          break
+        case 'tool-call':
+          tokens += Math.ceil(block.name.length / CHARS_PER_TOKEN)
+            + Math.ceil(block.arguments.length / CHARS_PER_TOKEN)
+            + BLOCK_OVERHEAD
+          break
+        case 'tool-result':
+          tokens += this._estimateContent(block.content) + BLOCK_OVERHEAD
+          break
+        default:
+          // ContentBlockMap is merge-extensible; unknown blocks retain a
+          // conservative structural JSON price under the fixed heuristic.
+          tokens += BLOCK_OVERHEAD + Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN)
+      }
+    }
+    return tokens
+  }
+
+  /** Price the canonical non-surface request envelope. */
+  private _estimateHeader(header: EpochHeader | undefined): number {
+    if (header === undefined) return 0
+    let tokens = 0
+    for (const message of header.messagePrefix ?? []) tokens += this.estimateMessage(message)
+    if (header.system !== undefined) {
+      tokens += Math.ceil(header.system.length / CHARS_PER_TOKEN) + ROLE_OVERHEAD
+    }
+    if (header.tools !== undefined && header.tools.length > 0) {
+      tokens += Math.ceil(JSON.stringify(header.tools).length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD
+    }
+    return tokens
   }
 }
 

packages/llm/token-meter/src/replay.ts

@@ -1,367 +0,0 @@
-/**
- * Model-bound transactional replay of request headers, surface mutations, and
- * successful-call token anchors.
- *
- * @module @deepseek-ai/dsh-token-meter/replay
- */
-
-import { BlockAssembler, deepFreeze } from '@deepseek-ai/dsh-llm'
-import type { ContentBlock, Message, TokenUsage } from '@deepseek-ai/dsh-llm'
-import type { EpochHeader, Session, SessionEvent, SurfaceEvent } from '@deepseek-ai/dsh-session'
-import { applyHeaderDelta, canonicalHeader, headerEquals, isSurfaceEvent } from '@deepseek-ai/dsh-session'
-import type {
-  ModelTokenMeter,
-  TokenMeasurement,
-  TokenMeasurementBaseline,
-  TokenSurfaceMeasurement,
-  TokenSurfaceNode,
-} from './types.ts'
-
-/** Internal validated pricing profile. */
-export interface ModelTokenProfile {
-  readonly model: string
-  readonly contextWindow: number
-  readonly charsPerToken: number
-}
-
-/** Per-block structural overhead for JSON framing and type tags. */
-const BLOCK_OVERHEAD = 4
-
-/** Role-field framing overhead added to every priced message. */
-const ROLE_OVERHEAD = 4
-
-interface UsageAnchor {
-  readonly header: EpochHeader
-  readonly surfaceTokens: number
-  readonly baseline: Exclude<TokenMeasurementBaseline, { kind: 'none' }>
-}
-
-interface ReplayState {
-  consumedEvents: number
-  header: EpochHeader | undefined
-  surface: TokenSurfaceNode[]
-  surfaceTokens: number
-  stepStart: { turn: number; step: number; surfaceTokens: number } | undefined
-  anchor: UsageAnchor | undefined
-}
-
-interface PreparedSurfaceMutation {
-  readonly tokens: number
-  commit(state: ReplayState): void
-}
-
-/** Sum disjoint provider usage buckets without double-counting reasoning output. */
-function usageTokens(usage: TokenUsage): number {
-  return usage.inputTokens
-    + (usage.cacheReadTokens ?? 0)
-    + (usage.cacheWriteTokens ?? 0)
-    + usage.outputTokens
-}
-
-/** One configured model's replay fold, weakly isolated by session identity. */
-export class ReplayModelTokenMeter implements ModelTokenMeter {
-  readonly model: string
-  readonly contextWindow: number
-  readonly charsPerToken: number
-
-  private readonly states = new WeakMap<Session, ReplayState>()
-
-  constructor(profile: ModelTokenProfile) {
-    this.model = profile.model
-    this.contextWindow = profile.contextWindow
-    this.charsPerToken = profile.charsPerToken
-  }
-
-  /**
-   * Advance an already-read model/session fold without creating unused state.
-   * @param session - session whose durable tail advanced.
-   */
-  observeIfActive(session: Session): void {
-    if (this.states.has(session)) this._sync(session)
-  }
-
-  /** @inheritdoc */
-  estimateMessage(message: Message): number {
-    return this._estimateContent(message.content) + ROLE_OVERHEAD
-  }
-
-  /** @inheritdoc */
-  measure(session: Session, requestHeader?: EpochHeader): TokenMeasurement {
-    const state = this._sync(session)
-    const header = requestHeader === undefined
-      ? state.header
-      : canonicalHeader(requestHeader)
-    const anchor = state.anchor
-
-    let baseline: TokenMeasurementBaseline
-    let surfaceDeltaTokens: number
-    if (anchor !== undefined && header !== undefined && headerEquals(anchor.header, header)) {
-      baseline = anchor.baseline
-      surfaceDeltaTokens = state.surfaceTokens - anchor.surfaceTokens
-    } else if (header === undefined && state.surfaceTokens === 0) {
-      baseline = { kind: 'none', tokens: 0 }
-      surfaceDeltaTokens = 0
-    } else {
-      baseline = {
-        kind: 'estimated',
-        tokens: this._estimateHeader(header) + state.surfaceTokens,
-      }
-      surfaceDeltaTokens = 0
-    }
-
-    return deepFreeze(structuredClone({
-      model: this.model,
-      logRevision: state.consumedEvents,
-      baseline,
-      surfaceDeltaTokens,
-      totalTokens: Math.max(0, baseline.tokens + surfaceDeltaTokens),
-    }))
-  }
-
-  /** @inheritdoc */
-  measureSurface(session: Session): TokenSurfaceMeasurement {
-    const state = this._sync(session)
-    return deepFreeze(structuredClone({
-      model: this.model,
-      logRevision: state.consumedEvents,
-      totalTokens: state.surfaceTokens,
-      nodes: state.surface,
-    }))
-  }
-
-  /** Catch one session's fold up to the current durable tail. */
-  private _sync(session: Session): ReplayState {
-    let state = this.states.get(session)
-    if (state === undefined) {
-      state = {
-        consumedEvents: 0,
-        header: undefined,
-        surface: [],
-        surfaceTokens: 0,
-        stepStart: undefined,
-        anchor: undefined,
-      }
-      this.states.set(session, state)
-    }
-
-    while (state.consumedEvents < session.events.length) {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- contiguous session seqs index the durable log
-      const event = session.events[state.consumedEvents]!
-      this._foldEvent(session, state, event)
-      state.consumedEvents += 1
-    }
-    return state
-  }
-
-  /**
-   * Validate and prepare every fallible part before mutating replay state.
-   * A malformed event therefore remains the next unread event on every retry
-   * instead of applying a partial surface mutation twice.
-   */
-  private _foldEvent(session: Session, state: ReplayState, event: SessionEvent): void {
-    let nextHeader = state.header
-    let nextStepStart = state.stepStart
-    let nextAnchor = state.anchor
-
-    switch (event.type) {
-      case 'request/header':
-        nextHeader = canonicalHeader(event.data.header)
-        break
-      case 'request/header-delta':
-        if (state.header === undefined) {
-          throw new Error(`token meter: request/header-delta at seq ${event.seq} has no preceding header`)
-        }
-        nextHeader = applyHeaderDelta(state.header, event.data)
-        break
-      case 'step/start':
-        if (state.stepStart !== undefined) {
-          throw new Error(
-            `token meter: step/start at seq ${event.seq} arrived before turn ${state.stepStart.turn}/step ${state.stepStart.step} ended`,
-          )
-        }
-        nextStepStart = { ...event.data, surfaceTokens: state.surfaceTokens }
-        break
-      case 'step/end':
-        if (state.stepStart === undefined
-          || state.stepStart.turn !== event.data.turn
-          || state.stepStart.step !== event.data.step) {
-          throw new Error(`token meter: step/end at seq ${event.seq} has no matching step/start boundary`)
-        }
-        nextStepStart = undefined
-        break
-      default:
-        break
-    }
-
-    const surface = isSurfaceEvent(event)
-      ? this._prepareSurfaceMutation(session, state, event)
-      : undefined
-
-    if (event.type === 'assistant/message' && nextHeader?.config.model === this.model) {
-      const stepStart = state.stepStart
-      if (stepStart === undefined
-        || stepStart.turn !== event.data.turn
-        || stepStart.step !== event.data.step) {
-        throw new Error(`token meter: assistant/message at seq ${event.seq} has no matching step/start boundary`)
-      }
-
-      // assistant/message is surface-mandatory at every append/seed boundary.
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const eventTokens = surface!.tokens
-      if (event.data.usage !== undefined) {
-        const providerAssistantTokens = this._estimateProviderAssistant(
-          session,
-          event,
-          eventTokens,
-        )
-        nextAnchor = {
-          header: nextHeader,
-          surfaceTokens: stepStart.surfaceTokens + providerAssistantTokens,
-          baseline: {
-            kind: 'usage',
-            tokens: usageTokens(event.data.usage),
-            usage: event.data.usage,
-          },
-        }
-      } else {
-        const anchorSurfaceTokens = stepStart.surfaceTokens + eventTokens
-        nextAnchor = {
-          header: nextHeader,
-          surfaceTokens: anchorSurfaceTokens,
-          baseline: {
-            kind: 'estimated',
-            tokens: this._estimateHeader(nextHeader) + anchorSurfaceTokens,
-          },
-        }
-      }
-    }
-
-    state.header = nextHeader
-    state.stepStart = nextStepStart
-    if (surface !== undefined) surface.commit(state)
-    state.anchor = nextAnchor
-  }
-
-  /** Validate one surface operation and return its allocation-light commit. */
-  private _prepareSurfaceMutation(
-    session: Session,
-    state: ReplayState,
-    event: SurfaceEvent,
-  ): PreparedSurfaceMutation {
-    const tokens = this._estimateSurfaceEvent(session, event)
-    const op = event.surfaceOp
-    if (op === 'append') {
-      return {
-        tokens,
-        commit(target) {
-          target.surface.push({ seq: event.seq, tokens })
-          target.surfaceTokens += tokens
-        },
-      }
-    }
-
-    const startIdx = state.surface.findIndex(node => node.seq === op.start)
-    const endIdx = state.surface.findIndex(node => node.seq === op.end)
-    if (startIdx === -1 || endIdx === -1 || startIdx > endIdx) {
-      throw new Error(
-        `token meter: replace at seq ${event.seq} has invalid current range ${op.start}-${op.end}`,
-      )
-    }
-    const removedTokens = state.surface
-      .slice(startIdx, endIdx + 1)
-      .reduce((total, node) => total + node.tokens, 0)
-    return {
-      tokens,
-      commit(target) {
-        target.surface.splice(startIdx, endIdx - startIdx + 1, { seq: event.seq, tokens })
-        target.surfaceTokens += tokens - removedTokens
-      },
-    }
-  }
-
-  /** Price one current surface event exactly as it projects to a request. */
-  private _estimateSurfaceEvent(session: Session, event: SurfaceEvent): number {
-    const message = session.deriveEventMessage(event)
-    return message === null ? 0 : this.estimateMessage(message)
-  }
-
-  /**
-   * Reassemble provider output from exact chunk provenance for a usage anchor.
-   * Missing legacy provenance conservatively treats the durable output as the
-   * provider output; explicit empty provenance prices a known empty stream.
-   */
-  private _estimateProviderAssistant(
-    session: Session,
-    event: SessionEvent<'assistant/message'>,
-    durableEventTokens: number,
-  ): number {
-    const sourceSeqs = event.sourceEventSeqs
-    if (sourceSeqs === undefined) return durableEventTokens
-
-    const assembler = new BlockAssembler()
-    const seen = new Set<number>()
-    for (const seq of sourceSeqs) {
-      if (seq >= event.seq) {
-        throw new Error(`token meter: assistant/message at seq ${event.seq} source seq ${seq} is not earlier`)
-      }
-      if (seen.has(seq)) {
-        throw new Error(`token meter: assistant/message at seq ${event.seq} repeats source seq ${seq}`)
-      }
-      seen.add(seq)
-      // Session construction validates contiguous seqs, and the explicit
-      // earlier-than-assistant check above therefore guarantees existence.
-      const source = session.events[seq]
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const sourceEvent = source!
-      if (sourceEvent.type !== 'assistant/chunk') {
-        throw new Error(`token meter: assistant/message at seq ${event.seq} source seq ${seq} is not assistant/chunk`)
-      }
-      if (sourceEvent.data.turn !== event.data.turn || sourceEvent.data.step !== event.data.step) {
-        throw new Error(`token meter: assistant/message at seq ${event.seq} source seq ${seq} belongs to another step`)
-      }
-      assembler.push(sourceEvent.data.chunk)
-    }
-    const providerMessage = assembler.message()
-    return providerMessage.content.length === 0 ? 0 : this.estimateMessage(providerMessage)
-  }
-
-  /** Price content blocks recursively under this model's density profile. */
-  private _estimateContent(blocks: readonly ContentBlock[]): number {
-    let tokens = 0
-    for (const block of blocks) {
-      switch (block.type) {
-        case 'text':
-        case 'reasoning':
-          tokens += Math.ceil(block.text.length / this.charsPerToken) + BLOCK_OVERHEAD
-          break
-        case 'tool-call':
-          tokens += Math.ceil(block.name.length / this.charsPerToken)
-            + Math.ceil(block.arguments.length / this.charsPerToken)
-            + BLOCK_OVERHEAD
-          break
-        case 'tool-result':
-          tokens += this._estimateContent(block.content) + BLOCK_OVERHEAD
-          break
-        default:
-          // ContentBlockMap is merge-extensible; unknown blocks retain a
-          // conservative structural JSON price under the selected profile.
-          tokens += BLOCK_OVERHEAD + Math.ceil(JSON.stringify(block).length / this.charsPerToken)
-      }
-    }
-    return tokens
-  }
-
-  /** Price the canonical non-surface request envelope. */
-  private _estimateHeader(header: EpochHeader | undefined): number {
-    if (header === undefined) return 0
-    let tokens = 0
-    for (const message of header.messagePrefix ?? []) tokens += this.estimateMessage(message)
-    if (header.system !== undefined) {
-      tokens += Math.ceil(header.system.length / this.charsPerToken) + ROLE_OVERHEAD
-    }
-    if (header.tools !== undefined && header.tools.length > 0) {
-      tokens += Math.ceil(JSON.stringify(header.tools).length / this.charsPerToken) + BLOCK_OVERHEAD
-    }
-    return tokens
-  }
-}

packages/llm/token-meter/src/types.ts

@@ -4,21 +4,12 @@
  * @module @deepseek-ai/dsh-token-meter/types
  */
 
-import type { Message, TokenUsage } from '@deepseek-ai/dsh-llm'
-import type { EpochHeader, Session } from '@deepseek-ai/dsh-session'
-
-/** Optional pricing fields for one configured model. */
-export interface ModelTokenMeterConfig {
-  /** Provider context-window capacity in tokens. Required for a custom model. */
-  contextWindow?: number
-  /** Heuristic text density in characters per token. Defaults to `4`. */
-  charsPerToken?: number
-}
+import type { TokenUsage } from '@deepseek-ai/dsh-llm'
 
 /** Token-meter plugin configuration. */
 export interface TokenMeterConfig {
-  /** Built-in field overrides and custom model profiles, keyed by routed model name. */
-  models?: Record<string, ModelTokenMeterConfig>
+  /** Service-wide context-window capacity in tokens. Defaults to `128000`. */
+  contextWindow?: number
 }
 
 /** The baseline from which a signed surface delta produces current pressure. */
@@ -29,8 +20,6 @@ export type TokenMeasurementBaseline =
 
 /** Detached immutable scalar pressure at one consumed session-log revision. */
 export interface TokenMeasurement {
-  /** Model profile used for every heuristic component. */
-  readonly model: string
   /** Number of durable events consumed; equal to the next unread event seq. */
   readonly logRevision: number
   /** Provider or heuristic anchor used for this measurement. */
@@ -51,8 +40,6 @@ export interface TokenSurfaceNode {
 
 /** Detached immutable priced surface at one consumed session-log revision. */
 export interface TokenSurfaceMeasurement {
-  /** Model profile used to price every node. */
-  readonly model: string
   /** Number of durable events consumed; equal to the next unread event seq. */
   readonly logRevision: number
   /** Total heuristic tokens across the current surface. */
@@ -60,42 +47,3 @@ export interface TokenSurfaceMeasurement {
   /** Current surface nodes in positional head-to-tail order. */
   readonly nodes: readonly TokenSurfaceNode[]
 }
-
-/** A model-bound replay meter returned by {@link TokenMeterService.resolve}. */
-export interface ModelTokenMeter {
-  /** Routed model name bound to this handle. */
-  readonly model: string
-  /** Provider context-window capacity in tokens. */
-  readonly contextWindow: number
-  /** Heuristic text density in characters per token. */
-  readonly charsPerToken: number
-
-  /**
-   * Measure current request pressure through the session's durable tail.
-   *
-   * Provider usage is reused only when its routed model and canonical request
-   * envelope match `requestHeader`; otherwise the complete envelope and
-   * surface are heuristically repriced for this handle's model.
-   *
-   * @param session - session to replay through its current durable tail.
-   * @param requestHeader - optional effective request envelope replacing the latest logged header.
-   * @returns a detached deeply immutable pressure measurement.
-   */
-  measure(session: Session, requestHeader?: EpochHeader): TokenMeasurement
-
-  /**
-   * Price the current surface for retention and replacement decisions.
-   *
-   * @param session - session to replay through its current durable tail.
-   * @returns a detached deeply immutable positional surface measurement.
-   */
-  measureSurface(session: Session): TokenSurfaceMeasurement
-
-  /**
-   * Heuristically price one model-visible message.
-   *
-   * @param message - message to price without mutation.
-   * @returns content and role-framing tokens under this model profile.
-   */
-  estimateMessage(message: Message): number
-}

packages/llm/token-meter/tests/token-meter.spec.ts

@@ -4,12 +4,8 @@ import { CallId } from '@deepseek-ai/dsh-llm'
 import type { ContentBlock, Message, TokenUsage } from '@deepseek-ai/dsh-llm'
 import SessionStore, { Session, SessionId, canonicalHeader } from '@deepseek-ai/dsh-session'
 import type { EpochHeader } from '@deepseek-ai/dsh-session'
-import TokenMeterService, {
-  TOKEN_METER_INVALID_CONFIG,
-  TOKEN_METER_MODEL_UNCONFIGURED,
-  TokenMeterError,
-} from '@deepseek-ai/dsh-token-meter'
-import type { ModelTokenMeter, TokenMeterConfig } from '@deepseek-ai/dsh-token-meter'
+import TokenMeterService from '@deepseek-ai/dsh-token-meter'
+import type { TokenMeterConfig } from '@deepseek-ai/dsh-token-meter'
 
 function header(model: string, extras: Omit<EpochHeader, 'config'> = {}): EpochHeader {
   return canonicalHeader({ config: { model }, ...extras })
@@ -76,69 +72,23 @@ function meter(config: TokenMeterConfig = {}): TokenMeterService {
 }
 
 describe('TokenMeterService configuration and registration', () => {
-  it('provides immutable zero-config DeepSeek profiles', () => {
+  it('provides one zero-config context window', () => {
     const service = meter()
-    expect(service.resolve('deepseek-v4-flash')).toMatchObject({
-      model: 'deepseek-v4-flash',
-      contextWindow: 128_000,
-      charsPerToken: 4,
-    })
-    expect(service.resolve('deepseek-v4-pro')).toMatchObject({
-      model: 'deepseek-v4-pro',
-      contextWindow: 128_000,
-      charsPerToken: 4,
-    })
-  })
-
-  it('merges built-in overrides field-wise and defaults custom density', () => {
-    const service = meter({
-      models: {
-        'deepseek-v4-flash': { charsPerToken: 2 },
-        custom: { contextWindow: 32_000 },
-      },
-    })
-    expect(service.resolve('deepseek-v4-flash')).toMatchObject({ contextWindow: 128_000, charsPerToken: 2 })
-    expect(service.resolve('deepseek-v4-pro')).toMatchObject({ contextWindow: 128_000, charsPerToken: 4 })
-    expect(service.resolve('custom')).toMatchObject({ contextWindow: 32_000, charsPerToken: 4 })
+    expect(service.contextWindow).toBe(128_000)
   })
 
-  it('throws a typed exact-code error for unknown models', () => {
-    const service = meter()
-    let thrown: unknown
-    try {
-      service.resolve('unconfigured-model')
-    } catch (error: unknown) {
-      thrown = error
-    }
-    expect(thrown).toBeInstanceOf(TokenMeterError)
-    expect(thrown).toMatchObject({
-      code: TOKEN_METER_MODEL_UNCONFIGURED,
-      model: 'unconfigured-model',
-    })
-    expect((thrown as Error).message).toContain('unconfigured-model')
+  it('accepts one service-wide context-window override', () => {
+    expect(meter({ contextWindow: 32_000 }).contextWindow).toBe(32_000)
   })
 
   it.each([
-    [{ models: null }, /models must be an object/],
-    [{ models: [] }, /models must be an object/],
-    [{ models: { custom: {} } }, /requires contextWindow/],
-    [{ models: { '': { contextWindow: 1 } } }, /must not be empty/],
-    [{ models: { custom: { contextWindow: 0 } } }, /positive integer/],
-    [{ models: { custom: { contextWindow: 1.5 } } }, /positive integer/],
-    [{ models: { custom: { contextWindow: 1, charsPerToken: 0 } } }, /positive finite/],
-    [{ models: { custom: { contextWindow: 1, charsPerToken: Number.NaN } } }, /positive finite/],
-    [{ models: { custom: null } }, /must be an object/],
-    [{ models: { custom: [] } }, /must be an object/],
-  ] as unknown as Array<[TokenMeterConfig, RegExp]>)('rejects invalid profile config %#', (config, pattern) => {
-    let thrown: unknown
-    try {
-      meter(config)
-    } catch (error: unknown) {
-      thrown = error
-    }
-    expect(thrown).toBeInstanceOf(TokenMeterError)
-    expect(thrown).toMatchObject({ code: TOKEN_METER_INVALID_CONFIG })
-    expect((thrown as Error).message).toMatch(pattern)
+    { contextWindow: 0 },
+    { contextWindow: -1 },
+    { contextWindow: 1.5 },
+    { contextWindow: Number.NaN },
+    { contextWindow: null },
+  ] as unknown as TokenMeterConfig[])('rejects invalid context capacity %#', (config) => {
+    expect(() => meter(config)).toThrow(/contextWindow .* positive integer/)
   })
 
   it('registers and unregisters ctx.tokenMeter with its plugin fiber', async () => {
@@ -151,9 +101,9 @@ describe('TokenMeterService configuration and registration', () => {
   })
 })
 
-describe('ModelTokenMeter pricing', () => {
-  it('prices every built-in content shape and merge-extended blocks', () => {
-    const handle = meter({ models: { custom: { contextWindow: 100, charsPerToken: 2 } } }).resolve('custom')
+describe('TokenMeterService pricing', () => {
+  it('prices every built-in content shape and merge-extended blocks with one fixed heuristic', () => {
+    const service = meter({ contextWindow: 100 })
     const blocks: ContentBlock[] = [
       { type: 'text', text: 'abcd' },
       { type: 'reasoning', text: 'ab' },
@@ -166,17 +116,16 @@ describe('ModelTokenMeter pricing', () => {
       },
       { type: 'future-block', payload: 'abcd' } as unknown as ContentBlock,
     ]
-    const estimated = handle.estimateMessage({ role: 'assistant', content: blocks })
+    const estimated = service.estimateMessage({ role: 'assistant', content: blocks })
     expect(estimated).toBeGreaterThan(30)
-    expect(handle.estimateMessage(textMessage('abcd'))).toBe(10)
+    expect(service.estimateMessage(textMessage('abcd'))).toBe(9)
   })
 
   it('returns a detached deeply immutable empty measurement', () => {
-    const handle = meter().resolve('deepseek-v4-flash')
+    const service = meter()
     const session = new Session(SessionId('empty'))
-    const result = handle.measure(session)
+    const result = service.measure(session)
     expect(result).toEqual({
-      model: 'deepseek-v4-flash',
       logRevision: 0,
       baseline: { kind: 'none', tokens: 0 },
       surfaceDeltaTokens: 0,
@@ -190,14 +139,14 @@ describe('ModelTokenMeter pricing', () => {
   })
 
   it('keeps earlier scalar and surface snapshots detached from later replay', () => {
-    const handle = meter().resolve('deepseek-v4-flash')
+    const service = meter()
     const session = new Session(SessionId('detached'))
     session.append('user/message', {
       content: [{ type: 'text', text: 'first' }],
       source: { kind: 'user' },
     }, { surfaceOp: 'append' })
-    const scalar = handle.measure(session)
-    const surface = handle.measureSurface(session)
+    const scalar = service.measure(session)
+    const surface = service.measureSurface(session)
     const scalarCopy = structuredClone(scalar)
     const surfaceCopy = structuredClone(surface)
 
@@ -205,8 +154,8 @@ describe('ModelTokenMeter pricing', () => {
       content: [{ type: 'text', text: 'second' }],
       source: { kind: 'user' },
     }, { surfaceOp: 'append' })
-    expect(handle.measure(session).logRevision).toBe(2)
-    expect(handle.measureSurface(session).nodes).toHaveLength(2)
+    expect(service.measure(session).logRevision).toBe(2)
+    expect(service.measureSurface(session).nodes).toHaveLength(2)
     expect(scalar).toEqual(scalarCopy)
     expect(surface).toEqual(surfaceCopy)
     expect(scalar.logRevision).toBe(1)
@@ -214,7 +163,7 @@ describe('ModelTokenMeter pricing', () => {
   })
 
   it('prices header, prefix, tools, and surface when no reusable usage exists', () => {
-    const handle = meter().resolve('deepseek-v4-flash')
+    const service = meter()
     const session = new Session(SessionId('heuristic'))
     session.append('user/message', {
       content: [{ type: 'text', text: 'question' }],
@@ -225,9 +174,9 @@ describe('ModelTokenMeter pricing', () => {
       messagePrefix: [textMessage('prefix')],
       tools: [{ name: 'read', description: 'read', parameters: { type: 'object' } }],
     }))
-    const result = handle.measure(session)
+    const result = service.measure(session)
     expect(result.baseline.kind).toBe('estimated')
-    expect(result.totalTokens).toBeGreaterThan(handle.measureSurface(session).totalTokens)
+    expect(result.totalTokens).toBeGreaterThan(service.measureSurface(session).totalTokens)
     expect(result.logRevision).toBe(session.events.length)
   })
 })
@@ -242,7 +191,7 @@ describe('replay anchors and surface folds', () => {
   }
 
   it('uses disjoint provider usage and signed durable-output rewrites', () => {
-    const handle = meter().resolve('deepseek-v4-flash')
+    const service = meter()
     const session = new Session(SessionId('usage'))
     session.append('user/message', {
       content: [{ type: 'text', text: 'before' }],
@@ -253,7 +202,7 @@ describe('replay anchors and surface folds', () => {
       durableText: 'a much longer rewritten durable assistant answer',
       usage: USAGE,
     })
-    const result = handle.measure(session)
+    const result = service.measure(session)
     expect(result.baseline).toMatchObject({ kind: 'usage', tokens: 34, usage: USAGE })
     expect(result.surfaceDeltaTokens).toBeGreaterThan(0)
     expect(result.totalTokens).toBe(34 + result.surfaceDeltaTokens)
@@ -263,20 +212,20 @@ describe('replay anchors and surface folds', () => {
   })
 
   it('uses an estimated anchor when provider usage is absent', () => {
-    const handle = meter().resolve('deepseek-v4-flash')
+    const service = meter()
     const session = new Session(SessionId('missing-usage'))
     appendSuccessfulCall(session, header('deepseek-v4-flash', { system: 's' }), {
       providerText: 'provider',
       durableText: 'rewritten',
     })
-    const anchored = handle.measure(session)
+    const anchored = service.measure(session)
     expect(anchored.baseline.kind).toBe('estimated')
     expect(anchored.surfaceDeltaTokens).toBe(0)
     session.append('user/message', {
       content: [{ type: 'text', text: 'later' }],
       source: { kind: 'user' },
     }, { surfaceOp: 'append' })
-    const advanced = handle.measure(session)
+    const advanced = service.measure(session)
     expect(advanced.surfaceDeltaTokens).toBeGreaterThan(0)
   })
 
@@ -295,24 +244,17 @@ describe('replay anchors and surface folds', () => {
       usage: USAGE,
       provenance: 'absent',
     })
-    const handle = meter().resolve('deepseek-v4-flash')
-    expect(handle.measure(explicit).surfaceDeltaTokens).toBeGreaterThan(0)
-    expect(handle.measure(legacy).surfaceDeltaTokens).toBe(0)
+    const service = meter()
+    expect(service.measure(explicit).surfaceDeltaTokens).toBeGreaterThan(0)
+    expect(service.measure(legacy).surfaceDeltaTokens).toBe(0)
   })
 
-  it('preserves one model anchor across another model success and reuses it after switching back', () => {
-    const service = meter({
-      models: {
-        alpha: { contextWindow: 1000 },
-        beta: { contextWindow: 1000, charsPerToken: 2 },
-      },
-    })
-    const alpha = service.resolve('alpha')
-    const beta = service.resolve('beta')
+  it('keeps only the latest successful request anchor across model switches', () => {
+    const service = meter({ contextWindow: 1_000 })
     const session = new Session(SessionId('switch'))
     const alphaHeader = header('alpha', { system: 'same envelope' })
     appendSuccessfulCall(session, alphaHeader, { usage: USAGE, providerText: 'alpha' })
-    expect(alpha.measure(session).baseline.kind).toBe('usage')
+    expect(service.measure(session).baseline).toMatchObject({ kind: 'usage', tokens: 34 })
 
     appendSuccessfulCall(session, header('beta'), {
       turn: 1,
@@ -320,34 +262,33 @@ describe('replay anchors and surface folds', () => {
       usage: { inputTokens: 100, outputTokens: 50 },
       providerText: 'beta response',
     })
-    expect(alpha.measure(session).baseline.kind).toBe('estimated')
-    expect(beta.measure(session).baseline).toMatchObject({ kind: 'usage', tokens: 150 })
+    expect(service.measure(session).baseline).toMatchObject({ kind: 'usage', tokens: 150 })
 
     appendHeader(session, alphaHeader)
-    const switchedBack = alpha.measure(session)
-    expect(switchedBack.baseline).toMatchObject({ kind: 'usage', tokens: 34 })
-    expect(switchedBack.surfaceDeltaTokens).toBeGreaterThan(0)
+    const switchedBack = service.measure(session)
+    expect(switchedBack.baseline.kind).toBe('estimated')
+    expect(switchedBack.surfaceDeltaTokens).toBe(0)
   })
 
   it('invalidates usage for any canonical envelope change or explicit override', () => {
-    const handle = meter().resolve('deepseek-v4-flash')
+    const service = meter()
     const session = new Session(SessionId('envelope'))
     const anchoredHeader = header('deepseek-v4-flash', { system: 'one' })
     appendSuccessfulCall(session, anchoredHeader, { usage: USAGE })
-    expect(handle.measure(session, { ...anchoredHeader, tools: [] }).baseline.kind).toBe('usage')
-    expect(handle.measure(session, header('deepseek-v4-flash', { system: 'two' })).baseline.kind)
+    expect(service.measure(session, { ...anchoredHeader, tools: [] }).baseline.kind).toBe('usage')
+    expect(service.measure(session, header('deepseek-v4-flash', { system: 'two' })).baseline.kind)
       .toBe('estimated')
-    expect(handle.measure(session, header('deepseek-v4-pro', { system: 'one' })).baseline.kind)
+    expect(service.measure(session, header('deepseek-v4-pro', { system: 'one' })).baseline.kind)
       .toBe('estimated')
-    expect(handle.measure(session, {
+    expect(service.measure(session, {
       ...anchoredHeader,
       config: { ...anchoredHeader.config, temperature: 0.2 },
     }).baseline.kind).toBe('estimated')
-    expect(handle.measure(session, {
+    expect(service.measure(session, {
       ...anchoredHeader,
       messagePrefix: [textMessage('prefix')],
     }).baseline.kind).toBe('estimated')
-    expect(handle.measure(session, {
+    expect(service.measure(session, {
       ...anchoredHeader,
       tools: [{ name: 'read', description: 'read', parameters: { type: 'object' } }],
     }).baseline.kind).toBe('estimated')
@@ -357,7 +298,7 @@ describe('replay anchors and surface folds', () => {
     const session = new Session(SessionId('header-delta'))
     appendHeader(session, header('deepseek-v4-flash'))
     session.append('request/header-delta', { config: { model: 'deepseek-v4-pro' } })
-    const result = meter().resolve('deepseek-v4-flash').measure(session)
+    const result = meter().measure(session)
     expect(result.baseline.kind).toBe('estimated')
     expect(result.logRevision).toBe(2)
   })
@@ -374,9 +315,8 @@ describe('replay anchors and surface folds', () => {
       source: { kind: 'user' },
     }, { surfaceOp: 'append' })
     const seeded = new Session(SessionId('surface-seeded'), original.events)
-    const handle = service.resolve('deepseek-v4-flash')
-    const before = handle.measureSurface(seeded)
-    const beforeScalar = handle.measure(seeded)
+    const before = service.measureSurface(seeded)
+    const beforeScalar = service.measure(seeded)
     expect(before.nodes).toHaveLength(2)
     expect(beforeScalar.surfaceDeltaTokens).toBeGreaterThan(0)
 
@@ -385,8 +325,8 @@ describe('replay anchors and surface folds', () => {
       content: [{ type: 'text', text: 'replacement' }],
       source: { kind: 'plugin', plugin: 'test' },
     }, { surfaceOp: { op: 'replace', start: first, end: first }, sourceEventSeqs: [first] })
-    const after = handle.measureSurface(seeded)
-    const afterScalar = handle.measure(seeded)
+    const after = service.measureSurface(seeded)
+    const afterScalar = service.measure(seeded)
     expect(after.nodes).toHaveLength(2)
     expect(after.nodes[0]!.seq).toBe(seeded.events.length - 1)
     expect(after.logRevision).toBe(seeded.events.length)
@@ -405,7 +345,7 @@ describe('replay anchors and surface folds', () => {
       durableText: '',
       provenance: 'empty',
     })
-    const surface = meter().resolve('deepseek-v4-flash').measureSurface(session)
+    const surface = meter().measureSurface(session)
     const assistant = session.events.find(event => event.type === 'assistant/message')!
     expect(surface.nodes).toEqual([{ seq: assistant.seq, tokens: 0 }])
     expect(surface.totalTokens).toBe(0)
@@ -413,18 +353,18 @@ describe('replay anchors and surface folds', () => {
 })
 
 describe('malformed replay and listener lifecycle', () => {
-  function expectRepeatedFailure(handle: ModelTokenMeter, session: Session, pattern: RegExp): void {
-    expect(() => handle.measure(session)).toThrow(pattern)
-    expect(() => handle.measure(session)).toThrow(pattern)
+  function expectRepeatedFailure(service: TokenMeterService, session: Session, pattern: RegExp): void {
+    expect(() => service.measure(session)).toThrow(pattern)
+    expect(() => service.measure(session)).toThrow(pattern)
   }
 
   it('rejects a header delta before any snapshot transactionally', () => {
     const session = new Session(SessionId('bad-delta'))
     session.append('request/header-delta', { config: { model: 'deepseek-v4-flash' } })
-    expectRepeatedFailure(meter().resolve('deepseek-v4-flash'), session, /no preceding header/)
+    expectRepeatedFailure(meter(), session, /no preceding header/)
   })
 
-  it('rejects a matching-model assistant without its step boundary transactionally', () => {
+  it('rejects an assistant without its step boundary transactionally', () => {
     const session = new Session(SessionId('bad-step'))
     appendHeader(session, header('deepseek-v4-flash'))
     session.append('assistant/message', {
@@ -432,7 +372,7 @@ describe('malformed replay and listener lifecycle', () => {
       step: 1,
       content: [{ type: 'text', text: 'bad' }],
     }, { surfaceOp: 'append', sourceEventSeqs: [] })
-    expectRepeatedFailure(meter().resolve('deepseek-v4-flash'), session, /no matching step\/start/)
+    expectRepeatedFailure(meter(), session, /no matching step\/start/)
   })
 
   it('clears completed step boundaries and rejects overlapping or late step events', () => {
@@ -440,7 +380,7 @@ describe('malformed replay and listener lifecycle', () => {
     overlapping.append('step/start', { turn: 1, step: 1 })
     overlapping.append('step/start', { turn: 1, step: 2 })
     expectRepeatedFailure(
-      meter().resolve('deepseek-v4-flash'),
+      meter(),
       overlapping,
       /arrived before turn 1\/step 1 ended/,
     )
@@ -455,7 +395,7 @@ describe('malformed replay and listener lifecycle', () => {
       content: [],
     }, { surfaceOp: 'append', sourceEventSeqs: [] })
     expectRepeatedFailure(
-      meter().resolve('deepseek-v4-flash'),
+      meter(),
       late,
       /no matching step\/start/,
     )
@@ -464,7 +404,7 @@ describe('malformed replay and listener lifecycle', () => {
     mismatchedEnd.append('step/start', { turn: 1, step: 1 })
     mismatchedEnd.append('step/end', { turn: 1, step: 2 })
     expectRepeatedFailure(
-      meter().resolve('deepseek-v4-flash'),
+      meter(),
       mismatchedEnd,
       /step\/end .* no matching step\/start/,
     )
@@ -509,7 +449,7 @@ describe('malformed replay and listener lifecycle', () => {
         content: [{ type: 'text', text: 'bad' }],
         usage: { inputTokens: 1, outputTokens: 1 },
       }, { surfaceOp: 'append', sourceEventSeqs })
-      expect(() => meter().resolve('deepseek-v4-flash').measure(session)).toThrow(testCase.pattern)
+      expect(() => meter().measure(session)).toThrow(testCase.pattern)
     }
   })
 
@@ -528,7 +468,7 @@ describe('malformed replay and listener lifecycle', () => {
       content: [],
       usage: { inputTokens: 1, outputTokens: 0 },
     }, { surfaceOp: 'append', sourceEventSeqs: [source, source] })
-    expect(() => meter().resolve('deepseek-v4-flash').measure(duplicate)).toThrow(/repeats source seq/)
+    expect(() => meter().measure(duplicate)).toThrow(/repeats source seq/)
 
     const future = new Session(SessionId('future-source'))
     future.append('step/start', { turn: 1, step: 1 })
@@ -539,7 +479,7 @@ describe('malformed replay and listener lifecycle', () => {
       content: [],
       usage: { inputTokens: 1, outputTokens: 0 },
     }, { surfaceOp: 'append', sourceEventSeqs: [99] })
-    expect(() => meter().resolve('deepseek-v4-flash').measure(future)).toThrow(/is not earlier/)
+    expect(() => meter().measure(future)).toThrow(/is not earlier/)
   })
 
   it('does not partially apply a malformed assistant replacement', () => {
@@ -556,7 +496,7 @@ describe('malformed replay and listener lifecycle', () => {
       content: [{ type: 'text', text: 'replacement' }],
     }, { surfaceOp: { op: 'replace', start: head, end: head }, sourceEventSeqs: [head] })
     expectRepeatedFailure(
-      meter().resolve('deepseek-v4-flash'),
+      meter(),
       session,
       /no matching step\/start/,
     )
@@ -572,32 +512,32 @@ describe('malformed replay and listener lifecycle', () => {
       content: [{ type: 'text', text: 'bad' }],
       source: { kind: 'user' },
     }, { surfaceOp: { op: 'replace', start: 99, end: 99 }, sourceEventSeqs: [0] })
-    expectRepeatedFailure(meter().resolve('deepseek-v4-flash'), session, /invalid current range/)
+    expectRepeatedFailure(meter(), session, /invalid current range/)
   })
 
   it('handles earlier-reader catch-up, eager observation, and service reload', async () => {
     const ctx = new Context()
     await ctx.plugin(SessionStore)
-    let handle: ModelTokenMeter | undefined
+    let activeMeter: TokenMeterService | undefined
     const revisions: number[] = []
     ctx.on('session/event', (session) => {
-      if (handle !== undefined) revisions.push(handle.measure(session).logRevision)
+      if (activeMeter !== undefined) revisions.push(activeMeter.measure(session).logRevision)
     })
     const firstFiber = await ctx.plugin(TokenMeterService)
-    handle = ctx.tokenMeter.resolve('deepseek-v4-flash')
+    activeMeter = ctx.tokenMeter
     const session = ctx.sessions.create(SessionId('listener-order'))
-    handle.measure(session)
+    activeMeter.measure(session)
     session.append('user/message', {
       content: [{ type: 'text', text: 'one' }],
       source: { kind: 'user' },
     }, { surfaceOp: 'append' })
     expect(revisions).toEqual([1])
-    expect(handle.measure(session).logRevision).toBe(1)
+    expect(activeMeter.measure(session).logRevision).toBe(1)
 
     await firstFiber.dispose()
     const secondFiber = await ctx.plugin(TokenMeterService)
-    handle = ctx.tokenMeter.resolve('deepseek-v4-flash')
-    expect(handle.measure(session).logRevision).toBe(1)
+    activeMeter = ctx.tokenMeter
+    expect(activeMeter.measure(session).logRevision).toBe(1)
     await secondFiber.dispose()
   })
 })

scripts/gen-doc-graphs.ts

@@ -92,7 +92,7 @@ const SERVICE_ROLES: ServiceRole[] = [
     title: 'Replay token measurement',
     mode: 'core',
     consumers: ['compact-basic'],
-    note: 'Owns isolated per-model/session replay folds; pressure consumers share immutable revisioned measurements.',
+    note: 'Owns isolated per-session replay folds; pressure consumers share immutable revisioned measurements.',
   },
   {
     key: 'sessions',