diff --git a/packages/core/test/session-compaction.test.ts b/packages/core/test/session-compaction.test.ts
index eeffeb4..80bb7e4 100644
--- a/packages/core/test/session-compaction.test.ts
+++ b/packages/core/test/session-compaction.test.ts
@@ -344,6 +344,65 @@ it.effect("clamps an oversized compaction buffer and waits for an exchange to su
   }),
 )
 
+it.effect("auto compaction stays model-aware when switching between differently sized providers", () =>
+  Effect.gen(function* () {
+    const compaction = yield* SessionCompaction.Service
+    const session = yield* insertSession(Session.ID.make("ses_synthetic_provider_switch"))
+    // A user may configure this for a large model, then change providers mid-thread.
+    yield* compaction.transform((editor) => editor.configure({ buffer: 600_000 }))
+
+    const models = {
+      large: LanguageModel.make({ id: "synthetic-large", provider: "synthetic-large", route: OpenAIChat.route }),
+      small: LanguageModel.make({ id: "synthetic-small", provider: "synthetic-small", route: OpenAIChat.route }),
+    }
+    const assistant = (provider: "large" | "small", inputTokens: number) =>
+      Schema.decodeUnknownSync(SessionMessage.Assistant)({
+        id: SessionMessage.ID.create(),
+        type: "assistant",
+        agent: Agent.defaultID,
+        model: { id: models[provider].id, providerID: models[provider].provider },
+        content: [{ type: "text", text: "Synthetic response" }],
+        tokens: { input: inputTokens, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        time: { created: 0, completed: 0 },
+      })
+    const user = (text: string) =>
+      SessionMessage.User.make({
+        id: SessionMessage.ID.create(),
+        type: "user",
+        text,
+        time: { created: DateTime.makeUnsafe(0) },
+      })
+    const status = (provider: "large" | "small", messages: readonly SessionMessage.Info[]) =>
+      compaction
+        .compact({
+          reason: "auto",
+          context: {
+            ...loaded(session, messages),
+            model: SessionRunnerModel.resolved(models[provider], {
+              capabilities: { tools: true, input: ["text"], output: ["text"] },
+              cost: [],
+              limit: { context: provider === "large" ? 1_000_000 : 200_000, output: 32_000 },
+            }),
+          },
+        })
+        .pipe(Effect.map((outcome) => outcome.status))
+
+    const big = assistant("large", 250_000)
+    const start = [user("Start synthetic task"), big]
+    expect(yield* status("large", start)).toBe("skipped") // 1M - 600k remains usable.
+
+    const switched = [...start, user("Switch to smaller provider")]
+    expect(yield* status("small", switched)).toBe("skipped") // Ignore large provider's token count.
+    const small = [...switched, assistant("small", 25_000)]
+    expect(yield* status("small", small)).toBe("skipped") // Oversized buffer falls back to default.
+
+    expect(yield* status("large", [...small, user("Switch back")])).toBe("skipped")
+
+    // Real pressure on the smaller provider still triggers normal auto-compaction (200k - 20k).
+    expect(yield* status("small", [...switched, assistant("small", 180_000)])).toBe("completed")
+  }),
+)
+
 /** Seeds the global project plus one session row, returning the projected session. */
 const insertSession = (id: Session.ID, overrides?: Partial<typeof SessionTable.$inferInsert>) =>
   Effect.gen(function* () {