@@ -0,0 +1,26 @@
+// altimate_change start — shared vendor classifier for `model.family` values.
+//
+// `model.family` is a free-form string in the Model schema; the model registry
+// (`packages/opencode/test/tool/fixtures/models-api.json`) uses *specific*
+// values like `claude-sonnet`, `claude-haiku`, `gemini-pro`, `gemini-flash`,
+// `gpt-codex`, etc. — never the coarse `anthropic`/`gemini`/`openai` literals.
+// Routing code that exact-matches against the coarse names silently misses
+// real models, recreating the GH #887 misrouting class on any altimate-backend
+// gateway path that exposes Claude or Gemini models. Use this helper to map a
+// specific family value to its vendor bucket.
+//
+// Reviewer-driven addition (PR #888 review thread, J1 from the multi-LLM
+// panel). Keep this the single source of truth so the prompt-routing and the
+// hoist-decision both interpret family the same way.
+
+export type Vendor = "anthropic" | "gemini" | "openai"
+
+export function familyVendor(family: string | undefined): Vendor | undefined {
+  if (!family) return undefined
+  const f = family.toLowerCase()
+  if (f === "anthropic" || f === "claude" || f.startsWith("claude-")) return "anthropic"
+  if (f === "gemini" || f.startsWith("gemini-")) return "gemini"
+  if (f === "openai" || f === "openai-compatible" || f === "gpt" || f.startsWith("gpt-")) return "openai"
+  return undefined
+}
+// altimate_change end
@@ -11,6 +11,9 @@ import { Session } from "."
 import { Agent } from "../agent/agent"
 import { Provider } from "../provider/provider"
 import { ModelID, ProviderID } from "../provider/schema"
+// altimate_change start — shared family→vendor classifier (#888 J1)
+import { familyVendor } from "../provider/family"
+// altimate_change end
 import { type Tool as AITool, tool, jsonSchema, type ToolCallOptions, asSchema } from "ai"
 import { SessionCompaction } from "./compaction"
 import { Instance } from "../project/instance"
@@ -688,25 +691,23 @@ export namespace SessionPrompt {
       const agent = await Agent.get(lastUser.agent)
       const maxSteps = agent.steps ?? Infinity
       const isLastStep = step >= maxSteps
-      // altimate_change start — insertReminders now returns the trusted reminder
-      // parts it appended; for non-Anthropic-like models we hoist them into the
-      // system prompt and mark the parts ignored so they don't ALSO appear in
-      // the user message. The returned-parts list is the trust boundary —
-      // never the `synthetic` flag (other code paths set it on file/resource
-      // expansions, which are user-derived). See #887/#888 review thread.
+      // altimate_change start — insertReminders returns the trusted reminder parts
+      // it appended. The function now also pre-applies `ignored: true` to those
+      // parts (and to the persisted rows under experimental plan mode) for
+      // non-Anthropic-like models, so `toModelMessages` skips them on every turn
+      // — not just this one (#888 J2). The returned-parts list is the trust
+      // boundary; we never infer trust from the `synthetic` flag (other code
+      // paths set it on user-derived file/resource expansions). See #887/#888.
       const reminderResult = await insertReminders({
         messages: msgs,
         agent,
         session,
+        model,
       })
       msgs = reminderResult.messages
-      const hoistedReminders: string[] = []
-      if (!isAnthropicLikeModel(model)) {
-        for (const part of reminderResult.trustedReminderParts) {
-          hoistedReminders.push(part.text)
-          part.ignored = true
-        }
-      }
+      const hoistedReminders = isAnthropicLikeModel(model)
+        ? []
+        : reminderResult.trustedReminderParts.map((p) => p.text)
       // altimate_change end
 
       // altimate_change start — plan refinement detection and telemetry
@@ -2055,16 +2056,22 @@ export namespace SessionPrompt {
     }
   }
 
-  // altimate_change start — model-family helper used by the trust-aware hoist below
+  // altimate_change start — model-family helper used by the trust-aware hoist below.
+  // Uses `familyVendor` so specific family values (`claude-sonnet`, `claude-haiku`,
+  // `gemini-pro`, etc.) classify correctly — an exact `family === "anthropic"`
+  // check would miss the gateway-emitted specific names (#888 J1). The api.id
+  // checks are lowercased and tightened to a `claude-` / `anthropic-` /
+  // `anthropic/...` shape so a model named `foo-claude-bench` doesn't false-match.
   function isAnthropicLikeModel(model: Provider.Model): boolean {
-    return (
-      model.providerID === "anthropic" ||
-      model.providerID === "google-vertex-anthropic" ||
-      model.family?.toLowerCase() === "anthropic" ||
-      model.api.npm === "@ai-sdk/anthropic" ||
-      model.api.id.includes("anthropic") ||
-      model.api.id.includes("claude")
-    )
+    if (model.providerID === "anthropic") return true
+    if (model.providerID === "google-vertex-anthropic") return true
+    if (familyVendor(model.family) === "anthropic") return true
+    if (model.api.npm === "@ai-sdk/anthropic") return true
+    const apiId = model.api.id.toLowerCase()
+    const lastSeg = apiId.split("/").pop() ?? apiId
+    if (/^claude[-_.]/.test(lastSeg)) return true
+    if (/^anthropic[-_/]/.test(apiId)) return true
+    return false
   }
   // altimate_change end
 
@@ -2080,8 +2087,20 @@ export namespace SessionPrompt {
     messages: MessageV2.WithParts[]
     agent: Agent.Info
     session: Session.Info
+    // altimate_change start — used to bake `ignored` into the persisted experimental
+    // plan-mode reminders so they don't replay as user-role `<system-reminder>` on
+    // turn 2+ on non-Anthropic models (#888 J2).
+    model: Provider.Model
+    // altimate_change end
   }): Promise<InsertRemindersResult> {
     const trustedReminderParts: MessageV2.TextPart[] = []
+    // altimate_change start — pre-compute the hoist decision once so it can be
+    // applied at insertion time (including to persisted rows). For non-Anthropic
+    // models, every trusted reminder is marked `ignored: true` immediately so
+    // `toModelMessages` will skip it (the caller no longer needs to mutate the
+    // flag, and DB-persisted rows survive the contract across turns).
+    const nonAnthropic = !isAnthropicLikeModel(input.model)
+    // altimate_change end
     const userMessage = input.messages.findLast((msg) => msg.info.role === "user")
     if (!userMessage) return { messages: input.messages, trustedReminderParts }
 
@@ -2095,6 +2114,7 @@ export namespace SessionPrompt {
           type: "text",
           text: PROMPT_PLAN,
           synthetic: true,
+          ...(nonAnthropic ? { ignored: true } : {}),
         }
         userMessage.parts.push(part)
         trustedReminderParts.push(part)
@@ -2108,6 +2128,7 @@ export namespace SessionPrompt {
           type: "text",
           text: BUILD_SWITCH,
           synthetic: true,
+          ...(nonAnthropic ? { ignored: true } : {}),
         }
         userMessage.parts.push(part)
         trustedReminderParts.push(part)
@@ -2131,6 +2152,7 @@ export namespace SessionPrompt {
           text:
             BUILD_SWITCH + "\n\n" + `A plan file exists at ${plan}. You should execute on the plan defined within it`,
           synthetic: true,
+          ...(nonAnthropic ? { ignored: true } : {}),
         })
         userMessage.parts.push(part)
         trustedReminderParts.push(part as MessageV2.TextPart)
@@ -2235,6 +2257,7 @@ This is critical - your turn should only end with either asking the user a quest
 NOTE: At any point in time through this workflow you should feel free to ask the user questions or clarifications. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.
 </system-reminder>`,
         synthetic: true,
+        ...(nonAnthropic ? { ignored: true } : {}),
       })
       userMessage.parts.push(part)
       trustedReminderParts.push(part as MessageV2.TextPart)
 
@@ -10,6 +10,9 @@ import PROMPT_ANTHROPIC from "./prompt/anthropic.txt"
 import PROMPT_ANTHROPIC_WITHOUT_TODO from "./prompt/qwen.txt"
 import PROMPT_BEAST from "./prompt/beast.txt"
 import PROMPT_GEMINI from "./prompt/gemini.txt"
+// altimate_change start — shared family→vendor classifier (see #888 J1)
+import { familyVendor } from "../provider/family"
+// altimate_change end
 
 import PROMPT_CODEX from "./prompt/codex_header.txt"
 import PROMPT_TRINITY from "./prompt/trinity.txt"
@@ -33,16 +36,23 @@ export namespace SystemPrompt {
     // before the api.id string-match fallthrough. The gateway's model.api.id is
     // the opaque alias `altimate-default` (kept stable for backward compat —
     // users persist it in model.json), which matches none of the patterns below.
-    // Defense in depth: without this guard a future provider misconfiguration
-    // could route an OpenAI-backed gateway model to PROMPT_ANTHROPIC_WITHOUT_TODO.
-    // Family lookup is case-insensitive since `family` is a free-form string in
-    // the Model schema. Unknown families default to PROMPT_CODEX because the
-    // gateway is registered as `@ai-sdk/openai-compatible`.
+    // Use the shared `familyVendor` classifier so specific family values
+    // (`claude-sonnet`, `gemini-pro`, `gpt-codex`, …) map to the right vendor.
+    // An exact `family === "anthropic"` check would silently fall through to
+    // PROMPT_CODEX on any altimate-backend gateway path that exposes a Claude
+    // model with the specific family — recreating the #887 misrouting class
+    // this PR is meant to fix (see #888 J1).
+    // Unknown vendors default to PROMPT_CODEX because the gateway is registered
+    // as `@ai-sdk/openai-compatible`.
     if (model.providerID === "altimate-backend") {
-      const family = model.family?.toLowerCase()
-      if (family === "anthropic") return [PROMPT_ANTHROPIC]
-      if (family === "gemini") return [PROMPT_GEMINI]
-      return [PROMPT_CODEX]
+      switch (familyVendor(model.family)) {
+        case "anthropic":
+          return [PROMPT_ANTHROPIC]
+        case "gemini":
+          return [PROMPT_GEMINI]
+        default:
+          return [PROMPT_CODEX]
+      }
     }
     // altimate_change end
     if (model.api.id.includes("gpt-5")) return [PROMPT_CODEX]
 
@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test"
+import { familyVendor } from "../../src/provider/family"
+
+// Locks the contract for the shared family→vendor classifier introduced for
+// #888 J1. The model registry uses *specific* family values like
+// `claude-sonnet`, `claude-haiku`, `gemini-pro`, `gemini-flash`, etc., not the
+// coarse `anthropic`/`gemini`/`openai` literals — so exact-match logic in the
+// previous version silently fell through to PROMPT_CODEX on any altimate-
+// backend gateway path that exposed a Claude model.
+describe("familyVendor", () => {
+  test.each([
+    // Coarse vendor literals.
+    ["anthropic", "anthropic"],
+    ["openai", "openai"],
+    ["openai-compatible", "openai"],
+    ["gemini", "gemini"],
+    ["claude", "anthropic"],
+    ["gpt", "openai"],
+    // Specific names that the model registry actually emits.
+    ["claude-sonnet", "anthropic"],
+    ["claude-haiku", "anthropic"],
+    ["claude-opus", "anthropic"],
+    ["gemini-pro", "gemini"],
+    ["gemini-flash", "gemini"],
+    ["gemini-flash-lite", "gemini"],
+    ["gpt-codex", "openai"],
+    ["gpt-codex-mini", "openai"],
+    // Case-insensitivity.
+    ["ANTHROPIC", "anthropic"],
+    ["Claude-Sonnet", "anthropic"],
+    ["GEMINI-PRO", "gemini"],
+    ["GPT", "openai"],
+  ] as const)("classifies %p as %p", (family, expected) => {
+    expect(familyVendor(family)).toBe(expected)
+  })
+
+  test.each([undefined, "", "unknown-future-family", "kimi", "qwen", "llama"])("returns undefined for %p", (family) => {
+    expect(familyVendor(family)).toBeUndefined()
+  })
+})
@@ -472,15 +472,10 @@ describe("plan prompt safety", () => {
       "utf-8",
     )
     // Must consume the trusted-parts contract.
-    expect(promptTs).toMatch(/trustedReminderParts/)
-    // The hoist loop must iterate the returned trusted parts.
-    expect(promptTs).toMatch(/for \(const part of reminderResult\.trustedReminderParts\)/)
+    expect(promptTs).toMatch(/reminderResult\.trustedReminderParts/)
     // The hoist must NOT have been re-implemented as a scan over `part.synthetic`,
     // which would re-open the prompt-injection vector via attached file content.
     expect(promptTs).not.toMatch(/hoistSyntheticReminders/)
-    // The loose `if (!part.synthetic) continue` shape must not reappear in any
-    // trust-boundary context. The remaining `synthetic` usages should only be
-    // setters or the unrelated text-wrap skip at the queued-message reminder.
   })
 
   test("insertReminders return shape includes trustedReminderParts", async () => {
@@ -495,6 +490,50 @@ describe("plan prompt safety", () => {
       /type InsertRemindersResult = \{ messages: MessageV2\.WithParts\[\]; trustedReminderParts: MessageV2\.TextPart\[\] \}/,
     )
   })
+
+  // #888 J2 regression guard. Persisted experimental-mode reminders must carry
+  // `ignored: true` for non-Anthropic models — otherwise on turn 2+ they reload
+  // from DB with `ignored: undefined`, slip into the user-role payload via
+  // `toModelMessages` (which gates on `!part.ignored`), and re-trigger the GPT-5.x
+  // refusal class this PR was meant to fix.
+  test("insertReminders bakes `ignored: true` into trusted reminders for non-Anthropic models", async () => {
+    const promptTs = await fs.readFile(
+      path.join(__dirname, "../../src/session/prompt.ts"),
+      "utf-8",
+    )
+    // The function must take `model` so it can compute the hoist decision once.
+    expect(promptTs).toMatch(/async function insertReminders\(input:\s*\{[\s\S]*?model: Provider\.Model/)
+    // The `nonAnthropic` decision must drive an `ignored: true` annotation on
+    // each trusted part (and on the Session.updatePart payload for experimental
+    // persisted rows).
+    expect(promptTs).toMatch(/const nonAnthropic = !isAnthropicLikeModel\(input\.model\)/)
+    // At least one persisted-write site must include the conditional `ignored: true`.
+    const nonAnthropicIgnored = promptTs.match(/nonAnthropic \? \{ ignored: true \} : \{\}/g)
+    expect((nonAnthropicIgnored ?? []).length).toBeGreaterThanOrEqual(4)
+    // And the caller must no longer mutate `part.ignored = true` — that contract
+    // is now owned by insertReminders.
+    expect(promptTs).not.toMatch(/part\.ignored = true/)
+  })
+
+  // #888 J1 regression guard. `family` is a free-form string and the model
+  // registry uses specific values (`claude-sonnet`, `gemini-pro`, …); an exact
+  // `family === "anthropic"` match would silently fall through to PROMPT_CODEX
+  // on any altimate-backend gateway path exposing a Claude/Gemini model.
+  test("family routing uses the shared familyVendor helper, not exact-match literals", async () => {
+    const systemTs = await fs.readFile(
+      path.join(__dirname, "../../src/session/system.ts"),
+      "utf-8",
+    )
+    const promptTs = await fs.readFile(
+      path.join(__dirname, "../../src/session/prompt.ts"),
+      "utf-8",
+    )
+    expect(systemTs).toMatch(/familyVendor\(model\.family\)/)
+    expect(promptTs).toMatch(/familyVendor\(model\.family\)/)
+    // Exact-match `family === "anthropic"` shape must not reappear in the
+    // altimate-backend routing block.
+    expect(systemTs).not.toMatch(/model\.providerID === "altimate-backend"[\s\S]{0,200}family === "anthropic"/)
+  })
 })
 
 // ---------------------------------------------------------------------------