airaknit 1.1.2-rc.9

package/src/server/pr3-liveness.test.ts

@@ -0,0 +1,252 @@
+/**
+ * PR3 Stage 2 integration tests — heartbeat-TTL liveness states.
+ *
+ * Covers:
+ *  1. /health exposes state/protocolVersion/incompatible (boot a real server,
+ *     assert the shape once a runner is healthy).
+ *  2. Discover path: KV entry with stale lastSeenAt → not adoptable; fresh → adoptable.
+ *  3. getReadiness() derives state from runnerLivenessState (unit, no NATS required).
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { mkdtempSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { NatsServer } from "@lagz0ne/nats-embedded"
+import { connect, type NatsConnection } from "@nats-io/transport-node"
+import { Kvm } from "@nats-io/kv"
+import { startServer } from "./server"
+import { RunnerManager } from "./runner-manager"
+import { ensureRunnerEventsStream, ensureRunnerRegistryBucket } from "./nats-streams"
+import {
+  RUNNER_REGISTRY_BUCKET,
+  LIVENESS_OFFLINE_MS,
+  type RunnerRegistration,
+} from "../shared/runner-protocol"
+
+const encoder = new TextEncoder()
+
+// ── Unit: getReadiness derives liveness state from lastHeartbeatAt ────────────
+
+describe("RunnerManager.getReadiness — liveness state derivation", () => {
+  let server: NatsServer
+  let nc: NatsConnection
+
+  beforeEach(async () => {
+    server = await NatsServer.start({ jetstream: true })
+    nc = await connect({ servers: server.url })
+    await ensureRunnerEventsStream(nc)
+  })
+
+  afterEach(async () => {
+    await nc?.drain()
+    await server?.stop()
+  })
+
+  test("state is 'offline' when no heartbeat has been received", () => {
+    const mgr = new RunnerManager({ nc, natsUrl: server.url })
+    const r = mgr.getReadiness()
+    expect(r.state).toBe("offline")
+    expect(r.heartbeatFresh).toBe(false)
+    expect(r.ok).toBe(false)
+  })
+
+  test("state is 'online' when heartbeat was just received (simulated via injected clock)", async () => {
+    const mgr = new RunnerManager({ nc, natsUrl: server.url })
+    // Access private field to inject a heartbeat timestamp directly.
+    const now = Date.now()
+    ;(mgr as unknown as { lastHeartbeatAt: number }).lastHeartbeatAt = now
+    const r = mgr.getReadiness(now)
+    expect(r.state).toBe("online")
+    expect(r.heartbeatFresh).toBe(true)
+  })
+
+  test("state is 'degraded' when heartbeat age is between 25s and 60s", () => {
+    const mgr = new RunnerManager({ nc, natsUrl: server.url })
+    const now = Date.now()
+    ;(mgr as unknown as { lastHeartbeatAt: number }).lastHeartbeatAt = now - 30_000
+    const r = mgr.getReadiness(now)
+    expect(r.state).toBe("degraded")
+    expect(r.heartbeatFresh).toBe(false) // heartbeatFresh === (state === "online")
+  })
+
+  test("state is 'offline' when heartbeat is older than LIVENESS_OFFLINE_MS", () => {
+    const mgr = new RunnerManager({ nc, natsUrl: server.url })
+    const now = Date.now()
+    ;(mgr as unknown as { lastHeartbeatAt: number }).lastHeartbeatAt = now - LIVENESS_OFFLINE_MS
+    const r = mgr.getReadiness(now)
+    expect(r.state).toBe("offline")
+    expect(r.heartbeatFresh).toBe(false)
+  })
+
+  test("heartbeatFresh === (state === 'online') invariant holds for all states", () => {
+    const mgr = new RunnerManager({ nc, natsUrl: server.url })
+    const now = Date.now()
+
+    for (const [age, expectedState] of [
+      [0, "online"],
+      [30_000, "degraded"],
+      [LIVENESS_OFFLINE_MS, "offline"],
+      [null, "offline"],
+    ] as [number | null, string][]) {
+      ;(mgr as unknown as { lastHeartbeatAt: number | null }).lastHeartbeatAt =
+        age === null ? null : now - age
+      const r = mgr.getReadiness(now)
+      expect(r.state as string).toBe(expectedState)
+      expect(r.heartbeatFresh).toBe(r.state === "online")
+    }
+  })
+})
+
+// ── Integration: discover path uses lastSeenAt TTL, not process.kill ─────────
+
+describe("discover path — lastSeenAt TTL liveness", () => {
+  let server: NatsServer
+  let nc: NatsConnection
+  let tmpDir: string
+
+  beforeEach(async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "pr3-discover-"))
+    server = await NatsServer.start({ jetstream: true, storeDir: tmpDir })
+    nc = await connect({ servers: server.url })
+    await ensureRunnerEventsStream(nc)
+    await ensureRunnerRegistryBucket(nc)
+  })
+
+  afterEach(async () => {
+    await nc?.drain()
+    await server?.stop()
+    rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  test("stale lastSeenAt (>60s ago) → discover treats entry as offline, not adoptable", async () => {
+    // Write a KV entry whose lastSeenAt is well past the offline threshold.
+    const kvm = new Kvm(nc)
+    const kvStore = await kvm.open(RUNNER_REGISTRY_BUCKET)
+    const staleReg: RunnerRegistration = {
+      runnerId: "stale-runner",
+      pid: 99999,
+      startedAt: Date.now() - 120_000,
+      providers: ["claude", "codex"],
+      protocolVersion: 1,
+      lastSeenAt: Date.now() - (LIVENESS_OFFLINE_MS + 5_000), // 65s ago — offline
+    }
+    await kvStore.put("stale-runner", encoder.encode(JSON.stringify(staleReg)))
+
+    // Discover mode should poll, find stale-runner, skip it (offline), and
+    // eventually time out (no live runner). We cap the timeout to 1s for speed.
+    const mgr = new RunnerManager({ nc, natsUrl: server.url, mode: "discover" })
+    await expect(
+      // Override the 15s deadline: wrap in a 1.5s race so the test completes fast.
+      Promise.race([
+        mgr.ensureRunner(),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error("no live runner — stale skipped")), 1_500)
+        ),
+      ])
+    ).rejects.toThrow(/no live runner|No external runner/)
+  }, 10_000)
+
+  test("fresh lastSeenAt (just now) → discover adopts the entry", async () => {
+    // Write a KV entry with a fresh lastSeenAt so discover considers it live.
+    const kvm = new Kvm(nc)
+    const kvStore = await kvm.open(RUNNER_REGISTRY_BUCKET)
+    const freshRunnerId = "fresh-runner"
+    const freshReg: RunnerRegistration = {
+      runnerId: freshRunnerId,
+      pid: process.pid, // real pid so adopt doesn't crash on heartbeat wait
+      startedAt: Date.now(),
+      providers: ["claude", "codex"],
+      protocolVersion: 1,
+      lastSeenAt: Date.now(), // fresh
+    }
+    await kvStore.put(freshRunnerId, encoder.encode(JSON.stringify(freshReg)))
+
+    // Discover picks the runner as adoptable. It then subscribes to heartbeats
+    // and waits 5s for one — which won't arrive (no actual runner process here).
+    // That's expected: what we're testing is that the *entry is picked at all*.
+    const mgr = new RunnerManager({ nc, natsUrl: server.url, mode: "discover" })
+    await expect(
+      Promise.race([
+        mgr.ensureRunner(),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error("heartbeat timeout — runner adopted but no process")), 6_000)
+        ),
+      ])
+    ).rejects.toThrow(/heartbeat|no process/)
+    // The key assertion: runnerId was set (entry was adopted before the heartbeat wait)
+    expect((mgr as unknown as { runnerId: string | null }).runnerId).toBe(freshRunnerId)
+  }, 15_000)
+
+  test("incompatible lastSeenAt-fresh entry → discover skips it", async () => {
+    const kvm = new Kvm(nc)
+    const kvStore = await kvm.open(RUNNER_REGISTRY_BUCKET)
+    const incompatReg: RunnerRegistration = {
+      runnerId: "incompat-runner",
+      pid: 88888,
+      startedAt: Date.now(),
+      providers: ["claude"],
+      protocolVersion: 999, // outside SUPPORTED_RANGE
+      lastSeenAt: Date.now(), // fresh — but incompatible
+    }
+    await kvStore.put("incompat-runner", encoder.encode(JSON.stringify(incompatReg)))
+
+    const mgr = new RunnerManager({ nc, natsUrl: server.url, mode: "discover" })
+    await expect(
+      Promise.race([
+        mgr.ensureRunner(),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error("incompatible runner skipped")), 1_500)
+        ),
+      ])
+    ).rejects.toThrow(/incompatible|No external runner/)
+  }, 10_000)
+})
+
+// ── Integration: /health exposes state/protocolVersion/incompatible ───────────
+
+describe("/health runner shape (integration)", () => {
+  let started: Awaited<ReturnType<typeof startServer>> | null = null
+
+  afterEach(async () => {
+    await started?.stop()
+    started = null
+    delete process.env.NATS_DATA_DIR
+    delete process.env.RUNNER_PROTOCOL_VERSION
+  })
+
+  test("/health runner object includes state, protocolVersion, incompatible", async () => {
+    const natsDataDir = mkdtempSync(join(tmpdir(), "pr3-health-"))
+    process.env.NATS_DATA_DIR = natsDataDir
+    try {
+      started = await startServer({ port: 4371, host: "127.0.0.1", strictPort: true })
+      const port = started.port
+
+      // Wait up to 15s for the runner to become healthy.
+      let health: Record<string, unknown> | null = null
+      const deadline = Date.now() + 15_000
+      while (Date.now() < deadline) {
+        const res = await fetch(`http://127.0.0.1:${port}/health`)
+        const body = await res.json() as { ok: boolean; runner: Record<string, unknown> }
+        if (body.ok) {
+          health = body.runner
+          break
+        }
+        await new Promise((r) => setTimeout(r, 200))
+      }
+
+      expect(health).not.toBeNull()
+      // state must be present and one of the liveness values
+      expect(["online", "degraded", "offline"]).toContain(health!.state as string)
+      expect(health!.state).toBe("online") // healthy runner → online
+      // heartbeatFresh back-compat: must equal (state === "online")
+      expect(health!.heartbeatFresh).toBe(health!.state === "online")
+      // version fields
+      expect(typeof health!.protocolVersion).toBe("number")
+      expect(health!.protocolVersion).toBe(1)
+      expect(health!.incompatible).toBe(false)
+    } finally {
+      rmSync(natsDataDir, { recursive: true, force: true })
+    }
+  }, 30_000)
+})

package/src/server/process-utils.ts

@@ -0,0 +1,10 @@
+import { spawn, spawnSync } from "node:child_process"
+
+export function spawnDetached(command: string, args: string[]) {
+  spawn(command, args, { stdio: "ignore", detached: true }).unref()
+}
+
+export function hasCommand(command: string) {
+  const result = spawnSync("sh", ["-lc", `command -v ${command}`], { stdio: "ignore" })
+  return result.status === 0
+}

package/src/server/project-cli.ts

@@ -0,0 +1,180 @@
+// src/server/project-cli.ts
+
+export interface CliCommand {
+  command: string
+  args: Record<string, string | undefined>
+}
+
+export function parseProjectCliArgs(argv: string[]): CliCommand {
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    return { command: "help", args: {} }
+  }
+
+  const flags: Record<string, string> = {}
+  const positional: string[] = []
+
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith("--") && i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
+      flags[argv[i].slice(2)] = argv[i + 1]
+      i++
+    } else if (!argv[i].startsWith("--")) {
+      positional.push(argv[i])
+    }
+  }
+
+  const cmd = positional[0]
+  const rest = positional.slice(1)
+  // Normalize flag names to match API expectations
+  const normalized: Record<string, string> = {}
+  for (const [key, value] of Object.entries(flags)) {
+    if (key === "project") normalized["workspaceId"] = value
+    else normalized[key] = value
+  }
+  const args: Record<string, string | undefined> = { ...normalized }
+
+  switch (cmd) {
+    case "sessions":
+      if (rest.length > 0) return { command: "session-detail", args: { ...args, chatId: rest[0] } }
+      return { command: "sessions", args }
+    case "search":
+      return { command: "search", args: { ...args, query: rest.join(" ") } }
+    case "tasks":
+      if (rest.length > 0) return { command: "task-detail", args: { ...args, taskId: rest[0] } }
+      return { command: "tasks", args }
+    case "claim":
+      return { command: "claim", args: { ...args, description: rest.join(" ") } }
+    case "complete":
+      return { command: "complete", args: { ...args, taskId: rest[0] } }
+    case "delegate":
+      return { command: "delegate", args: { ...args, request: rest.join(" ") } }
+    default:
+      return { command: "help", args: {} }
+  }
+}
+
+export function formatOutput(command: string, data: unknown, json: boolean): string {
+  if (json) return JSON.stringify(data, null, 2)
+
+  if (command === "sessions" && Array.isArray(data)) {
+    if (data.length === 0) return "No sessions found."
+    const rows = data.map((s: Record<string, unknown>) =>
+      `${s.chatId}  ${String(s.status).padEnd(8)}  ${String(s.provider).padEnd(6)}  ${String(s.intent ?? "").slice(0, 50)}`
+    )
+    return ["CHAT_ID   STATUS    PROVIDER  INTENT", ...rows].join("\n")
+  }
+
+  if (command === "tasks" && Array.isArray(data)) {
+    if (data.length === 0) return "No tasks tracked."
+    const rows = data.map((t: Record<string, unknown>) =>
+      `${t.id}  ${String(t.status).padEnd(12)}  ${t.claimedBy ?? t.createdBy ?? "-"}  ${String(t.description).slice(0, 50)}`
+    )
+    return ["ID     STATUS        CLAIMED_BY  DESCRIPTION", ...rows].join("\n")
+  }
+
+  return JSON.stringify(data, null, 2)
+}
+
+export function getHelpText(): string {
+  return `tinkaria-project — Cross-session project agent CLI
+
+Commands:
+  sessions                    List active/recent sessions with summaries
+  sessions <chat-id>          Detailed summary of a specific session
+  search <query>              Lexical search over project transcripts
+  tasks                       List all project tasks
+  tasks <task-id>             Get task details
+  claim <description>         Claim a new task for the current session
+  complete <task-id>          Mark a task as complete
+  delegate <request>          Submit a delegation request to the project agent
+
+Flags:
+  --json                      Output as JSON (default when stdout is not a TTY)
+  --project <id>              Target project (default: current)
+  --session <chat-id>         Identify calling session (for claim/complete)
+  --port <port>               Tinkaria server port (default: 3210)
+  --version                   CLI version
+  --help                      Show this help`
+}
+
+export async function executeCommand(
+  parsed: CliCommand,
+  baseUrl: string,
+): Promise<{ output: string; exitCode: number }> {
+  const args = parsed.args
+  const json = "json" in args || !process.stdout.isTTY
+
+  try {
+    let data: unknown
+    switch (parsed.command) {
+      case "help":
+        return { output: getHelpText(), exitCode: 0 }
+      case "sessions": {
+        const workspaceId = args.workspaceId ?? ""
+        const res = await fetch(`${baseUrl}/api/workspace/sessions?workspaceId=${encodeURIComponent(workspaceId)}`)
+        data = await res.json()
+        break
+      }
+      case "session-detail": {
+        const res = await fetch(`${baseUrl}/api/workspace/sessions/${args.chatId}`)
+        if (res.status === 404) return { output: formatOutput("error", { error: "Session not found" }, json), exitCode: 1 }
+        data = await res.json()
+        break
+      }
+      case "search": {
+        const res = await fetch(`${baseUrl}/api/workspace/search`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query: args.query, limit: 10 }),
+        })
+        data = await res.json()
+        break
+      }
+      case "tasks": {
+        const res = await fetch(`${baseUrl}/api/workspace/tasks`)
+        data = await res.json()
+        break
+      }
+      case "task-detail": {
+        const res = await fetch(`${baseUrl}/api/workspace/tasks/${args.taskId}`)
+        if (res.status === 404) return { output: formatOutput("error", { error: "Task not found" }, json), exitCode: 1 }
+        data = await res.json()
+        break
+      }
+      case "claim": {
+        const res = await fetch(`${baseUrl}/api/workspace/claim`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ description: args.description, session: args.session, branch: args.branch ?? null }),
+        })
+        if (res.status === 400) return { output: formatOutput("error", await res.json(), json), exitCode: 1 }
+        data = await res.json()
+        break
+      }
+      case "complete": {
+        const res = await fetch(`${baseUrl}/api/workspace/complete`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ taskId: args.taskId, outputs: [] }),
+        })
+        if (res.status === 404) return { output: formatOutput("error", { error: "Task not found" }, json), exitCode: 1 }
+        data = await res.json()
+        break
+      }
+      case "delegate": {
+        const res = await fetch(`${baseUrl}/api/workspace/delegate`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ request: args.request, workspaceId: args.workspaceId ?? "" }),
+        })
+        data = await res.json()
+        break
+      }
+      default:
+        return { output: getHelpText(), exitCode: 1 }
+    }
+    return { output: formatOutput(parsed.command, data, json), exitCode: 0 }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    return { output: JSON.stringify({ error: message, code: 2 }), exitCode: 2 }
+  }
+}

package/src/server/provider-catalog.test.ts

@@ -0,0 +1,177 @@
+import { describe, expect, test } from "bun:test"
+import {
+  codexServiceTierFromModelOptions,
+  normalizeClaudeModelOptions,
+  normalizeCodexModelOptions,
+  normalizeServerModel,
+  deriveServerProviderCatalog,
+  SERVER_PROVIDERS,
+} from "./provider-catalog"
+import { resolveClaudeApiModelId } from "../shared/types"
+import type { RuntimeCapabilities, DiscoveredModel } from "../shared/runtime-types"
+
+describe("provider catalog normalization", () => {
+  test("maps legacy Claude effort into shared model options", () => {
+    expect(normalizeClaudeModelOptions("opus", undefined, "max")).toEqual({
+      reasoningEffort: "max",
+      contextWindow: "200k",
+    })
+  })
+
+  test("normalizes Claude context window only for supported models", () => {
+    expect(normalizeClaudeModelOptions("sonnet", {
+      claude: {
+        reasoningEffort: "medium",
+        contextWindow: "1m",
+      },
+    })).toEqual({
+      reasoningEffort: "medium",
+      contextWindow: "1m",
+    })
+
+    expect(normalizeClaudeModelOptions("haiku", {
+      claude: {
+        reasoningEffort: "medium",
+        contextWindow: "1m",
+      },
+    })).toMatchObject({
+      reasoningEffort: "medium",
+    })
+  })
+
+  test("normalizes Codex model options and fast mode defaults", () => {
+    expect(normalizeCodexModelOptions(undefined)).toEqual({
+      reasoningEffort: "high",
+      fastMode: false,
+    })
+
+    const normalized = normalizeCodexModelOptions({
+      codex: {
+        reasoningEffort: "xhigh",
+        fastMode: true,
+      },
+    })
+
+    expect(normalized).toEqual({
+      reasoningEffort: "xhigh",
+      fastMode: true,
+    })
+    expect(codexServiceTierFromModelOptions(normalized)).toBe("fast")
+  })
+
+  test("resolves Claude API model ids for 1m context window", () => {
+    expect(resolveClaudeApiModelId("opus", "1m")).toBe("opus[1m]")
+    expect(resolveClaudeApiModelId("sonnet", "200k")).toBe("sonnet")
+  })
+})
+
+const DISCOVERED_MODELS: DiscoveredModel[] = [
+  {
+    value: "default",
+    displayName: "Default (recommended)",
+    description: "Opus 4.6 with 1M context",
+    supportsEffort: true,
+    supportedEffortLevels: ["low", "medium", "high", "max"],
+    supportsFastMode: true,
+    supportsAutoMode: true,
+  },
+  {
+    value: "sonnet",
+    displayName: "Sonnet",
+    description: "Sonnet 4.6 · Best for everyday tasks",
+    supportsEffort: true,
+    supportedEffortLevels: ["low", "medium", "high"],
+    supportsAutoMode: true,
+  },
+  {
+    value: "haiku",
+    displayName: "Haiku",
+    description: "Haiku 4.5 · Fastest for quick answers",
+  },
+]
+
+function makeCapabilities(models: DiscoveredModel[] = DISCOVERED_MODELS): RuntimeCapabilities {
+  return { models, probedAt: Date.now(), runtimeVersion: "1.0.0" }
+}
+
+describe("deriveServerProviderCatalog", () => {
+  test("returns static SERVER_PROVIDERS when no capabilities", () => {
+    const result = deriveServerProviderCatalog()
+    expect(result).toEqual(SERVER_PROVIDERS)
+  })
+
+  test("returns static SERVER_PROVIDERS when capabilities have empty models", () => {
+    const result = deriveServerProviderCatalog(makeCapabilities([]))
+    expect(result).toEqual(SERVER_PROVIDERS)
+  })
+
+  test("enriches static Claude models with discovered description and effort levels", () => {
+    const result = deriveServerProviderCatalog(makeCapabilities())
+    const claude = result.find((p) => p.id === "claude")!
+    const sonnet = claude.models.find((m) => m.id === "sonnet")!
+    expect(sonnet.description).toBe("Sonnet 4.6 · Best for everyday tasks")
+    expect(sonnet.supportedEffortLevels).toEqual(["low", "medium", "high"])
+  })
+
+  test("maps 'default' discovered model to static 'opus' entry", () => {
+    const result = deriveServerProviderCatalog(makeCapabilities())
+    const claude = result.find((p) => p.id === "claude")!
+    const opus = claude.models.find((m) => m.id === "opus")!
+    expect(opus.description).toBe("Opus 4.6 with 1M context")
+    expect(opus.supportedEffortLevels).toEqual(["low", "medium", "high", "max"])
+  })
+
+  test("appends discovered models not in static list", () => {
+    const extraModel: DiscoveredModel = {
+      value: "claude-opus-4-7",
+      displayName: "Opus 4",
+      description: "Newer version available",
+    }
+    const result = deriveServerProviderCatalog(makeCapabilities([...DISCOVERED_MODELS, extraModel]))
+    const claude = result.find((p) => p.id === "claude")!
+    const extra = claude.models.find((m) => m.id === "claude-opus-4-7")
+    expect(extra).toBeDefined()
+    expect(extra!.description).toBe("Newer version available")
+    expect(extra!.label).toBe("Opus 4")
+  })
+
+  test("preserves static model order — static first, discovered extras appended", () => {
+    const extraModel: DiscoveredModel = {
+      value: "claude-opus-4-7",
+      displayName: "Opus 4",
+      description: "Newer version",
+    }
+    const result = deriveServerProviderCatalog(makeCapabilities([...DISCOVERED_MODELS, extraModel]))
+    const claude = result.find((p) => p.id === "claude")!
+    const ids = claude.models.map((m) => m.id)
+    expect(ids).toEqual(["opus", "sonnet", "haiku", "claude-opus-4-7"])
+  })
+
+  test("codex is always static regardless of capabilities", () => {
+    const result = deriveServerProviderCatalog(makeCapabilities())
+    const codex = result.find((p) => p.id === "codex")!
+    const staticCodex = SERVER_PROVIDERS.find((p) => p.id === "codex")!
+    expect(codex).toEqual(staticCodex)
+  })
+})
+
+describe("normalizeServerModel with dynamic catalog", () => {
+  test("accepts full model id when present in dynamic catalog", () => {
+    const extraModel: DiscoveredModel = {
+      value: "claude-opus-4-7",
+      displayName: "Opus 4",
+      description: "Newer version",
+    }
+    const catalog = deriveServerProviderCatalog(makeCapabilities([...DISCOVERED_MODELS, extraModel]))
+    expect(normalizeServerModel("claude", "claude-opus-4-7", catalog)).toBe("claude-opus-4-7")
+  })
+
+  test("falls back to default model when model not in catalog", () => {
+    const catalog = deriveServerProviderCatalog(makeCapabilities())
+    expect(normalizeServerModel("claude", "nonexistent", catalog)).toBe("sonnet")
+  })
+
+  test("uses static catalog by default (backward compat)", () => {
+    expect(normalizeServerModel("claude", "sonnet")).toBe("sonnet")
+  })
+})