What a consumer Mac app does on the day five frontier LLM events land in a 48-hour window

The 48-hour window, event by event

The narrow read is that April was a busy month for model releases (true: at least nine significant models from six labs in the first half). The useful read is what happens on a single user's machine when four labs land four shipping or retirement events in two days. Here is the local view of the window.

A roundup is allowed to stop here. A consumer Mac app is not. The three model launches each demand a different ingress path (acp-bridge natively handles Claude, codex-acp natively handles GPT, everything else routes through a Custom API Endpoint), and the Sonnet 1M retirement creates orphaned entries in any user's persisted settings. The next three sections trace what Fazm actually does on your Mac during that window.

Step 1: the picker repopulates without an app update

The picker is not a static array. It is a derived view of two streams (Claude models from acp-bridge, Codex models from codex-acp), filtered and merged at runtime. Every time either stream reports a new list, the recomputeAvailableModels() function at ShortcutSettings.swift:289 fires. The merged list replaces the @Published availableModels array, SwiftUI rebinds, and the picker changes shape. No App Store push, no settings dialog, no user action.

Here is the JSON-RPC frame to picker UI path verbatim, with the functions that fire on each hop labelled inline.

The hops marked event are self-messages: filterContextVariants(), recomputeAvailableModels(), and the migration ladder all run inside ShortcutSettings without leaving the actor. Once the @Published mutation hits availableModels, SwiftUI does the rest. The pill on the floating bar rebinds on the same frame.

Step 2: the version floor at CodexBackendManager.swift:190

The actual rule that decides whether a Codex model survives the next picker rebuild fits on the screen. It is 16 lines. It does not look at benchmarks. It does not call out to a remote model registry. It parses the model id, strips variant suffixes, and compares the base version against a hardcoded floor of gpt-5.5. Anything older drops out the next time codex-acp probes.

// /Users/matthewdi/fazm/Desktop/Sources/CodexBackendManager.swift
// Lines 186 to 205. The literal frontier filter.

/// Returns true when the modelId belongs to the current frontier generation
/// the picker should expose (gpt-5.5 or newer). Older generations like
/// gpt-5.4, gpt-5.3-codex, gpt-5.2 are hidden once a newer generation works.
/// Inputs look like "gpt-5.5/high", "gpt-5.4-mini/low", "gpt-5.3-codex/high".
static func isPickerEligible(modelId: String) -> Bool {
    let family = modelId.split(separator: "/").first.map(String.init) ?? modelId
    // Strip variant suffixes ("-mini", "-codex") so we only compare base version
    let base = family.split(separator: "-").prefix(2).joined(separator: "-")
    // base is "gpt-5.5", "gpt-5.4", etc. Extract major.minor.
    guard base.hasPrefix("gpt-") else { return false }
    let version = String(base.dropFirst("gpt-".count))
    let parts = version.split(separator: ".")
    guard parts.count == 2,
          let major = Int(parts[0]),
          let minor = Int(parts[1]) else { return false }
    // Keep gpt-5.5 and newer (e.g. 5.5, 5.6, 6.0)
    if major > 5 { return true }
    if major == 5 && minor >= 5 { return true }
    return false
}

Three structural choices worth flagging. First, the parser ignores anything after the second hyphen in the family, so gpt-5.5-mini and gpt-5.5-codex collapse to the same base for the version check. The variant survives if the base survives. Second, the rule is open ended: when OpenAI ships gpt-5.6 or gpt-6.0, the existing binary accepts the new model on the next probe with no code change. Third, the floor is a constant. Bumping it (say, to gpt-5.6) is a one-line edit; the next Fazm release inherits the new floor without touching the picker UI.

Step 3: the migration ladder at ShortcutSettings.swift:296

The filter is half the story. The other half is what happens when a user's saved selectedModel gets filtered out. The migration ladder runs as a four-rung if-else chain immediately after the @Published mutation:

// /Users/matthewdi/fazm/Desktop/Sources/FloatingControlBar/ShortcutSettings.swift
// Lines 296 to 323. Four rules tried in order.

// If the current selection vanished, try to migrate it within the same
// backend (Claude alias normalization or longest-prefix match).
guard !merged.contains(where: { $0.id == selectedModel }) else { return }
let normalizedSelection = Self.normalizeModelId(selectedModel)
if merged.contains(where: { $0.id == normalizedSelection }) {
    selectedModel = normalizedSelection
    log("ShortcutSettings: normalized selectedModel to \(normalizedSelection)")
} else if selectedModel.contains("[1m]") {
    // User had a [1m] variant saved but it's been filtered out (likely switched
    // to builtin mode where 1M context isn't available). Strip [1m] and retry.
    let stripped = normalizedSelection.replacingOccurrences(of: "[1m]", with: "")
    if let fallback = merged.first(where: { $0.id == stripped }) {
        selectedModel = fallback.id
        log("ShortcutSettings: dropped [1m] variant \(selectedModel) -> \(fallback.id)")
    }
} else if selectedModel.hasPrefix("gpt-"),
          let preferred = Self.preferredGptModel(in: merged, sameEffortAs: selectedModel) {
    // GPT model was filtered out (e.g. gpt-5.4/high after upgrading to 5.5).
    // Pick the same effort tier within the new generation, falling back
    // to the first GPT model if no effort match.
    selectedModel = preferred
    log("ShortcutSettings: upgraded GPT selectedModel \(normalizedSelection) -> \(preferred)")
} else if let upgraded = merged.first(where: { $0.id.contains(normalizedSelection) }) {
    selectedModel = upgraded.id
    log("ShortcutSettings: upgraded selectedModel \(normalizedSelection) -> \(upgraded.id)")
}

The rules in order: alias normalization (the Opus 4.7 case from April 22), bracket suffix stripping (the Sonnet 1M retirement case from April 30), same-effort GPT migration (the gpt-5.4 to gpt-5.5 case from May 1), and longest-prefix matching. The chain is short because most cases are one of the first three.

The same-effort GPT migration is the part worth slowing down on. The rule is in preferredGptModel(in:sameEffortAs:) at ShortcutSettings.swift:329. It is 20 lines. It splits the old id on "/" to get the effort tier (high, medium, low, xhigh), then searches the merged list in three passes: plain family at the requested effort (gpt-5.5/high is preferred over gpt-5.5-mini/high), then any model at the requested effort, then the first GPT model in the list. A user who had gpt-5.4/high pinned for two weeks lands on gpt-5.5/high the next time the picker repopulates.

// /Users/matthewdi/fazm/Desktop/Sources/FloatingControlBar/ShortcutSettings.swift
// Lines 329 to 348. The same-effort migration heuristic.

private static func preferredGptModel(in merged: [ModelOption],
                                      sameEffortAs oldId: String) -> String? {
    let effort = oldId.split(separator: "/").last.map(String.init) ?? "high"
    // Match base family (no variants like -mini, -codex) at requested effort first.
    let plainSameEffort = merged.first { opt in
        guard opt.id.hasPrefix("gpt-") else { return false }
        let parts = opt.id.split(separator: "/")
        guard parts.count == 2, parts[1] == effort else { return false }
        // Plain family = "gpt-X.Y" with no extra dashes after the version.
        let family = String(parts[0])
        let dashCount = family.filter { $0 == "-" }.count
        return dashCount == 1
    }
    if let plain = plainSameEffort { return plain.id }
    // Then any GPT at the requested effort.
    if let anySameEffort = merged.first(where: { $0.id.hasPrefix("gpt-") && $0.id.hasSuffix("/\(effort)") }) {
        return anySameEffort.id
    }
    // Last resort: first GPT model in the list.
    return merged.first(where: { $0.id.hasPrefix("gpt-") })?.id
}

What the picker does not do

The version floor is opinionated, not authoritarian. It is also not a model registry, a downloader, or a benchmark. The boundaries are worth being explicit about, because the alternative is a wishlist that maps poorly to what a single app on a single Mac can credibly do.

Why this matters when a model lands tomorrow

The interesting property of the version-floor heuristic is that it generalises. When OpenAI ships gpt-5.6 next week, the existing binary will absorb it the next time codex-acp probes; the migration ladder will move users on gpt-5.5/high to gpt-5.6/high if a newer floor bump arrives. When Anthropic flips Opus 4.8 to GA, the alias normalization rule already in place (opus to default, normalize at read time) catches it. When a future Sonnet variant ships with a 2M context window beta, the bracket-stripping rule already handles the retirement.

The non-claim is that this picker rule is the source of truth on which model you should pick. It is not. The benchmarks people argue about (SWE-Bench Verified, MMLU, aider-polyglot, multi-step tool use) all still matter; the picker is just the bit that keeps the user interface honest when the upstream world reshuffles. For the April 29 to April 30, 2026 window, that meant five frontier events landed and the user on the floating bar saw their model pill continue to render the right label across all of them. The code that made that true is roughly 100 lines, distributed across two files.

Cross-references and source files

• Frontier filter: /Users/matthewdi/fazm/Desktop/Sources/CodexBackendManager.swift lines 186 to 205, 206 lines total.
• Migration ladder: /Users/matthewdi/fazm/Desktop/Sources/FloatingControlBar/ShortcutSettings.swift lines 211 to 348, 494 lines total.
• CHANGELOG entries: /Users/matthewdi/fazm/CHANGELOG.json releases 2.6.2 through 2.7.2, dates 2026-04-28 to 2026-05-02.
• Open source repository at github.com/m13v/fazm; download at fazm.ai/download.