fix: resolve ratio base from active session model, not agent config

cheapestinference · claude · cheapestinference · commit a96f4450f816 · 2026-04-14T13:51:05.000+02:00
Audited every site that consumes the new `*Share` fields and confirmed the
context-window base is always the SESSION-active model:

- `pi-embedded-runner/run/attempt.ts` reads `params.model.contextWindow`,
  where `params.model` is `effectiveModel` from `resolveEffectiveRuntimeModel`
  using the per-run `provider`/`modelId` (which already honors session model
  overrides via `resolveHookModelSelection` and persisted session overrides).
- `pi-embedded-runner/compact.ts` reads `model?.contextWindow` from the model
  resolved by `resolveModelAsync(provider, modelId, …)` where provider/modelId
  flow from `params.provider`/`params.model` (session-scoped) through
  `resolveEmbeddedCompactionTarget`, with the documented `compaction.model`
  override taking precedence only when explicitly configured.
- `auto-reply/reply/memory-flush.ts` resolves the window via
  `resolveMemoryFlushContextWindowTokens` from `followupRun.run.model` —
  the per-run model captured at queue time, which is session-scoped.

No code path computes the share against a statically baked agent-default
model, so no fix to the resolution logic is required. Documentation,
however, was implicit. This commit:

- Extends JSDoc on each `*Share` field in `types.agent-defaults.ts` to
  state explicitly that the base is the context window of the model
  active for the CURRENT SESSION, falling back to the agent's default
  model, then to DEFAULT_CONTEXT_TOKENS.
- Adds a regression test in `reply-state.test.ts` proving that two
  sessions of the same agent (one inheriting the agent default
  glm-4.7@200k, one overriding to kimi-k2@1M) compute different
  `reserveTokensFloor` and `softThresholdTokens` from the same share
  config — locking in the session-scoped semantics so a future refactor
  cannot silently regress to agent-scoped resolution.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/auto-reply/reply/reply-state.test.ts b/src/auto-reply/reply/reply-state.test.ts
@@ -516,6 +516,73 @@ describe("applyMemoryFlushSharesToPlan", () => {
     expect(small.reserveTokensFloor).toBe(800);
     expect(small.softThresholdTokens).toBe(160);
   });
+
+  // Regression: a single agent runs sessions with different models. The share
+  // must be evaluated against the SESSION-active model's context window, not
+  // a value statically derived from the agent's default model. Two sessions
+  // of the same agent with different active models must yield different
+  // resolved budgets.
+  it("share resolves against the SESSION-active model, not the agent default model", () => {
+    // Same agent config: both share fields set, no absolute overrides.
+    const cfg = {
+      models: {
+        providers: {
+          glm: { models: [{ id: "glm-4.7", contextWindow: 200_000 }] },
+          moonshot: { models: [{ id: "kimi-k2", contextWindow: 1_000_000 }] },
+        },
+      },
+      agents: {
+        defaults: {
+          // Agent-level default model (would be used as a fallback when the
+          // session does not override).
+          model: { primary: "glm/glm-4.7" },
+          compaction: {
+            reserveTokensFloorShare: 0.1,
+            memoryFlush: { softThresholdTokensShare: 0.02 },
+          },
+        },
+      },
+    } as never;
+
+    // Session S1 inherits the agent default (glm-4.7, 200k window).
+    const sessionS1Window = resolveMemoryFlushContextWindowTokens({
+      cfg,
+      provider: "glm",
+      modelId: "glm-4.7",
+    });
+    expect(sessionS1Window).toBe(200_000);
+
+    const planS1 = applyMemoryFlushSharesToPlan({
+      plan: basePlan,
+      cfg,
+      contextWindowTokens: sessionS1Window,
+    });
+    expect(planS1.reserveTokensFloor).toBe(20_000); // 200k × 0.1
+    expect(planS1.softThresholdTokens).toBe(4_000); // 200k × 0.02
+
+    // Session S2 of the SAME agent overrides to kimi-k2 (1M window). The
+    // share must scale to the active session model, NOT stay locked at the
+    // agent default's 200k.
+    const sessionS2Window = resolveMemoryFlushContextWindowTokens({
+      cfg,
+      provider: "moonshot",
+      modelId: "kimi-k2",
+    });
+    expect(sessionS2Window).toBe(1_000_000);
+
+    const planS2 = applyMemoryFlushSharesToPlan({
+      plan: basePlan,
+      cfg,
+      contextWindowTokens: sessionS2Window,
+    });
+    expect(planS2.reserveTokensFloor).toBe(100_000); // 1M × 0.1
+    expect(planS2.softThresholdTokens).toBe(20_000); // 1M × 0.02
+
+    // Sanity: budgets really did differ between the two sessions even though
+    // the agent config is identical — proving the ratio is session-scoped.
+    expect(planS2.reserveTokensFloor).not.toBe(planS1.reserveTokensFloor);
+    expect(planS2.softThresholdTokens).not.toBe(planS1.softThresholdTokens);
+  });
 });
 
 describe("incrementCompactionCount", () => {
diff --git a/src/config/types.agent-defaults.ts b/src/config/types.agent-defaults.ts
@@ -388,6 +388,12 @@ export type AgentCompactionConfig = {
    * Fraction of the model's contextWindowTokens used as the reserve-tokens target
    * (0.01-0.9). Wins over `reserveTokens` when both are set, which lets a single
    * config scale correctly across heterogeneous context windows (e.g. 200k vs 1M).
+   *
+   * The base window is the context window of the model active for the CURRENT
+   * SESSION (resolved per-run from session model overrides), falling back to the
+   * agent's configured default model, then to DEFAULT_CONTEXT_TOKENS. This means
+   * a single agent can host sessions on differently-sized models and the share
+   * scales per session, not per agent config.
    */
   reserveTokensShare?: number;
   /** Pi keepRecentTokens budget used for cut-point selection. */
@@ -396,6 +402,10 @@ export type AgentCompactionConfig = {
    * Fraction of the model's contextWindowTokens used as the keepRecentTokens budget
    * (0.01-0.9). Wins over `keepRecentTokens` when both are set so recent-turn
    * preservation scales with the window instead of being fixed in absolute tokens.
+   *
+   * The base window is the context window of the model active for the CURRENT
+   * SESSION (per-run), falling back to the agent's default model, then to
+   * DEFAULT_CONTEXT_TOKENS.
    */
   keepRecentTokensShare?: number;
   /** Minimum reserve tokens enforced for Pi compaction (0 disables the floor). */
@@ -404,6 +414,10 @@ export type AgentCompactionConfig = {
    * Fraction of the model's contextWindowTokens used as the reserve-tokens floor
    * (0.01-0.9). Wins over `reserveTokensFloor` when both are set; the resolved
    * floor is still applied as an absolute minimum on the final reserve tokens.
+   *
+   * The base window is the context window of the model active for the CURRENT
+   * SESSION (per-run), falling back to the agent's default model, then to
+   * DEFAULT_CONTEXT_TOKENS.
    */
   reserveTokensFloorShare?: number;
   /** Max share of context window for history during safeguard pruning (0.1–0.9, default 0.5). */
@@ -462,6 +476,10 @@ export type AgentCompactionMemoryFlushConfig = {
    * Fraction of the model's contextWindowTokens used as the memory-flush soft threshold
    * (0.01-0.9). Wins over `softThresholdTokens` when both are set, so the trigger point
    * scales with the actual context window rather than being fixed in absolute tokens.
+   *
+   * The base window is the context window of the model active for the CURRENT
+   * SESSION (resolved per-run from session model overrides), falling back to the
+   * agent's default model, then to DEFAULT_CONTEXT_TOKENS.
    */
   softThresholdTokensShare?: number;
   /**
