privateer-agent 0.12.56 → 0.12.58

package/extensions/privateer-gate.ts

@@ -491,11 +491,25 @@ const approveInAppMs = isSubagentChild() ? 0 : Number(process.env.PRIVATEER_APPR
 // anything, and media.ts has no business in the TUI's startup graph.
 async function quoteMediaCall(tool: string, input: unknown, signal?: AbortSignal): Promise<number | null> {
   const { readMediaCapabilities, quoteMediaCallUsd } = await import("../src/tools/media.ts");
+  const { effectiveMediaModel } = await import("../src/config/mediaModels.ts");
   const a = (input && typeof input === "object" ? input : {}) as Record<string, unknown>;
-  const model = typeof a.model === "string" && a.model ? a.model : undefined;
-  const query = tool === "generate_video" || tool === "generate_sprite" ? { videoModel: model } : tool === "generate_model" ? { model } : {};
+  // Price the model the tool will actually SEND — its own `model`, else this machine's
+  // /image-model or /video-model choice — not the account default it would fall past.
+  let priced = a;
+  let query: { imageModel?: string; videoModel?: string; model?: string } = {};
+  if (tool === "generate_image") {
+    const imageModel = effectiveMediaModel("image", a.model);
+    priced = { ...a, model: imageModel };
+    query = { imageModel };
+  } else if (tool === "generate_video" || tool === "generate_sprite") {
+    const imageModel = tool === "generate_sprite" ? effectiveMediaModel("image", a.image_model) : undefined;
+    priced = tool === "generate_sprite" ? { ...a, image_model: imageModel } : a;
+    query = { videoModel: effectiveMediaModel("video", a.model), imageModel };
+  } else if (tool === "generate_model") {
+    query = { model: typeof a.model === "string" && a.model ? a.model : undefined };
+  }
   const caps = await readMediaCapabilities(query, signal);
-  return caps.ok ? quoteMediaCallUsd(tool, input, caps.data) : null;
+  return caps.ok ? quoteMediaCallUsd(tool, priced, caps.data) : null;
 }
 
 const cliLedger = cliGrant ? new CliSpendLedger(cliGrant, quoteMediaCall) : null;

package/extensions/privateer-media.ts

@@ -20,14 +20,20 @@
 // already on disk — no account, no network, no spend — so it stays useful to a
 // signed-out terminal, and to a child whose job is to cut together what its parent
 // generated.
+//
+// /image-model and /video-model are registered unconditionally too: they only write a
+// local preference, and a signed-out terminal is told to /login when it opens the
+// picker rather than finding the command missing.
 import { makeMediaTools } from "../src/tools/media.ts";
 import { makeComposeTools } from "../src/tools/videoCompose.ts";
 import { mediaEnabled } from "../src/config/hosted.ts";
 import { childHoldsSpendGrant } from "../src/permissions/childSpend.ts";
 import { isSubagentChild } from "../src/remote/subagentRelay.ts";
+import { registerMediaModelCommands } from "../src/tools/mediaModelCommands.ts";
 
 export default function privateerMedia(pi: any): void {
   const canSpend = !isSubagentChild() || childHoldsSpendGrant();
   if (mediaEnabled() && canSpend) makeMediaTools()(pi);
   makeComposeTools()(pi);
+  registerMediaModelCommands(pi);
 }

package/extensions/privateer-speak.ts

@@ -32,17 +32,39 @@
 // gates on hasUI, so harbor/daemon/ACP surfaces stay silent by design (this extension is
 // manifest-only, like privateer-hints: buildMoat never includes it).
 //
-// VOICES. qwen3-tts speakers, mirrored from the server's TINFOIL_VOICES (the list is
-// static there too; first entry is the server-side default). Tinfoil requires the voice
-// param server-side, so the server applies "serena" when none is sent — leaving voice
-// unset here is always safe. If the account's default TTS model ever changes, update
-// this list with it.
+// VOICES. Every TTS model the account can reach, each with the voices it really offers,
+// comes from GET /api/agent/media/capabilities: its `speech.catalog` lists the models
+// (name, provider, confidential or not, blocked by the account's ZDR setting or not),
+// and `?ttsModel=<id>` returns one model's exact voice ids. Models blocked by the
+// account's privacy setting are left out rather than offered to fail. Each voice is
+// described in the app's words (speak-voices.data.ts, generated from the app's sourced
+// table) and can be heard through /api/audio/voice-preview, which serves a fixed
+// sentence from a cache shared across accounts: after the first listen, free.
+//
+// The account default (qwen3-tts, confidential) stays the default: a voice on it saves
+// no model, so a change of default on the server carries users along. Picking a voice
+// on another model saves that model, and it's sent as ttsModelId.
+//
+// Signed out, or the catalog unreachable: the qwen3-tts speakers below, so the picker
+// is never empty. Tinfoil requires a voice server-side and applies "serena" when none is
+// sent, so leaving voice unset is always safe.
 import { join } from "node:path";
-import { makePiSpeakExtension, registerSpeechProvider, registerTranscriptionProvider } from "privateer-speak";
+import {
+  kokoroVoice,
+  languageName,
+  makePiSpeakExtension,
+  registerSpeechProvider,
+  registerTranscriptionProvider,
+  type SpeechAudio,
+  type TranscriptionModelInfo,
+  type VoiceInfo,
+} from "privateer-speak";
 import { apiRequest, hasCredentials } from "../src/auth/privateer.ts";
 import { globalDir } from "../src/config/paths.ts";
+import { VOICE_DESCRIPTIONS } from "./speak-voices.data.ts";
 
 const QWEN3_TTS_VOICES = ["serena", "aiden", "dylan", "eric", "ono_anna", "ryan", "sohee", "uncle_fu", "vivian"];
+const DEFAULT_MODEL = "qwen3-tts";
 
 // Call an account audio endpoint and hand back the parsed JSON, throwing the server's
 // own (person-readable, localized) message on failure — same policy as media.ts's
@@ -72,18 +94,163 @@ async function accountJson<T>(path: string, body: unknown, signal?: AbortSignal)
   return (await res.json()) as T;
 }
 
+// ── the voice catalog ───────────────────────────────────────────────────────
+
+/**
+ * The language a voice speaks, when its id or its maker says so. Same rules as the
+ * app's voiceLabels.ts: Voxtral's `de_male` / `en_paul_sad`, Aura-2's trailing code,
+ * MAI's leading tag, Kokoro's first letter, and Qwen's published native languages.
+ */
+const VOXTRAL_LANGUAGES = new Set(["ar", "de", "es", "fr", "hi", "it", "nl", "pt"]);
+const ENGLISH_STYLES = new Set(["neutral", "casual", "cheerful", "american", "british"]);
+const KOKORO_LANGUAGES: Record<string, string> = { a: "en-US", b: "en-GB", e: "es", f: "fr", h: "hi", i: "it", j: "ja", p: "pt-BR", z: "zh" };
+const QWEN_NATIVE: Record<string, string> = {
+  serena: "zh", vivian: "zh", uncle_fu: "zh", dylan: "zh", eric: "zh", ryan: "en", aiden: "en", ono_anna: "ja", sohee: "ko",
+};
+
+export function voiceLanguage(id: string): string | undefined {
+  const two = /^([a-z]+)_(female|male)$/.exec(id);
+  if (two) {
+    if (VOXTRAL_LANGUAGES.has(two[1]!)) return languageName(two[1]!);
+    if (ENGLISH_STYLES.has(two[1]!)) return "English";
+  }
+  const kokoro = /^([abefhijpz])[fm]_/.exec(id);
+  if (kokoro) return languageName(KOKORO_LANGUAGES[kokoro[1]!]!);
+  const styled = /^([a-z]{2})_[a-z]+_[a-z]+$/.exec(id);
+  if (styled && (styled[1] === "en" || VOXTRAL_LANGUAGES.has(styled[1]!))) return languageName(styled[1]!);
+  const aura = /^(?:aura-2|flux)-.+-([a-z]{2})$/.exec(id);
+  if (aura) return languageName(aura[1]!);
+  const mai = /^([a-z]{2}-[A-Z]{2})-[^:]+:/.exec(id);
+  if (mai) return languageName(mai[1]!);
+  return QWEN_NATIVE[id] ? languageName(QWEN_NATIVE[id]!) : undefined;
+}
+
+/** A readable name for ids that are really slugs: "aura-2-thalia-en" → "Thalia". */
+function displayName(id: string): string | undefined {
+  const aura = /^(?:aura-2|flux)-(.+)-[a-z]{2}$/.exec(id);
+  if (aura) return aura[1]!.charAt(0).toUpperCase() + aura[1]!.slice(1);
+  const mai = /^[a-z]{2}-[A-Z]{2}-([^:]+):/.exec(id);
+  return mai?.[1];
+}
+
+interface CatalogModel {
+  id: string;
+  name?: string;
+  provider?: string;
+  isZdr?: boolean;
+  isTee?: boolean;
+  blockedByZdr?: boolean;
+  voiceCount?: number;
+}
+interface SpeechCapabilities {
+  speech?: { model?: string; voices?: string[]; catalog?: CatalogModel[] };
+}
+
+const CLIP_FORMATS: Record<string, SpeechAudio["format"]> = {
+  "audio/mpeg": "mp3",
+  "audio/mp3": "mp3",
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/ogg": "ogg",
+};
+
+/** A voice as the picker shows it: described, with its language, model and a sample. */
+function voiceInfo(id: string, model: CatalogModel | undefined, modelId: string): VoiceInfo {
+  // Kokoro's id states name and gender outright; the app's table adds the author's grade.
+  const kokoro = /^[abefhijpz][fm]_/.test(id) ? kokoroVoice(id, modelId) : undefined;
+  const description = kokoro?.description ?? VOICE_DESCRIPTIONS[id];
+  const language = voiceLanguage(id);
+  const name = kokoro?.name ?? displayName(id);
+  return {
+    id,
+    model: modelId,
+    ...(model?.name ? { modelName: model.name } : {}),
+    ...(name ? { name } : {}),
+    ...(description ? { description } : {}),
+    ...(language ? { language } : {}),
+    // The enclave is attested by Privateer's server, which then forwards the text: the
+    // shield says so ("TEE · attested by Privateer"), not that this terminal checked it.
+    ...(model
+      ? model.isTee
+        ? { privacy: "confidential" as const, attestedBy: "Privateer" }
+        : { privacy: model.isZdr ? ("zdr" as const) : ("standard" as const) }
+      : {}),
+    preview: async (signal?: AbortSignal): Promise<SpeechAudio> => {
+      const { audioBase64, mimeType } = await accountJson<{ audioBase64?: string; mimeType?: string }>(
+        "/api/audio/voice-preview",
+        { ttsModelId: modelId, voice: id, locale: "en" },
+        signal,
+      );
+      if (!audioBase64) throw new Error("Privateer returned no sample");
+      return { data: Buffer.from(audioBase64, "base64"), format: CLIP_FORMATS[mimeType ?? ""] ?? "mp3" };
+    },
+  };
+}
+
+async function capabilities(ttsModel?: string): Promise<SpeechCapabilities> {
+  const res = await apiRequest(`/api/agent/media/capabilities${ttsModel ? `?ttsModel=${encodeURIComponent(ttsModel)}` : ""}`, {
+    method: "GET",
+    signal: AbortSignal.timeout(10_000),
+  });
+  if (!res.ok) throw new Error(`Privateer returned ${res.status}`);
+  return (await res.json()) as SpeechCapabilities;
+}
+
+// Read once per session: the catalog changes on deploys, not between keypresses.
+let catalog: Promise<VoiceInfo[]> | undefined;
+let accountDefault: string | undefined;
+
+function loadCatalog(): Promise<VoiceInfo[]> {
+  return (catalog ??= (async () => {
+    const top = await capabilities();
+    accountDefault = top.speech?.model;
+    const models = (top.speech?.catalog ?? []).filter((m) => !m.blockedByZdr);
+    // The default model first, then the rest as the server sorts them.
+    models.sort((a, b) => Number(b.id === accountDefault) - Number(a.id === accountDefault));
+    const lists = await Promise.all(
+      models.map(async (m) => {
+        const ids = m.id === accountDefault ? (top.speech?.voices ?? []) : m.voiceCount ? ((await capabilities(m.id).catch(() => ({}))) as SpeechCapabilities).speech?.voices ?? [] : [];
+        // A model whose voices are prose, not a list: its default voice is still usable.
+        return ids.length ? ids.map((id) => voiceInfo(id, m, m.id)) : [{ ...voiceInfo("", m, m.id), name: "default voice", preview: undefined }];
+      }),
+    );
+    return lists.flat();
+  })().catch((e) => {
+    catalog = undefined; // try again next time the picker opens
+    throw e;
+  }));
+}
+
+const fallbackVoices = (): VoiceInfo[] =>
+  QWEN3_TTS_VOICES.map((id) => ({
+    ...voiceInfo(id, undefined, DEFAULT_MODEL),
+    modelName: "Qwen3 TTS",
+    privacy: "confidential" as const,
+    attestedBy: "Privateer",
+  }));
+
 registerSpeechProvider(
   {
     id: "privateer",
-    label: "Privateer account TTS (attested enclave)",
+    label: "Privateer",
     privacy: "confidential",
+    attestedBy: "Privateer",
     defaultVoice: QWEN3_TTS_VOICES[0],
-    voices: () => QWEN3_TTS_VOICES,
+    model: () => accountDefault ?? DEFAULT_MODEL,
+    voices: async () => {
+      if (!hasCredentials()) return fallbackVoices();
+      try {
+        const voices = await loadCatalog();
+        return voices.length ? voices : fallbackVoices();
+      } catch {
+        return fallbackVoices();
+      }
+    },
     available: () => hasCredentials(),
-    fetchSpeech: async (text, { voice, signal }) => {
+    fetchSpeech: async (text, { voice, model, signal }) => {
       const { audioBase64 } = await accountJson<{ audioBase64?: string }>(
         "/api/audio/speech",
-        { text, ...(voice ? { voice } : {}) },
+        { text, ...(voice ? { voice } : {}), ...(model ? { ttsModelId: model } : {}) },
         signal,
       );
       if (!audioBase64) throw new Error("Privateer returned no audio");
@@ -93,18 +260,85 @@ registerSpeechProvider(
   { preferWhen: () => hasCredentials() },
 );
 
+// ── transcription models ────────────────────────────────────────────────────
+//
+// The account's STT catalog is GET /api/models/openrouter?action=stt: OpenRouter's
+// ZDR-covered transcription models plus the NEAR AI and Tinfoil enclave ones, each with
+// isTee / isZdr. A model id goes back as sttModelId.
+//
+// THE DEFAULT IS ASKED FOR BY NAME. The server's own default (DEFAULT_STT_MODEL) is a
+// deployment setting and today an OpenRouter ZDR model, not an enclave, so sending no
+// model would let this provider's "confidential" badge describe something it doesn't
+// control. Unless you pick otherwise, transcription asks for Tinfoil's enclave Whisper.
+const CONFIDENTIAL_STT = "tinfoil/whisper-large-v3-turbo";
+
+interface SttCatalogModel {
+  id: string;
+  name?: string;
+  description?: string;
+  isTee?: boolean;
+  isZdr?: boolean;
+}
+
+/** The catalog's first sentence, short enough for a row. */
+function oneLine(text: string | undefined): string | undefined {
+  const first = text?.split(/(?<=\.)\s/)[0]?.trim().replace(/\.$/, "");
+  if (!first) return undefined;
+  return first.length > 90 ? `${first.slice(0, 89)}…` : first;
+}
+
+let sttCatalog: Promise<TranscriptionModelInfo[]> | undefined;
+function loadSttCatalog(): Promise<TranscriptionModelInfo[]> {
+  return (sttCatalog ??= (async () => {
+    const res = await apiRequest("/api/models/openrouter?action=stt", { method: "GET", signal: AbortSignal.timeout(10_000) });
+    if (!res.ok) throw new Error(`Privateer returned ${res.status}`);
+    const { models = [] } = (await res.json()) as { models?: SttCatalogModel[] };
+    const described = models.map((m): TranscriptionModelInfo => {
+      const about = oneLine(m.description);
+      return {
+        id: m.id,
+        ...(m.name ? { name: m.name } : {}),
+        ...(about ? { description: about } : {}),
+        ...(m.isTee
+          ? { privacy: "confidential" as const, attestedBy: "Privateer" }
+          : { privacy: m.isZdr ? ("zdr" as const) : ("standard" as const) }),
+      };
+    });
+    // Enclave models first: they're what the default is and what the badge promises.
+    return described.sort((a, b) => Number(b.privacy === "confidential") - Number(a.privacy === "confidential"));
+  })().catch((e) => {
+    sttCatalog = undefined;
+    throw e;
+  }));
+}
+
 registerTranscriptionProvider(
   {
     id: "privateer",
-    label: "Privateer account STT (attested enclave)",
+    label: "Privateer",
     privacy: "confidential",
+    attestedBy: "Privateer",
+    defaultModel: () => CONFIDENTIAL_STT,
+    models: async () => {
+      const fallback: TranscriptionModelInfo[] = [
+        { id: CONFIDENTIAL_STT, name: "Whisper Large v3 Turbo", privacy: "confidential", attestedBy: "Privateer" },
+      ];
+      if (!hasCredentials()) return fallback;
+      try {
+        const models = await loadSttCatalog();
+        return models.length ? models : fallback;
+      } catch {
+        return fallback;
+      }
+    },
     available: () => hasCredentials(),
-    transcribe: async (audio, { language, signal }) => {
+    transcribe: async (audio, { language, model, signal }) => {
       const { text } = await accountJson<{ text?: string }>(
         "/api/audio/transcribe",
         {
           audioBase64: Buffer.from(audio.data).toString("base64"),
           format: audio.format,
+          sttModelId: model ?? CONFIDENTIAL_STT,
           ...(language ? { language } : {}),
         },
         signal,

package/extensions/speak-voices.data.ts

@@ -0,0 +1,206 @@
+// GENERATED by scripts/gen-speak-voices.mjs from the Privateer app's voiceProfiles.ts.
+// Do not edit by hand: change the app's table and regenerate. Every entry is the
+// provider's own published description of the voice (see that file's sources).
+export const VOICE_DESCRIPTIONS: Readonly<Record<string, string>> = {
+  "aura-2-amalthea-en": "female · young · Filipino · engaging, natural, cheerful · for casual chat",
+  "aura-2-andromeda-en": "female · adult · American · casual, expressive, comfortable · for customer service, phone menus",
+  "aura-2-apollo-en": "male · adult · American · confident, comfortable, casual · for casual chat",
+  "aura-2-arcas-en": "male · adult · American · natural, smooth, clear, comfortable · for customer service, casual chat",
+  "aura-2-aries-en": "male · adult · American · warm, energetic, caring · for casual chat",
+  "aura-2-asteria-en": "female · adult · American · clear, confident, knowledgeable, energetic · for advertising",
+  "aura-2-athena-en": "female · mature · American · calm, smooth, professional · for storytelling",
+  "aura-2-atlas-en": "male · mature · American · enthusiastic, confident, approachable, friendly · for advertising",
+  "aura-2-aurora-en": "female · adult · American · cheerful, expressive, energetic · for interview",
+  "aura-2-callista-en": "female · adult · American · clear, energetic, professional, smooth · for phone menus",
+  "aura-2-cora-en": "female · adult · American · smooth, melodic, caring · for storytelling",
+  "aura-2-cordelia-en": "female · young · American · approachable, warm, polite · for storytelling",
+  "aura-2-delia-en": "female · young · American · casual, friendly, cheerful, breathy · for interview",
+  "aura-2-draco-en": "male · adult · British · warm, approachable, trustworthy, baritone · for storytelling",
+  "aura-2-electra-en": "female · adult · American · professional, engaging, knowledgeable · for phone menus, advertising, customer service",
+  "aura-2-harmonia-en": "female · adult · American · empathetic, clear, calm, confident · for customer service",
+  "aura-2-helena-en": "female · adult · American · caring, natural, positive, friendly, raspy · for phone menus, casual chat",
+  "aura-2-hera-en": "female · adult · American · smooth, warm, professional · for informative",
+  "aura-2-hermes-en": "male · adult · American · expressive, engaging, professional · for informative",
+  "aura-2-hyperion-en": "male · adult · Australian · caring, warm, empathetic · for interview",
+  "aura-2-iris-en": "female · young · American · cheerful, positive, approachable · for phone menus, advertising, customer service",
+  "aura-2-janus-en": "female · adult · American · southern, smooth, trustworthy · for storytelling",
+  "aura-2-juno-en": "female · adult · American · natural, engaging, melodic, breathy · for interview",
+  "aura-2-jupiter-en": "male · adult · American · expressive, knowledgeable, baritone · for informative",
+  "aura-2-luna-en": "female · young · American · friendly, natural, engaging · for phone menus",
+  "aura-2-mars-en": "male · adult · American · smooth, patient, trustworthy, baritone · for customer service",
+  "aura-2-minerva-en": "female · adult · American · positive, friendly, natural · for storytelling",
+  "aura-2-neptune-en": "male · adult · American · professional, patient, polite · for customer service",
+  "aura-2-odysseus-en": "male · adult · American · calm, smooth, comfortable, professional · for advertising",
+  "aura-2-ophelia-en": "female · adult · American · expressive, enthusiastic, cheerful · for interview",
+  "aura-2-orion-en": "male · adult · American · approachable, comfortable, calm, polite · for informative",
+  "aura-2-orpheus-en": "male · adult · American · professional, clear, confident, trustworthy · for customer service, storytelling",
+  "aura-2-pandora-en": "female · adult · British · smooth, calm, melodic, breathy · for phone menus, informative",
+  "aura-2-phoebe-en": "female · adult · American · energetic, warm, casual · for customer service",
+  "aura-2-pluto-en": "male · adult · American · smooth, calm, empathetic, baritone · for interview, storytelling",
+  "aura-2-saturn-en": "male · adult · American · knowledgeable, confident, baritone · for customer service",
+  "aura-2-selene-en": "female · adult · American · expressive, engaging, energetic · for informative",
+  "aura-2-thalia-en": "female · adult · American · clear, confident, energetic, enthusiastic · for casual chat, customer service, phone menus",
+  "aura-2-theia-en": "female · adult · Australian · expressive, polite, sincere · for informative",
+  "aura-2-vesta-en": "female · adult · American · natural, expressive, patient, empathetic · for customer service, interview, storytelling",
+  "aura-2-zeus-en": "male · adult · American · deep, trustworthy, smooth · for phone menus",
+  "aura-2-agustina-es": "female · adult · Peninsular · calm, clear, expressive, knowledgeable, professional · for interview, casual chat",
+  "aura-2-alvaro-es": "male · adult · Peninsular · calm, professional, clear, knowledgeable, approachable · for interview, customer service",
+  "aura-2-antonia-es": "female · adult · Argentine · approachable, enthusiastic, friendly, natural, professional · for customer service, interview, casual chat",
+  "aura-2-aquila-es": "male · adult · Latin American · expressive, enthusiastic, confident, casual, comfortable · for casual chat, informative",
+  "aura-2-carina-es": "female · adult · Peninsular · professional, raspy, energetic, breathy, confident · for interview, customer service, phone menus",
+  "aura-2-celeste-es": "female · young · Colombian · clear, energetic, positive, friendly, enthusiastic · for casual chat, advertising, phone menus",
+  "aura-2-diana-es": "female · adult · Peninsular · professional, confident, expressive, polite, knowledgeable · for storytelling, advertising",
+  "aura-2-estrella-es": "female · mature · Mexican · approachable, natural, calm, comfortable, expressive · for casual chat, interview",
+  "aura-2-gloria-es": "female · young · Colombian · casual, clear, expressive, natural, smooth · for customer service, casual chat",
+  "aura-2-javier-es": "male · adult · Mexican · approachable, professional, friendly, comfortable, calm · for casual chat, phone menus, storytelling",
+  "aura-2-luciano-es": "male · adult · Mexican · charismatic, cheerful, energetic, expressive, friendly · for customer service, casual chat",
+  "aura-2-nestor-es": "male · adult · Peninsular · calm, professional, approachable, clear, confident · for casual chat, customer service",
+  "aura-2-olivia-es": "female · adult · Mexican · breathy, calm, casual, expressive, warm · for customer service, casual chat",
+  "aura-2-selena-es": "female · young · Latin American · approachable, casual, friendly, calm, positive · for customer service, informative",
+  "aura-2-silvia-es": "female · adult · Peninsular · charismatic, clear, expressive, natural, warm · for customer service, casual chat",
+  "aura-2-sirio-es": "male · adult · Mexican · calm, professional, comfortable, empathetic, baritone · for casual chat, interview",
+  "aura-2-valerio-es": "male · adult · Mexican · deep, knowledgeable, natural, polite, professional · for customer service, informative",
+  "aura-2-beatrix-nl": "female · adult · cheerful, enthusiastic, friendly, trustworthy, warm · for customer service",
+  "aura-2-cornelia-nl": "female · adult · approachable, friendly, polite, positive, warm · for customer service",
+  "aura-2-daphne-nl": "female · adult · calm, clear, confident, professional, smooth · for healthcare, interview, casual chat, audiobook",
+  "aura-2-hestia-nl": "female · adult · approachable, caring, expressive, friendly, knowledgeable · for customer service",
+  "aura-2-lars-nl": "male · adult · breathy, casual, comfortable, sincere, trustworthy · for customer service",
+  "aura-2-leda-nl": "female · adult · caring, comfortable, empathetic, friendly, sincere · for sales",
+  "aura-2-rhea-nl": "female · adult · caring, knowledgeable, positive, smooth, warm · for customer service",
+  "aura-2-roman-nl": "male · adult · calm, casual, deep, natural, patient · for customer service",
+  "aura-2-sander-nl": "male · adult · calm, clear, deep, professional, smooth · for customer service",
+  "aura-2-agathe-fr": "female · adult · charismatic, cheerful, enthusiastic, friendly, natural · for customer service",
+  "aura-2-hector-fr": "male · adult · confident, empathetic, expressive, friendly, patient · for customer service",
+  "aura-2-aurelia-de": "female · young · approachable, casual, comfortable, natural, sincere · for healthcare, customer service, sales, financial services",
+  "aura-2-elara-de": "female · adult · calm, clear, natural, patient, trustworthy · for healthcare, customer service, sales, financial services",
+  "aura-2-fabian-de": "male · mature · confident, knowledgeable, natural, polite, professional · for healthcare, customer service, sales, financial services",
+  "aura-2-julius-de": "male · adult · casual, cheerful, engaging, expressive, friendly · for healthcare, customer service, sales, financial services",
+  "aura-2-kara-de": "female · young · caring, empathetic, expressive, professional, warm · for healthcare, customer service, sales, financial services",
+  "aura-2-lara-de": "female · young · caring, cheerful, empathetic, expressive, warm · for healthcare, customer service, sales, financial services",
+  "aura-2-viktoria-de": "female · adult · charismatic, cheerful, enthusiastic, friendly, warm · for healthcare, customer service, sales, financial services",
+  "aura-2-cesare-it": "male · adult · clear, empathetic, knowledgeable, natural, smooth · for casual chat, customer service, interview, phone menus",
+  "aura-2-cinzia-it": "female · mature · approachable, friendly, smooth, trustworthy, warm · for customer service, interview, narration",
+  "aura-2-demetra-it": "female · adult · calm, comfortable, patient · for casual chat, interview, narration",
+  "aura-2-dionisio-it": "male · adult · confident, engaging, friendly, melodic, positive · for interview, casual chat, customer service",
+  "aura-2-elio-it": "male · adult · breathy, calm, professional, smooth, trustworthy · for interview, casual chat, customer service",
+  "aura-2-flavio-it": "male · adult · confident, deep, empathetic, professional, trustworthy · for casual chat, interview, customer service",
+  "aura-2-livia-it": "female · adult · approachable, cheerful, clear, engaging, expressive · for customer service, interview, audiobook",
+  "aura-2-maia-it": "female · young · caring, energetic, expressive, professional, warm · for interview, casual chat, customer service",
+  "aura-2-melia-it": "female · adult · clear, comfortable, engaging, friendly, natural · for casual chat, customer service, interview",
+  "aura-2-ama-ja": "female · adult · casual, comfortable, confident, knowledgeable, natural · for interview, phone menus",
+  "aura-2-ebisu-ja": "male · young · calm, deep, natural, patient, sincere · for casual chat, customer service",
+  "aura-2-fujin-ja": "male · adult · calm, confident, knowledgeable, professional, smooth · for interview, casual chat, phone menus",
+  "aura-2-izanami-ja": "female · adult · approachable, clear, knowledgeable, polite, professional · for casual chat, customer service, interview, phone menus",
+  "aura-2-uzume-ja": "female · young · approachable, clear, polite, professional, trustworthy · for customer service, interview, phone menus, commercial",
+  "Zephyr": "bright",
+  "Puck": "upbeat",
+  "Charon": "informative",
+  "Kore": "firm",
+  "Fenrir": "excitable",
+  "Leda": "youthful",
+  "Orus": "firm",
+  "Aoede": "breezy",
+  "Callirrhoe": "easy-going",
+  "Autonoe": "bright",
+  "Enceladus": "breathy",
+  "Iapetus": "clear",
+  "Umbriel": "easy-going",
+  "Algieba": "smooth",
+  "Despina": "smooth",
+  "Erinome": "clear",
+  "Algenib": "gravelly",
+  "Rasalgethi": "informative",
+  "Laomedeia": "upbeat",
+  "Achernar": "soft",
+  "Alnilam": "firm",
+  "Schedar": "even",
+  "Gacrux": "mature",
+  "Pulcherrima": "forward",
+  "Achird": "friendly",
+  "Zubenelgenubi": "casual",
+  "Vindemiatrix": "gentle",
+  "Sadachbia": "lively",
+  "Sadaltager": "knowledgeable",
+  "Sulafat": "warm",
+  "Rachel": "female · young · American · calm · for narration",
+  "Sarah": "female · young · American · confident, warm, professional · for news",
+  "Laura": "female · young · American · sunny, quirky, upbeat · for social media",
+  "Charlie": "male · young · Australian · confident, energetic, natural · for casual chat",
+  "George": "male · adult · British · calm, resonant, warm · for audiobook, narration",
+  "Callum": "male · adult · Transatlantic · gravelly, intense · for characters",
+  "River": "neutral · adult · American · relaxed · for narration, casual chat",
+  "Liam": "male · young · American · warm, energetic · for social media",
+  "Charlotte": "female · young · Swedish · sensual, raspy · for characters",
+  "Alice": "female · adult · British · clear, engaging · for e-learning",
+  "Matilda": "female · adult · American · professional, warm · for narration",
+  "Will": "male · young · American · friendly · for social media",
+  "Jessica": "female · young · American · playful, expressive · for casual chat",
+  "Eric": "male · adult · American · smooth · for casual chat",
+  "Chris": "male · adult · American · natural, down-to-earth · for casual chat",
+  "Brian": "male · adult · American · resonant, comforting, deep · for narration",
+  "Daniel": "male · adult · British · authoritative, clear · for news",
+  "Lily": "female · adult · British · velvety, warm · for narration, news",
+  "Bill": "male · mature · American · friendly, comforting · for advertising",
+  "serena": "female · young · warm, gentle",
+  "vivian": "female · young · bright, edgy",
+  "ono_anna": "female · playful, light",
+  "uncle_fu": "male · mature · deep, mellow",
+  "dylan": "male · young · Beijing · clear, natural",
+  "eric": "male · Sichuan · lively, husky, bright",
+  "ryan": "male · dynamic, rhythmic",
+  "aiden": "male · American · sunny, clear",
+  "conversational_a": "for casual chat",
+  "conversational_b": "for casual chat",
+  "read_speech_a": "for narration",
+  "read_speech_b": "for narration",
+  "read_speech_c": "for narration",
+  "read_speech_d": "for narration",
+  "af_heart": "grade A",
+  "af_bella": "grade A-",
+  "af_nicole": "grade B-",
+  "bf_emma": "grade B-",
+  "ff_siwis": "grade B-",
+  "af_aoede": "grade C+",
+  "af_kore": "grade C+",
+  "af_sarah": "grade C+",
+  "am_fenrir": "grade C+",
+  "am_michael": "grade C+",
+  "am_puck": "grade C+",
+  "jf_alpha": "grade C+",
+  "af_alloy": "grade C",
+  "af_nova": "grade C",
+  "bf_isabella": "grade C",
+  "bm_fable": "grade C",
+  "bm_george": "grade C",
+  "hf_alpha": "grade C",
+  "hf_beta": "grade C",
+  "hm_omega": "grade C",
+  "hm_psi": "grade C",
+  "if_sara": "grade C",
+  "im_nicola": "grade C",
+  "jf_gongitsune": "grade C",
+  "jf_tebukuro": "grade C",
+  "af_sky": "grade C-",
+  "jf_nezumi": "grade C-",
+  "jm_kumo": "grade C-",
+  "bm_lewis": "grade D+",
+  "af_jessica": "grade D",
+  "af_river": "grade D",
+  "am_echo": "grade D",
+  "am_eric": "grade D",
+  "am_liam": "grade D",
+  "am_onyx": "grade D",
+  "bf_alice": "grade D",
+  "bf_lily": "grade D",
+  "bm_daniel": "grade D",
+  "zf_xiaobei": "grade D",
+  "zf_xiaoni": "grade D",
+  "zf_xiaoxiao": "grade D",
+  "zf_xiaoyi": "grade D",
+  "zm_yunjian": "grade D",
+  "zm_yunxi": "grade D",
+  "zm_yunxia": "grade D",
+  "zm_yunyang": "grade D",
+  "am_santa": "grade D-",
+  "am_adam": "grade F+",
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "privateer-agent",
-  "version": "0.12.56",
+  "version": "0.12.58",
   "description": "Privacy-first terminal coding agent — bring your own model across 20 providers (Anthropic, OpenAI, OpenRouter, Google, local Ollama…). Safe-by-default permissions, MCP, sub-agents, workflows, and verifiable TEE inference. Built on the Pi toolkit.",
   "type": "module",
   "license": "MIT",
@@ -86,7 +86,7 @@
     "pi-privacy": "0.14.1",
     "pi-subagents": "0.70.0",
     "picomatch": "4.0.5",
-    "privateer-speak": "0.5.0",
+    "privateer-speak": "0.6.0",
     "privateer-workflow": "0.1.0",
     "tinfoil": "1.1.11",
     "tsx": "4.23.0",

package/src/config/mediaModels.ts

@@ -0,0 +1,64 @@
+/**
+ * Which image and video models this machine's agent generates with, when the agent
+ * doesn't name one itself. Set by `/image-model` and `/video-model`
+ * (extensions/privateer-media.ts), stored as `media.imageModel` / `media.videoModel`
+ * in ~/.privateer/config.json.
+ *
+ * PER MACHINE, NOT PER ACCOUNT. The account already has a default for each (the app's
+ * own picker writes it, server-side), and that is what an unset value here falls through
+ * to. A terminal choice deliberately does not write back to it: picking a cheap video
+ * model for a batch of terminal drafts should not change what the phone renders with.
+ *
+ * PRECEDENCE, highest first: the tool call's own `model` → this file → the account
+ * default. The agent naming a model still wins, because it only does that when a job
+ * calls for a specific one (a 4K clip, a model that takes a last frame).
+ *
+ * Read at CALL time, like piiAllow.ts: a pick made in one terminal reaches a harbor or
+ * a second terminal on the same machine on its next generation, without a restart.
+ * Missing file, unreadable file and malformed JSON all mean "no choice" — the account
+ * default — never a crash in the middle of a tool call.
+ */
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { configPath } from "./paths.ts";
+
+export type MediaKind = "image" | "video";
+
+const KEY: Record<MediaKind, "imageModel" | "videoModel"> = { image: "imageModel", video: "videoModel" };
+
+function readConfig(): Record<string, unknown> {
+  try {
+    const cfg = JSON.parse(readFileSync(configPath(), "utf8"));
+    return cfg && typeof cfg === "object" && !Array.isArray(cfg) ? cfg : {};
+  } catch {
+    return {};
+  }
+}
+
+/** The chosen model id for `kind`, or undefined to use the account default. */
+export function mediaModelPref(kind: MediaKind): string | undefined {
+  const media = readConfig().media as Record<string, unknown> | undefined;
+  const v = media?.[KEY[kind]];
+  return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+
+/**
+ * Set (or, with null, clear) the choice for `kind`. Every other key in config.json is
+ * preserved — it also holds webhooks, privacy and coauthor settings this must not drop.
+ */
+export function setMediaModelPref(kind: MediaKind, id: string | null): void {
+  const cfg = readConfig();
+  const media = { ...((cfg.media as Record<string, unknown>) ?? {}) };
+  const clean = id?.trim();
+  if (clean) media[KEY[kind]] = clean;
+  else delete media[KEY[kind]];
+  const next: Record<string, unknown> = { ...cfg, media };
+  if (Object.keys(media).length === 0) delete next.media;
+  mkdirSync(dirname(configPath()), { recursive: true });
+  writeFileSync(configPath(), JSON.stringify(next, null, 2) + "\n");
+}
+
+/** The model a call should send: its own `model`, else this machine's choice, else none. */
+export function effectiveMediaModel(kind: MediaKind, requested: unknown): string | undefined {
+  return typeof requested === "string" && requested.trim() ? requested.trim() : mediaModelPref(kind);
+}

package/src/tools/media.ts

@@ -42,6 +42,7 @@ import { mkdirSync, readFileSync, writeFileSync, unlinkSync, existsSync, statSyn
 import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { tmpdir } from "node:os";
 import { apiRequest } from "../auth/privateer.ts";
+import { effectiveMediaModel } from "../config/mediaModels.ts";
 
 /** Tool names these definitions register, for allow-list construction. */
 export const MEDIA_TOOL_NAMES = [
@@ -280,7 +281,7 @@ export const generateImageToolDefinition = {
     count: Type.Optional(Type.Number({ description: "How many variations to produce, 1-4. Above 1, files are suffixed -1, -2, … Defaults to 1." })),
     aspectRatio: Type.Optional(Type.String({ description: "Aspect ratio, e.g. '16:9', '9:16', '1:1'. Defaults to the model's own." })),
     size: Type.Optional(Type.String({ description: "Explicit pixel size if the model supports one, e.g. '1024x1024'." })),
-    model: Type.Optional(Type.String({ description: "Override the account's image model (e.g. 'google/gemini-3.1-flash-image'). Leave unset to use the account default." })),
+    model: Type.Optional(Type.String({ description: "Override the image model (e.g. 'google/gemini-3.1-flash-image'). Leave unset to use the one the user chose with /image-model, or the account default." })),
   }),
   async execute(
     _toolCallId: string,
@@ -302,6 +303,7 @@ export const generateImageToolDefinition = {
     }
 
     const count = Math.min(Math.max(1, Math.round(params.count ?? 1)), 4);
+    const model = effectiveMediaModel("image", params.model);
     const r = await callAccount<ImageResponse>("/api/agent/media/images", {
       method: "POST",
       signal,
@@ -311,7 +313,7 @@ export const generateImageToolDefinition = {
         ...(inputs.length ? { images: inputs } : {}),
         ...(params.aspectRatio ? { aspectRatio: params.aspectRatio } : {}),
         ...(params.size ? { imageSize: params.size } : {}),
-        ...(params.model ? { model: params.model } : {}),
+        ...(model ? { model } : {}),
       },
     });
     if (!r.ok) return text(`Image generation failed: ${r.message}`);
@@ -381,7 +383,7 @@ export const generateVideoToolDefinition = {
     aspectRatio: Type.Optional(Type.String({ description: "Aspect ratio, e.g. '16:9', '9:16'. Model-specific." })),
     resolution: Type.Optional(Type.String({ description: "Resolution, e.g. '720p' or '1080p'." })),
     audio: Type.Optional(Type.Boolean({ description: "Ask the model to generate a soundtrack too, where it supports one. Costs more. Defaults to false." })),
-    model: Type.Optional(Type.String({ description: "Override the account's video model (e.g. 'google/veo-3.1-lite'). Leave unset to use the account default." })),
+    model: Type.Optional(Type.String({ description: "Override the video model (e.g. 'google/veo-3.1-lite'). Leave unset to use the one the user chose with /video-model, or the account default." })),
   }),
   async execute(
     _toolCallId: string,
@@ -417,6 +419,7 @@ export const generateVideoToolDefinition = {
       return text(`Error: ${e instanceof Error ? e.message : String(e)}`);
     }
 
+    const model = effectiveMediaModel("video", params.model);
     const submitted = await callAccount<VideoSubmitResponse>("/api/agent/media/videos", {
       method: "POST",
       signal,
@@ -426,7 +429,7 @@ export const generateVideoToolDefinition = {
         ...(params.aspectRatio ? { aspectRatio: params.aspectRatio } : {}),
         ...(params.resolution ? { resolution: params.resolution } : {}),
         ...(params.audio ? { generateAudio: true } : {}),
-        ...(params.model ? { model: params.model } : {}),
+        ...(model ? { model } : {}),
         ...(firstFrame ? { firstFrame } : {}),
         ...(lastFrame ? { lastFrame } : {}),
       },
@@ -1154,9 +1157,10 @@ export function quoteMediaCallUsd(tool: string, input: unknown, caps: Capabiliti
   };
   switch (tool) {
     case "generate_image": {
-      // The report prices the ACCOUNT's image model; a call naming another one would
-      // be quoted at the wrong model's rate, so it isn't quoted at all.
-      if (typeof args.model === "string" && args.model) return null;
+      // The report prices the image model it DESCRIBES; a call naming another one would
+      // be quoted at the wrong model's rate, so it isn't quoted at all. (A server that
+      // ignores `?imageModel=` describes the account default — a mismatch, so no quote.)
+      if (typeof args.model === "string" && args.model && args.model !== caps.image?.model) return null;
       const each = caps.image?.priceUsdEach;
       if (typeof each !== "number") return null;
       const n = Math.min(Math.max(Math.trunc(num(args.count) ?? 1), 1), caps.image?.maxPerCall ?? 4);
@@ -1176,7 +1180,7 @@ export function quoteMediaCallUsd(tool: string, input: unknown, caps: Capabiliti
       if (!row || clipUsd === null) return null;
       const stills = row.billedTurnStills ?? 0;
       const each = caps.image?.priceUsdEach;
-      if (stills > 0 && (typeof each !== "number" || (typeof args.image_model === "string" && args.image_model))) return null;
+      if (stills > 0 && (typeof each !== "number" || (typeof args.image_model === "string" && args.image_model && args.image_model !== caps.image?.model))) return null;
       return clipUsd * (row.billedClips ?? 1) + stills * (each ?? 0);
     }
     case "generate_sfx":
@@ -1189,12 +1193,13 @@ export function quoteMediaCallUsd(tool: string, input: unknown, caps: Capabiliti
   }
 }
 
-/** Read the capability report (optionally describing a specific video / 3D model). */
+/** Read the capability report (optionally describing a specific image / video / 3D model). */
 export async function readMediaCapabilities(
-  query: { videoModel?: string; model?: string } = {},
+  query: { imageModel?: string; videoModel?: string; model?: string } = {},
   signal?: AbortSignal,
 ): Promise<{ ok: true; data: CapabilitiesResponse } | { ok: false; message: string }> {
   const q = new URLSearchParams();
+  if (query.imageModel) q.set("imageModel", query.imageModel);
   if (query.videoModel) q.set("videoModel", query.videoModel);
   if (query.model) q.set("model", query.model);
   const qs = q.toString();
@@ -1293,10 +1298,17 @@ export const mediaCapabilitiesToolDefinition = {
           "their legal values and the price — is per-model.",
       }),
     ),
+    imageModel: Type.Optional(
+      Type.String({
+        description:
+          "An image model id to describe instead of the default (e.g. 'google/gemini-3.1-flash-image'), " +
+          "so the price per image is the one generate_image will charge for it.",
+      }),
+    ),
     videoModel: Type.Optional(
       Type.String({
         description:
-          "A video model id to describe instead of the account default (e.g. 'bytedance/seedance-2.0'). " +
+          "A video model id to describe instead of the default (e.g. 'bytedance/seedance-2.0'). " +
           "Clip lengths, aspect ratios and the price per clip are all per-model — check the one you will " +
           "pass as generate_video's `model` before you spend on it.",
       }),
@@ -1310,10 +1322,20 @@ export const mediaCapabilitiesToolDefinition = {
       }),
     ),
   }),
-  async execute(_toolCallId: string, params: { model?: string; ttsModel?: string; videoModel?: string }, signal?: AbortSignal) {
+  async execute(
+    _toolCallId: string,
+    params: { model?: string; ttsModel?: string; imageModel?: string; videoModel?: string },
+    signal?: AbortSignal,
+  ) {
+    // Unset means "the model generate_* would use", which is this machine's
+    // /image-model or /video-model choice before the account default — describing the
+    // account default instead would quote one model's price and clip lengths for another.
+    const imageModel = effectiveMediaModel("image", params?.imageModel);
+    const videoModel = effectiveMediaModel("video", params?.videoModel);
     const query = new URLSearchParams();
     if (params?.model) query.set("model", params.model);
-    if (params?.videoModel) query.set("videoModel", params.videoModel);
+    if (imageModel) query.set("imageModel", imageModel);
+    if (videoModel) query.set("videoModel", videoModel);
     if (params?.ttsModel) query.set("ttsModel", params.ttsModel);
     const qs = query.toString();
     const r = await callAccount<CapabilitiesResponse>(
@@ -1324,6 +1346,11 @@ export const mediaCapabilitiesToolDefinition = {
 
     const { image, video, model3d, sfx, speech, privacy } = r.data;
     const lines = describeImageVideo(image, video);
+    // An older server ignores `?imageModel=` and reports the account default; say so
+    // rather than let the agent read that model's price as the chosen one's.
+    if (imageModel && image?.model && image.model !== imageModel) {
+      lines.push(`  (generate_image will use ${imageModel}; this server described the account default instead)`);
+    }
 
     lines.push(...describeModel3d(model3d));
     lines.push(...describeSfx(sfx));
@@ -1773,13 +1800,13 @@ export const generateSpriteToolDefinition = {
       }),
     ),
     model: Type.Optional(
-      Type.String({ description: "Video model id to render the motion with. Omit for the account default." }),
+      Type.String({ description: "Video model id to render the motion with. Omit for the one chosen with /video-model, or the account default." }),
     ),
     image_model: Type.Optional(
       Type.String({
         description:
           "Image model id used to TURN the picture to face each direction, e.g. " +
-          "'google/gemini-3.1-flash-image'. Omit for the account default. Only used when " +
+          "'google/gemini-3.1-flash-image'. Omit for the one chosen with /image-model, or the account default. Only used when " +
           "`directions` is 'four' or 'eight' — 'one' renders no turns and never touches an image " +
           "model. Worth setting when a run fails with SPRITE_IMAGE_MODEL_UNAVAILABLE: that is the " +
           "image provider being down, not the request being wrong, and naming another model here " +
@@ -1859,8 +1886,8 @@ export const generateSpriteToolDefinition = {
             const guessed = guessResPath(cwd, params.dir);
             return guessed ? { res_path: guessed } : {};
           })()),
-        ...(params.model ? { model: params.model } : {}),
-        ...(params.image_model ? { image_model: params.image_model } : {}),
+        ...((m) => (m ? { model: m } : {}))(effectiveMediaModel("video", params.model)),
+        ...((m) => (m ? { image_model: m } : {}))(effectiveMediaModel("image", params.image_model)),
       },
     });
     if (!submitted.ok) return text(`Sprite generation failed: ${submitted.message}`);

package/src/tools/mediaModelCommands.ts

@@ -0,0 +1,175 @@
+// `/image-model` and `/video-model` — choose which model the media tools generate with
+// on this machine when the agent doesn't name one (see config/mediaModels.ts for where
+// the choice lives and why it is per machine rather than written to the account).
+//
+//   /image-model            open a picker over the account's live image catalog
+//   /image-model <id>       set it directly (checked against that catalog)
+//   /image-model default    clear it — back to the account default
+//
+// The catalog is the same list the app's own picker reads
+// (GET /api/models/openrouter?action=imageGen|videoGen), so the terminal can never
+// offer a model the account can't reach. Each row carries its privacy posture, because
+// a ZDR account choosing a non-ZDR model will have every generation refused — better
+// to see that in the picker than as a failed call later.
+import { apiRequest } from "../auth/privateer.ts";
+import { mediaModelPref, setMediaModelPref, type MediaKind } from "../config/mediaModels.ts";
+
+export interface CatalogModel {
+  id: string;
+  name?: string;
+  isZdr?: boolean;
+  isTee?: boolean;
+  supportedDurations?: number[] | null;
+  generateAudio?: boolean | null;
+  supportsImageToVideo?: boolean;
+}
+
+const ACTION: Record<MediaKind, string> = { image: "imageGen", video: "videoGen" };
+const RESET = new Set(["default", "reset", "clear", "none", "account"]);
+
+export async function fetchMediaCatalog(
+  kind: MediaKind,
+): Promise<{ ok: true; models: CatalogModel[] } | { ok: false; message: string }> {
+  let res: Response;
+  try {
+    res = await apiRequest(`/api/models/openrouter?action=${ACTION[kind]}`, { method: "GET" });
+  } catch (e) {
+    return { ok: false, message: `could not reach Privateer: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  if (!res.ok) {
+    if (res.status === 401) return { ok: false, message: "not signed in — run /login first" };
+    return { ok: false, message: `Privateer returned ${res.status}` };
+  }
+  try {
+    const body = (await res.json()) as { models?: CatalogModel[] };
+    // OpenRouter's auto routers ride along in the image-output list but pick a CHAT
+    // model per request — not something a generation can be pinned to.
+    const models = (body.models ?? []).filter(
+      (m) => m && typeof m.id === "string" && m.id && !m.id.startsWith("openrouter/"),
+    );
+    return { ok: true, models };
+  } catch {
+    return { ok: false, message: "Privateer returned a malformed model list" };
+  }
+}
+
+/** "3-15s" for a contiguous run of whole seconds, "5/10s" otherwise. Pure. */
+export function formatDurations(d: number[]): string {
+  const s = [...new Set(d)].sort((a, b) => a - b);
+  const contiguous = s.length > 2 && s.every((v, i) => i === 0 || v === s[i - 1] + 1);
+  return contiguous ? `${s[0]}-${s[s.length - 1]}s` : `${s.join("/")}s`;
+}
+
+/** One picker row: name, id, posture, and for video what the model can do. Pure. */
+export function describeCatalogRow(m: CatalogModel, kind: MediaKind, current?: string): string {
+  const posture = m.isTee ? "confidential" : m.isZdr ? "ZDR" : "non-ZDR";
+  const tags = [posture];
+  if (kind === "video") {
+    if (m.supportedDurations?.length) tags.push(formatDurations(m.supportedDurations));
+    if (m.supportsImageToVideo) tags.push("first frame");
+    if (m.generateAudio) tags.push("audio");
+  }
+  const name = m.name && m.name !== m.id ? `${m.name}  ` : "";
+  return `${m.id === current ? "● " : "  "}${name}${m.id}  (${tags.join(", ")})`;
+}
+
+const LABEL: Record<MediaKind, string> = { image: "Image", video: "Video" };
+
+function nonZdrWarning(m: CatalogModel | undefined): string {
+  return m && !m.isZdr && !m.isTee
+    ? " — non-ZDR: refused if this account requires Zero Data Retention for media (Settings → Privacy)"
+    : "";
+}
+
+interface Ui {
+  notify?: (msg: string, level?: string) => void;
+  select?: (title: string, options: string[]) => Promise<string | undefined>;
+}
+
+/**
+ * The whole command, minus registration — exported so tests can drive it with a fake
+ * ui and a stubbed catalog.
+ */
+export async function runMediaModelCommand(
+  kind: MediaKind,
+  args: string,
+  ui: Ui | undefined,
+  catalog: (kind: MediaKind) => ReturnType<typeof fetchMediaCatalog> = fetchMediaCatalog,
+): Promise<void> {
+  const say = (msg: string, level = "info") => ui?.notify?.(msg, level);
+  const label = LABEL[kind];
+  const current = mediaModelPref(kind);
+  const arg = String(args ?? "").trim();
+
+  if (RESET.has(arg.toLowerCase())) {
+    setMediaModelPref(kind, null);
+    say(`${label} model: account default${current ? ` (was ${current})` : ""}`);
+    return;
+  }
+
+  const list = await catalog(kind);
+
+  if (arg) {
+    // A typed id is checked against the live catalog when we can read it — a typo
+    // saved here would fail every later generation. When the catalog is unreachable
+    // it is saved anyway, with that said: the server still refuses an id it can't serve.
+    if (list.ok) {
+      const hit = list.models.find((m) => m.id === arg) ?? list.models.find((m) => m.id.toLowerCase() === arg.toLowerCase());
+      if (!hit) {
+        const near = list.models.filter((m) => m.id.toLowerCase().includes(arg.toLowerCase())).slice(0, 5);
+        say(
+          `No ${kind} model "${arg}" on this account.` +
+            (near.length ? ` Did you mean: ${near.map((m) => m.id).join(", ")}?` : ` Run /${kind}-model to browse.`),
+          "warning",
+        );
+        return;
+      }
+      setMediaModelPref(kind, hit.id);
+      say(`${label} model: ${hit.id}${nonZdrWarning(hit)}`);
+      return;
+    }
+    setMediaModelPref(kind, arg);
+    say(`${label} model: ${arg} (couldn't check it against the catalog: ${list.message})`, "warning");
+    return;
+  }
+
+  if (!list.ok) {
+    say(`Couldn't list ${kind} models: ${list.message}`, "error");
+    return;
+  }
+  if (!list.models.length) {
+    say(`This account has no ${kind} models available.`, "warning");
+    return;
+  }
+  if (!ui?.select) {
+    say(`${label} model: ${current ?? "account default"}. Set one with /${kind}-model <id>.`);
+    return;
+  }
+
+  const DEFAULT_ROW = `${current ? "  " : "● "}Account default`;
+  const rows = list.models.map((m) => describeCatalogRow(m, kind, current));
+  const picked = await ui.select(`${label} model for generate_${kind} — current: ${current ?? "account default"}`, [
+    DEFAULT_ROW,
+    ...rows,
+  ]);
+  if (picked === undefined) return;
+  if (picked === DEFAULT_ROW) {
+    setMediaModelPref(kind, null);
+    say(`${label} model: account default`);
+    return;
+  }
+  const chosen = list.models[rows.indexOf(picked)];
+  if (!chosen) return;
+  setMediaModelPref(kind, chosen.id);
+  say(`${label} model: ${chosen.id}${nonZdrWarning(chosen)}`);
+}
+
+export function registerMediaModelCommands(pi: { registerCommand?: (name: string, opts: unknown) => void }): void {
+  for (const kind of ["image", "video"] as const) {
+    pi.registerCommand?.(`${kind}-model`, {
+      description: `Choose the model generate_${kind} uses on this machine (default = the account's)`,
+      argumentHint: "[model id | default]",
+      handler: (args: string, ctx: any) => runMediaModelCommand(kind, args, ctx?.ui),
+    });
+  }
+}