fix: plan-mode refusals on altimate-default + warning false-positive (#887)

packages/opencode/src/provider/family.ts

@@ -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

packages/opencode/src/session/processor.ts

@@ -303,7 +303,7 @@ export namespace SessionProcessor {
  })
  break
 
- case "finish-step":
+ case "finish-step": {
  const usage = Session.getUsage({
  model: input.model,
  usage: value.usage,
@@ -348,10 +348,27 @@ export namespace SessionProcessor {
  // Users read the text, see no progress, and abandon. Surface a
  // warning + telemetry so the pattern is measurable and the user
  // knows to try a different model.
+ //
+ // sessionToolCallsMade tracks tool calls in the CURRENT step only
+ // — SessionProcessor.create() is called per-step by loop() (see
+ // prompt.ts), so the closure variable resets each step. A multi-
+ // step plan-mode session (read → grep → read → … → final text)
+ // would then false-positive on the final text-only step. Also
+ // scan streamInput.messages for any prior assistant tool-call
+ // content; if found, the session has used tools and the warning
+ // should be suppressed.
+ const sessionHasPriorToolCalls =
+ sessionToolCallsMade > 0 ||
+ streamInput.messages.some(
+ (m) =>
+ m.role === "assistant" &&
+ Array.isArray(m.content) &&
+ m.content.some((p) => p.type === "tool-call"),
+ )
  if (
  input.assistantMessage.agent === "plan" &&
  value.finishReason === "stop" &&
-sessionToolCallsMade === 0 &&
+!sessionHasPriorToolCalls &&
  !planNoToolWarningEmitted
  ) {
  planNoToolWarningEmitted = true
@@ -381,9 +398,13 @@ export namespace SessionProcessor {
  type: "text",
  synthetic: true,
  text:
- `⚠️ altimate-code: the \`plan\` agent is running on \`${input.model.providerID}/${input.model.id}\`, ` +
- `which returned text without calling any tools. If you expected the plan agent to explore the ` +
- `codebase, try switching to a model with stronger tool-use via \`/model\`.`,
+ `⚠️ altimate-code: the \`plan\` agent on \`${input.model.providerID}/${input.model.id}\` ` +
+ `stopped without calling any tools — it neither read, searched, nor explored the codebase. ` +
+ `Common causes: (a) the model wrote a plan from prompt context alone, (b) the model declined ` +
+ `to engage with the request (content-policy refusal), or (c) the request was too thin to act on. ` +
+ `To recover, try one of: reply asking it to investigate first (\`read\`/\`grep\`/\`glob\`/\`explore\`); ` +
+ `rephrase the request more concretely; or \`/model\` to a tier that's more eager to explore ` +
+ `(e.g. Claude Sonnet/Opus).`,
  time: { start: Date.now(), end: Date.now() },
  })
  }
@@ -424,6 +445,7 @@ export namespace SessionProcessor {
  needsCompaction = true
  }
  break
+ }
 
  case "text-start":
  currentText = {

packages/opencode/src/session/prompt.ts

@@ -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,11 +691,24 @@ export namespace SessionPrompt {
  const agent = await Agent.get(lastUser.agent)
  const maxSteps = agent.steps ?? Infinity
  const isLastStep = step >= maxSteps
- msgs = await insertReminders({
+ // 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 = isAnthropicLikeModel(model)
+ ? []
+ : reminderResult.trustedReminderParts.map((p) => p.text)
+ // altimate_change end
 
  // altimate_change start — plan refinement detection and telemetry
  if (agent.name === "plan") {
@@ -968,6 +984,7 @@ export namespace SessionPrompt {
  ...(skills ? [skills] : []),
  ...(knowledgeInjection ? [knowledgeInjection] : []),
  ...(await InstructionPrompt.system()),
+ ...hoistedReminders,
  ]
  const format = lastUser.format ?? { type: "text" }
  if (format.type === "json_schema") {
@@ -2039,34 +2056,84 @@ export namespace SessionPrompt {
  }
  }
 
- async function insertReminders(input: { messages: MessageV2.WithParts[]; agent: Agent.Info; session: Session.Info }) {
+ // 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 {
+ 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
+
+ // altimate_change start — return the trusted reminder parts insertReminders just appended
+ // so the caller can hoist them into the system prompt on non-Anthropic models.
+ // The returned-parts contract is the trust boundary: only parts that *this function*
+ // creates are eligible for promotion. The schema-wide `synthetic` flag is set by other
+ // code paths too (file/resource expansions at lines ~1729/1751/1801 attach
+ // file content as synthetic text), so it is not safe to infer trust from `synthetic`
+ // alone. See #888 review feedback.
+ type InsertRemindersResult = { messages: MessageV2.WithParts[]; trustedReminderParts: MessageV2.TextPart[] }
+ async function insertReminders(input: {
+ 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 input.messages
+ if (!userMessage) return { messages: input.messages, trustedReminderParts }
 
  // Original logic when experimental plan mode is disabled
  if (!Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE) {
  if (input.agent.name === "plan") {
-userMessage.parts.push({
+const part: MessageV2.TextPart = {
  id: PartID.ascending(),
  messageID: userMessage.info.id,
  sessionID: userMessage.info.sessionID,
  type: "text",
  text: PROMPT_PLAN,
  synthetic: true,
- })
+ ...(nonAnthropic ? { ignored: true } : {}),
+ }
+ userMessage.parts.push(part)
+ trustedReminderParts.push(part)
  }
  const wasPlan = input.messages.some((msg) => msg.info.role === "assistant" && msg.info.agent === "plan")
  if (wasPlan && input.agent.name === "builder") {
-userMessage.parts.push({
+const part: MessageV2.TextPart = {
  id: PartID.ascending(),
  messageID: userMessage.info.id,
  sessionID: userMessage.info.sessionID,
  type: "text",
  text: BUILD_SWITCH,
  synthetic: true,
- })
+ ...(nonAnthropic ? { ignored: true } : {}),
+ }
+ userMessage.parts.push(part)
+ trustedReminderParts.push(part)
  }
- return input.messages
+ return { messages: input.messages, trustedReminderParts }
  }
 
  // New plan mode logic when flag is enabled
@@ -2085,10 +2152,12 @@ 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)
  }
- return input.messages
+ return { messages: input.messages, trustedReminderParts }
  }
 
  // Entering plan mode
@@ -2188,12 +2257,15 @@ 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)
- return input.messages
+ trustedReminderParts.push(part as MessageV2.TextPart)
+ return { messages: input.messages, trustedReminderParts }
  }
- return input.messages
+ return { messages: input.messages, trustedReminderParts }
  }
+ // altimate_change end
 
  export const ShellInput = z.object({
  sessionID: SessionID.zod,

packages/opencode/src/session/prompt/plan.txt

@@ -20,6 +20,22 @@ Ask the user clarifying questions or ask for their opinion when weighing tradeof
 
 ---
 
+// altimate_change start — mandatory exploration before drafting
+## Investigate before drafting (REQUIRED)
+
+Before you write any plan content — outline OR full plan — you MUST call at least one read-only investigation tool against the actual codebase. Acceptable first moves:
+
+- `read` / `grep` / `glob` / `list` on relevant files
+- launching one or more `explore` subagents in parallel for broader sweeps
+- `bash` for read-only inspection (e.g. `git log`, `git diff`, `ls`)
+
+Plans written from the prompt alone — without inspecting the repo — are guesswork. They reference files that may not exist, miss existing patterns, and waste the user's time. If the task is trivial enough that you genuinely have everything needed (e.g. the user pasted the exact file contents inline), say so explicitly before drafting.
+
+This applies on the very first step. Do not produce a plan, an outline, or a "summary of approach" as your first action.
+// altimate_change end
+
+---
+
 // altimate_change start — two-step plan approach with refinement loop
 ## Two-Step Plan Approach