@pure01fx/dsh-openai-codex-auth 0.13.3 → 0.13.4

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+## 0.13.4
+
+- Extends the replacement meter to supply the UI context-pressure projection. Estimated occupancy includes native encrypted replay while measured input remains unchanged; per-session request routes, model-window matching, and compatible sample selection isolate conversations and model switches. Projection checkpoints recompute policy-dependent views on restore, and ownership changes rebuild the single pressure registration.
+
 ## 0.13.3
 
 - Supplies a replacement token-meter service through the package composition patch, so Codex encrypted reasoning participates in retained-history pricing and pressure reductions after compaction without changing Harness source. Reuses ordinary host pricing, preserves fixed heuristic projections, and corrects usage anchors without double-counting reasoning output. Preserves an explicitly reported zero reasoning count so it does not trigger the missing-detail fallback.

package/README.md

@@ -253,6 +253,32 @@ $DSH_HOME/openai-codex-auth.json
 
 `path` 的优先级高于 `dshHome`。
 
+### 关闭或恢复计量服务替代
+
+计量服务的选择由组合节点控制，目前不是 `openai-codex-auth` 的 `config` 开关。要保留 Codex Provider、OAuth 和 UI 功能，同时恢复 DSH 默认计量器，将以下覆盖项放到 profile 最后应用的补丁中（在本包补丁之后）：
+
+```yaml
+- id: token-meter
+  disabled: false
+
+- id: codex-token-meter
+  disabled: true
+```
+
+两项必须同时设置，确保只有一个 `ctx.tokenMeter`；关闭替代后，本包的隐藏推理保留预算修正及 UI 预计占用修正都会停用。`nativeAdapter: false` 只切换 Provider 行为，不会恢复 base 的计量节点。自定义 profile 如果使用不同节点 ID，应替换上面的 ID。
+
+保存覆盖配置后重新启动该 profile，使服务选择在启动时生效，避免在线切换过程中出现两个计量服务同时挂载。
+
+要重新启用本包计量器，反向覆盖这两项并重新启动 profile：
+
+```yaml
+- id: token-meter
+  disabled: true
+
+- id: codex-token-meter
+  disabled: false
+```
+
 ### 原生 Codex transport 与组合边界
 
 本包跟踪的上游 Codex repository、commit、release 与 Catalog client version 只在 `src/upstream.ts` 维护；升级上游时先更新该文件，再刷新 fixtures、生成产物和兼容测试，避免多个散落 hash 漂移。
@@ -261,9 +287,11 @@ $DSH_HOME/openai-codex-auth.json
 
 本包提供 Codex Provider 和计量服务替代入口，不发布具体 Profile。整合包必须在挂载本插件前释放已有的 `openai-codex` route，例如从自己的 `llm-pi-ai` provider map 中移除该项；本包不会清空未知的 sibling providers。只想复用 OAuth/UI 并继续使用外部 Provider 的组合可以显式设置 `nativeAdapter: false`。从 pi-ai 切到 Native 时，旧 foreign replay 会降级为可见持久历史；反向切回 pi-ai 后，已产生 Native replay 的进行中 session 不保证可续跑，应新建 session。
 
-`cordis.patch.yml` 会禁用 base bundle 的 `token-meter` 节点，并挂载本包 `/token-meter` 入口作为唯一的 `ctx.tokenMeter`；无需修改 DSH 源码。自定义组合应禁用自己的默认计量服务，再挂载同一入口，不能同时运行两个计量服务。服务复用宿主的文本、图片、文件和投影实现，只对源 route 与目标 route 属于同一个活跃 Native Codex adapter 的历史补充加密推理价格；`nativeAdapter: false` 和其他模型沿用宿主价格。
+`cordis.patch.yml` 会禁用 base bundle 的 `token-meter` 节点，并挂载本包 `/token-meter` 入口作为唯一的 `ctx.tokenMeter`；无需修改 DSH 源码。自定义组合应禁用自己的默认计量服务，再挂载同一入口，不能同时运行两个计量服务。服务复用宿主的文本、图片、文件计价及用量、组成投影，只对源 route 与目标 route 属于同一个活跃 Native Codex adapter 的历史补充加密推理价格；`nativeAdapter: false` 和其他模型沿用宿主价格。
+
+加密推理计量优先使用原始响应的 `usage.reasoningTokens`，每次响应计一次；缺少推理细分时以 `outputTokens` 作为生成推理的保守上界，连用量也没有时才用解码密文的字节数作体积估算。这些都是重放占用估计，不是精确的服务端输入计费。计量会同时修正节点 `tokens`、`surfaceTokens`、完整锚点与有符号的 `surfaceDeltaTokens`，服务端已计入的推理不会再加一次，压缩移除历史时会扣减隐藏占用；`heuristicTokens`、持久消息和服务端用量保持原语义。UI 的 `contextPressure` 由本包注册一个纯投影，复用同一隐藏推理定价函数；`pressureTokens` 仍是最近服务端实测输入，`projectedTokens` 是预计下一次请求占用，适用的加密推理会计入增长和压缩扣减。每个对话根据已提交的 `request/header` 独立选择路由，稳定的其他模型对话沿用原投影规则；模型或请求信封改变后重新估算，并在匹配的 `request/context` 到达前不显示旧模型窗口。
 
-加密推理计量优先使用原始响应的 `usage.reasoningTokens`，每次响应计一次；缺少推理细分时以 `outputTokens` 作为生成推理的保守上界，连用量也没有时才用解码密文的字节数作体积估算。这些都是重放占用估计，不是精确的服务端输入计费。计量会同时修正节点 `tokens`、`surfaceTokens`、完整锚点与有符号的 `surfaceDeltaTokens`，服务端已计入的推理不会再加一次，压缩移除历史时会扣减隐藏占用；`heuristicTokens`、持久消息和服务端用量保持原语义。宿主 UI 的固定启发式投影仍由原实现提供，不包含本包的隐藏推理估计。
+UI 投影的缓存保存与当前路由策略无关的每来源价格和采样总量，读取旧格式缓存会完整回放；同格式缓存读取时重新计算展示值，因此重启、分支恢复及 Native 路由归属变化不会沿用旧展示缓存。无法确认兼容性的跨 route 用量样本会使用完整估算，实测输入字段不变。路由归属变化会重建投影；宿主注册接口不主动推送空闲对话，现有订阅在下一次会话事件或快照读取时看到新值。尚未提交为请求信封的模型选择不属于该日志投影的输入。
 
 上游 Native Codex Responses 请求没有输出 token 上限字段，因此普通会话若显式设置 `maxTokens` 仍会在 Provider I/O 前失败。DSH 的压缩与会话标题辅助调用会固定携带 `maxTokens`，并分别通过 `purpose: compaction` 与 `purpose: session-title` 标识；本适配器允许这两类 hint 通过，但不会把它序列化为 `max_output_tokens`，实际输出长度仍由 Native Codex 决定。
 

package/lib/native-adapter.d.ts

@@ -6,6 +6,21 @@ import type { NativeCodexModel, NativeCodexModelCatalog } from './catalog.js';
 export declare const CODEX_PROVIDER = "openai-codex";
 /** Compatibility route retained for sessions created during the native preview. */
 export declare const NATIVE_CODEX_PROVIDER = "openai-codex-native";
+declare module '@deepseek-ai/cordis' {
+    interface Events {
+        /**
+         * Native replay ownership changed.
+         * @mode emit
+         */
+        'codex/replay-owners-updated'(): void;
+    }
+}
+/**
+ * Snapshot immutable provider groups for a pure projection's replay policy.
+ * @param runtime - current LLM service, or undefined before it is available.
+ * @returns sorted groups; each group is owned by one native adapter instance.
+ */
+export declare function nativeCodexReplayGroups(runtime: LlmRuntime | undefined): readonly (readonly string[])[];
 /**
  * Register native routes and their replay-pricing ownership in the same Cordis scope.
  * @param ctx - scope owning the native adapter registration.

package/lib/native-adapter.js

@@ -7,6 +7,23 @@ export const CODEX_PROVIDER = 'openai-codex';
 export const NATIVE_CODEX_PROVIDER = 'openai-codex-native';
 const OWNED_CODEX_PROVIDERS = new Set([CODEX_PROVIDER, NATIVE_CODEX_PROVIDER]);
 const replayOwners = new WeakMap();
+/**
+ * Snapshot immutable provider groups for a pure projection's replay policy.
+ * @param runtime - current LLM service, or undefined before it is available.
+ * @returns sorted groups; each group is owned by one native adapter instance.
+ */
+export function nativeCodexReplayGroups(runtime) {
+    if (runtime === undefined)
+        return Object.freeze([]);
+    const groups = new Map();
+    for (const [provider, adapter] of replayOwners.get(runtimeKey(runtime)) ?? []) {
+        const group = groups.get(adapter) ?? [];
+        group.push(provider);
+        groups.set(adapter, group);
+    }
+    return Object.freeze([...groups.values()].map(group => Object.freeze(group.sort()))
+        .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b))));
+}
 // Cordis returns scope-traced views; use the original service for ownership identity.
 function runtimeKey(runtime) {
     return Reflect.get(runtime, symbols.original) ?? runtime;
@@ -28,11 +45,13 @@ export function registerNativeCodexAdapter(ctx, providers, adapter) {
             replayOwners.set(runtimeKey(runtime), owners = new Map());
         for (const provider of providers)
             owners.set(provider, adapter);
+        ctx.emit('codex/replay-owners-updated');
         return () => {
             for (const provider of providers) {
                 if (owners.get(provider) === adapter)
                     owners.delete(provider);
             }
+            ctx.emit('codex/replay-owners-updated');
         };
     });
 }

package/lib/pressure-projection.d.ts

@@ -0,0 +1,69 @@
+import { type Context } from '@deepseek-ai/cordis';
+import { z } from 'zod';
+import { SessionSeq } from '@deepseek-ai/dsh-session';
+import type { ProjectionDefinition, SessionProjectionMap, SessionProjectionStateMap } from '@deepseek-ai/dsh-session-projection';
+type BaseState = SessionProjectionStateMap['contextPressure'];
+type View = SessionProjectionMap['contextPressure'];
+type PressureDefinition = ProjectionDefinition<'contextPressure'> & {
+    wire: NonNullable<ProjectionDefinition<'contextPressure'>['wire']>;
+};
+declare const extraSchema: z.ZodObject<{
+    header: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        fingerprint: z.ZodString;
+        tools: z.ZodNumber;
+    }, z.core.$strict>>;
+    sample: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        fingerprint: z.ZodString;
+        tools: z.ZodNumber;
+    }, z.core.$strict>>;
+    sampleNative: z.ZodNullable<z.ZodBoolean>;
+    nativeHistory: z.ZodBoolean;
+    context: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        seq: z.ZodPipe<z.ZodNumber, z.ZodTransform<SessionSeq, number>>;
+        position: z.ZodPipe<z.ZodNumber, z.ZodTransform<SessionSeq, number>>;
+        provider: z.ZodString;
+        tokens: z.ZodNumber;
+    }, z.core.$strict>>;
+    positions: z.ZodArray<z.ZodObject<{
+        seq: z.ZodPipe<z.ZodNumber, z.ZodTransform<SessionSeq, number>>;
+        position: z.ZodPipe<z.ZodNumber, z.ZodTransform<SessionSeq, number>>;
+    }, z.core.$strict>>;
+    sampledHidden: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strict>;
+type Extra = z.infer<typeof extraSchema> & {
+    view: View;
+};
+type State = BaseState & {
+    codex: Extra;
+};
+/**
+ * Withhold only the host pressure registration in an isolated service view.
+ * All other registrations use the original caller-traced registry and disposer.
+ * @param ctx - scope owning the replacement meter.
+ * @returns scoped constructor context and the captured host pressure definition.
+ */
+export declare function capturePressureRegistration(ctx: Context): {
+    context: Context;
+    readonly definition: PressureDefinition;
+    register<S extends BaseState>(definition: ProjectionDefinition<'contextPressure', S>): () => void;
+};
+/**
+ * Add hidden replay to the existing UI pressure fields using only logged data.
+ * Native groups are immutable policy; source prices and sample totals stay
+ * policy-independent so checkpoints can be safely restored after ownership changes.
+ * @param base - host pressure fold, schema, and wire view.
+ * @param groups - provider routes grouped by their active native adapter.
+ * @returns one pure pressure unit with a policy-independent checkpoint format.
+ */
+export declare function codexPressureProjection(base: PressureDefinition, groups: readonly (readonly string[])[]): ProjectionDefinition<'contextPressure', State> & {
+    wire: NonNullable<ProjectionDefinition<'contextPressure', State>['wire']>;
+};
+export {};

package/lib/pressure-projection.js

@@ -0,0 +1,216 @@
+/** Pure, route-aware UI pressure pricing and scoped host registration forwarding. */
+import { createHash } from 'node:crypto';
+import { symbols } from '@deepseek-ai/cordis';
+import { z } from 'zod';
+import { lastAssistantStreamChunk } from '@deepseek-ai/dsh-llm';
+import { canonicalHeader, deriveEventMessage, isSurfaceEvent, SessionSeq, } from '@deepseek-ai/dsh-session';
+import { estimateToolsTokens } from '@deepseek-ai/dsh-token-meter/estimate';
+import { CODEX_PROVIDER, NATIVE_CODEX_PROVIDER } from './native-adapter.js';
+import { estimateNativeCodexReplayTokens, hasNativeCodexReplayKind } from './replay.js';
+const sequence = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).transform(SessionSeq);
+const count = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const routeSchema = z.object({ provider: z.string(), model: z.string(), fingerprint: z.string(), tools: count }).strict();
+const extraSchema = z.object({
+    header: routeSchema.nullable(),
+    sample: routeSchema.nullable(),
+    sampleNative: z.boolean().nullable(),
+    nativeHistory: z.boolean(),
+    context: z.object({ provider: z.string(), model: z.string() }).strict().nullable(),
+    nodes: z.array(z.object({ seq: sequence, position: sequence, provider: z.string(), tokens: count }).strict()),
+    positions: z.array(z.object({ seq: sequence, position: sequence }).strict()),
+    sampledHidden: z.record(z.string(), count),
+}).strict();
+function route(header) {
+    const normalized = canonicalHeader(header);
+    return {
+        provider: normalized.config.provider,
+        model: normalized.config.model,
+        fingerprint: createHash('sha256').update(JSON.stringify({
+            config: {
+                provider: normalized.config.provider, model: normalized.config.model,
+                reasoningEffort: normalized.config.reasoningEffort, temperature: normalized.config.temperature,
+                maxTokens: normalized.config.maxTokens, stop: normalized.config.stop,
+            },
+            adapterDefaults: {
+                reasoningEffort: normalized.adapterDefaults?.reasoningEffort,
+                maxTokens: normalized.adapterDefaults?.maxTokens,
+            },
+            tools: normalized.tools ?? [],
+        })).digest('hex'),
+        tools: estimateToolsTokens(normalized),
+    };
+}
+function sums(nodes) {
+    const totals = {};
+    for (const node of nodes)
+        totals[node.provider] = (totals[node.provider] ?? 0) + node.tokens;
+    return totals;
+}
+function sameView(a, b) {
+    return a.pressureTokens === b.pressureTokens && a.projectedTokens === b.projectedTokens
+        && a.contextWindow === b.contextWindow;
+}
+/**
+ * Withhold only the host pressure registration in an isolated service view.
+ * All other registrations use the original caller-traced registry and disposer.
+ * @param ctx - scope owning the replacement meter.
+ * @returns scoped constructor context and the captured host pressure definition.
+ */
+export function capturePressureRegistration(ctx) {
+    const registry = ctx.sessionProjections;
+    const originalRegister = registry.register;
+    let captured;
+    const register = (definition) => {
+        if (definition.key === 'contextPressure') {
+            if (definition.wire === undefined)
+                throw new Error('host pressure projection has no wire view');
+            captured = { ...definition, wire: definition.wire };
+            return () => { };
+        }
+        return Reflect.apply(originalRegister, registry, [definition]);
+    };
+    const forwarded = new Proxy(registry, {
+        get(target, key, receiver) {
+            // Suppress another Cordis trace wrapper, which would bypass the register trap.
+            if (key === symbols.tracker)
+                return undefined;
+            if (key === 'register')
+                return register;
+            return Reflect.get(target, key, receiver);
+        },
+    });
+    const context = ctx.isolate('sessionProjections');
+    context.provide('sessionProjections', forwarded);
+    return { context, register(definition) {
+            return Reflect.apply(originalRegister, registry, [definition]);
+        }, get definition() {
+            if (captured === undefined)
+                throw new Error('host token meter did not register contextPressure');
+            return captured;
+        } };
+}
+/**
+ * Add hidden replay to the existing UI pressure fields using only logged data.
+ * Native groups are immutable policy; source prices and sample totals stay
+ * policy-independent so checkpoints can be safely restored after ownership changes.
+ * @param base - host pressure fold, schema, and wire view.
+ * @param groups - provider routes grouped by their active native adapter.
+ * @returns one pure pressure unit with a policy-independent checkpoint format.
+ */
+export function codexPressureProjection(base, groups) {
+    const owners = new Map(groups.flatMap((group, index) => group.map(provider => [provider, index])));
+    const hidden = (totals, target) => {
+        const owner = owners.get(target);
+        if (owner === undefined)
+            return 0;
+        return Object.entries(totals).reduce((n, [provider, tokens]) => n + (owners.get(provider) === owner ? tokens : 0), 0);
+    };
+    const view = (state, extra) => {
+        const original = base.wire.view(state);
+        const header = extra.header;
+        if (header === null)
+            return original;
+        const native = owners.has(header.provider);
+        const sampleProvider = extra.sample?.provider;
+        const changedEnvelope = extra.sample !== null && extra.sample.fingerprint !== header.fingerprint;
+        if (!native && !extra.nativeHistory && extra.sampleNative !== true
+            && !owners.has(sampleProvider ?? '') && !changedEnvelope)
+            return original;
+        const current = hidden(sums(extra.nodes), header.provider);
+        const sampled = hidden(extra.sampledHidden, header.provider);
+        const sampledSources = Object.entries(extra.sampledHidden).filter(([, tokens]) => tokens > 0);
+        const policyCompatible = native
+            ? sampledSources.every(([source]) => source === extra.sample?.provider
+                && owners.get(source) === owners.get(header.provider))
+            : extra.sampleNative === false || sampledSources.length === 0 && extra.sampleNative !== true;
+        const compatible = extra.sample?.fingerprint === header.fingerprint
+            && (extra.sampleNative === null || extra.sampleNative === native) && policyCompatible
+            && state.pressureTokens !== undefined
+            && state.sampledSurfaceTokens !== undefined
+            && state.pressureTokens >= state.sampledSurfaceTokens + header.tools + sampled;
+        const projectedTokens = compatible
+            ? Math.max(0, state.pressureTokens + state.surfaceTokens - state.sampledSurfaceTokens + current - sampled)
+            : state.surfaceTokens + header.tools + current;
+        const { contextWindow: _oldWindow, ...reported } = original;
+        return {
+            ...reported, projectedTokens,
+            ...extra.context?.provider === header.provider && extra.context.model === header.model
+                && original.contextWindow !== undefined ? { contextWindow: original.contextWindow } : {},
+        };
+    };
+    const stateSchema = z.record(z.string(), z.unknown()).transform((value, ctx) => {
+        const { codex, ...legacy } = value;
+        const parsedBase = base.stateSchema.safeParse(legacy);
+        const parsedExtra = extraSchema.safeParse(typeof codex === 'object' && codex !== null
+            ? Object.fromEntries(Object.entries(codex).filter(([key]) => key !== 'view')) : codex);
+        if (!parsedBase.success || !parsedExtra.success) {
+            ctx.addIssue({ code: 'custom', message: 'invalid Codex pressure checkpoint' });
+            return z.NEVER;
+        }
+        return { ...parsedBase.data, codex: { ...parsedExtra.data, view: view(parsedBase.data, parsedExtra.data) } };
+    });
+    return {
+        key: 'contextPressure', stateVersion: 6, stateSchema,
+        init: (header, inherited) => {
+            const initial = base.init(header, inherited);
+            const extra = {
+                header: null, sample: null, sampleNative: null, nativeHistory: false, context: null,
+                nodes: [], positions: [], sampledHidden: {},
+            };
+            return { ...initial, codex: { ...extra, view: view(initial, extra) } };
+        },
+        apply: (state, event) => {
+            const next = base.apply(state, event);
+            let extra = state.codex;
+            if (event.type === 'request/header') {
+                const nextRoute = route(event.data.header);
+                if (nextRoute.fingerprint !== extra.header?.fingerprint)
+                    extra = { ...extra, header: nextRoute };
+            }
+            if (event.type === 'request/context')
+                extra = { ...extra, context: { provider: event.data.provider, model: event.data.model } };
+            if (event.type === 'assistant/message' || event.type === 'assistant/attempt') {
+                const usage = event.type === 'assistant/message' && event.data.usage !== undefined
+                    ? event.data.usage : lastAssistantStreamChunk(event.data.stream, 'usage')?.usage;
+                if (usage !== undefined) {
+                    const finish = lastAssistantStreamChunk(event.data.stream, 'finish');
+                    const replay = finish?.replayState ?? (event.type === 'assistant/message'
+                        && event.data.message.source.kind === 'model' ? event.data.message.source.replayState : undefined);
+                    const native = replay === undefined || replay === null ? null : hasNativeCodexReplayKind(replay);
+                    extra = { ...extra, sample: extra.header, sampledHidden: sums(extra.nodes), sampleNative: native,
+                        nativeHistory: extra.nativeHistory || native === true };
+                }
+            }
+            if (isSurfaceEvent(event)) {
+                const message = deriveEventMessage(event);
+                const source = message?.role === 'assistant' && message.source.kind === 'model' ? message.source : undefined;
+                const originalNative = source !== undefined && hasNativeCodexReplayKind(source.replayState)
+                    && (source.provider === CODEX_PROVIDER || source.provider === NATIVE_CODEX_PROVIDER);
+                const price = originalNative ? estimateNativeCodexReplayTokens(source, event.type === 'assistant/message' ? event.data.usage : undefined) : 0;
+                let nodes = extra.nodes;
+                let positions = extra.positions;
+                let position = event.seq;
+                if (event.surfaceOp !== 'append') {
+                    const { startSeq, endSeq } = event.surfaceOp;
+                    const first = positions.find(node => node.seq === startSeq)?.position ?? startSeq;
+                    const last = positions.find(node => node.seq === endSeq)?.position ?? endSeq;
+                    if (last < first)
+                        throw new Error('Codex pressure: invalid positional replacement');
+                    position = first;
+                    nodes = nodes.filter(node => node.position < first || node.position > last);
+                    positions = [...positions.filter(node => node.position < first || node.position > last), { seq: event.seq, position }];
+                }
+                if (price > 0 && source !== undefined)
+                    nodes = [...nodes, { seq: event.seq, position, provider: source.provider, tokens: price }];
+                if (nodes !== extra.nodes || positions !== extra.positions || originalNative && !extra.nativeHistory) {
+                    extra = { ...extra, nodes, positions, nativeHistory: extra.nativeHistory || originalNative };
+                }
+            }
+            if (next === state && extra === state.codex)
+                return state;
+            const output = view(next, extra);
+            return { ...next, codex: { ...extra, view: sameView(output, state.codex.view) ? state.codex.view : output } };
+        },
+        wire: { viewSchema: base.wire.viewSchema, view: state => state.codex.view },
+    };
+}

package/lib/token-meter.d.ts

@@ -1,15 +1,19 @@
 /** Codex hidden-replay pricing layered over the host's ordinary token meter. */
 import { TokenMeter } from '@deepseek-ai/dsh-token-meter';
-import type { TokenMeasurement } from '@deepseek-ai/dsh-token-meter';
+import type { TokenMeasurement, TokenMeterConfig } from '@deepseek-ai/dsh-token-meter';
+import type { Context } from '@deepseek-ai/cordis';
 import type { EpochHeader, Session } from '@deepseek-ai/dsh-session';
 /**
  * Replacement tokenMeter service that charges native Codex encrypted reasoning.
- * Ordinary prices and projections come from the host meter. Hidden prices apply
+ * Ordinary prices, usage, and breakdown projections come from the host meter.
+ * The UI pressure unit adds the same hidden pricing per logged request route. Hidden prices apply
  * only between routes currently owned by the same native adapter; fixed
  * heuristicTokens stay unchanged. Provider usage is not charged a second time.
  */
 export declare class CodexTokenMeter extends TokenMeter {
+    static inject: string[];
     private readonly hiddenFolds;
+    constructor(ctx: Context, config?: TokenMeterConfig);
     /**
      * Return a detached measurement including opaque native replay in node prices,
      * surface totals, and signed anchor deltas. Recheck usage conservatism against

package/lib/token-meter.js

@@ -1,9 +1,10 @@
 /** Codex hidden-replay pricing layered over the host's ordinary token meter. */
 import { TokenMeter } from '@deepseek-ai/dsh-token-meter';
+import { capturePressureRegistration, codexPressureProjection } from './pressure-projection.js';
 import { estimateToolsTokens } from '@deepseek-ai/dsh-token-meter/estimate';
 import { assembleAssistantStream } from '@deepseek-ai/dsh-llm';
 import { canonicalHeader, deriveEventMessage, headerEquals, isSurfaceEvent, SessionSeq, } from '@deepseek-ai/dsh-session';
-import { canReplayNativeCodex } from './native-adapter.js';
+import { canReplayNativeCodex, nativeCodexReplayGroups } from './native-adapter.js';
 import { estimateNativeCodexReplayTokens } from './replay.js';
 function replayPrice(message, usage) {
     if (message?.role !== 'assistant' || message.source.kind !== 'model')
@@ -15,12 +16,32 @@ function sameHeader(a, b) {
 }
 /**
  * Replacement tokenMeter service that charges native Codex encrypted reasoning.
- * Ordinary prices and projections come from the host meter. Hidden prices apply
+ * Ordinary prices, usage, and breakdown projections come from the host meter.
+ * The UI pressure unit adds the same hidden pricing per logged request route. Hidden prices apply
  * only between routes currently owned by the same native adapter; fixed
  * heuristicTokens stay unchanged. Provider usage is not charged a second time.
  */
 export class CodexTokenMeter extends TokenMeter {
+    static inject = ['sessionProjections', 'llm'];
     hiddenFolds = new WeakMap();
+    constructor(ctx, config) {
+        const capture = capturePressureRegistration(ctx);
+        super(capture.context, config);
+        let unregister;
+        let policy;
+        const refresh = () => {
+            const groups = nativeCodexReplayGroups(ctx.get('llm'));
+            const fingerprint = JSON.stringify(groups);
+            if (fingerprint === policy)
+                return;
+            unregister?.();
+            unregister = capture.register(codexPressureProjection(capture.definition, groups));
+            policy = fingerprint;
+        };
+        refresh();
+        ctx.on('codex/replay-owners-updated', refresh);
+        ctx.effect(() => () => { unregister?.(); });
+    }
     /**
      * Return a detached measurement including opaque native replay in node prices,
      * surface totals, and signed anchor deltas. Recheck usage conservatism against

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pure01fx/dsh-openai-codex-auth",
-  "version": "0.13.3",
+  "version": "0.13.4",
   "description": "Native ChatGPT Codex provider, device-code-first login, and same-origin Web integration for DeepSeek Harness",
   "license": "MIT",
   "publishConfig": {
@@ -61,6 +61,8 @@
     "lib/replay.d.ts",
     "lib/token-meter.js",
     "lib/token-meter.d.ts",
+    "lib/pressure-projection.js",
+    "lib/pressure-projection.d.ts",
     "lib/retry-after.js",
     "lib/retry-after.d.ts",
     "lib/rate-limits.js",
@@ -123,6 +125,7 @@
   },
   "peerDependencies": {
     "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session-projection": "0.2.0-rc.2",
     "@deepseek-ai/cordis": "~4.0.4",
     "@deepseek-ai/dsh-attachment": "0.2.0-rc.2",
     "@deepseek-ai/dsh-credentials": "0.2.0-rc.2",
@@ -142,7 +145,8 @@
     "https-proxy-agent": "7.0.6",
     "image-size": "^2.0.2",
     "proxy-from-env": "1.1.0",
-    "ws": "8.21.3"
+    "ws": "8.21.3",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "~4.0.4",