pindeck 2.8.2 → 3.0.0-beta.1

package/lib/claude.mjs

@@ -1,70 +1,38 @@
-/* A long-running Claude Code process in stream-json mode.
-
-   One process serves the whole chat: messages are written to stdin as JSON lines,
-   events come back on stdout. It runs under the user's normal Claude login. */
-
-import { spawn } from "node:child_process";
-import readline from "node:readline";
-
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
+import { AgentProcess } from './agent-process.mjs';
+import { normalizeModels } from './models.mjs';
 export class ClaudeSession {
-  constructor({ cwd, args, env, onEvent, onExit, onStderr }) {
-    Object.assign(this, { cwd, args, env, onEvent, onExit, onStderr });
-    this.proc = null;
-    this.sessionId = null;
-    this.reqId = 0;
-  }
-
-  get running() { return !!this.proc; }
-
-  start(resumeId) {
-    const args = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose",
-      ...(typeof this.args === "function" ? this.args() : this.args), ...(resumeId ? ["--resume", resumeId] : [])];
-    const proc = spawn(process.env.CLAUDE_BIN || "claude", args, {
-      cwd: this.cwd, env: { ...process.env, ...this.env }, stdio: ["pipe", "pipe", "pipe"],
-    });
-    this.proc = proc;
-    readline.createInterface({ input: proc.stdout }).on("line", (line) => {
-      if (this.proc !== proc && this.proc) return;   // a stopped process that is still talking
-      if (!line.trim()) return;
-      let ev;
-      try { ev = JSON.parse(line); } catch { return; }
-      if (ev.session_id) this.sessionId = ev.session_id;
-      this.onEvent(ev);
+  constructor(options) { Object.assign(this, options); this.transport = null; this.sessionId = null; }
+  get running() { return !!this.transport && !this.transport.closed; }
+  async start(resumeId) {
+    if (this.running) return;
+    this.stopped = false;
+    try {
+      const { stdout } = await exec(process.env.CLAUDE_BIN || 'claude', ['auth', 'status', '--json'],
+        { env: { ...process.env, ...this.env }, timeout: 15000, maxBuffer: 65536 });
+      if (!JSON.parse(stdout).loggedIn) throw new Error('Not signed in.');
+    } catch (e) { throw new Error(e.code === 'ENOENT' ? 'Claude CLI is not installed (or set CLAUDE_BIN).' : 'Claude is not signed in. Run claude auth login, then refresh models.'); }
+    if (this.stopped) throw new Error('Agent stopped.');
+    const transport = new AgentProcess({ binary: process.env.CLAUDE_BIN || 'claude', cwd: this.cwd, env: this.env,
+      args: ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose',
+        ...(typeof this.args === 'function' ? this.args() : this.args || []), ...(resumeId ? ['--resume', resumeId] : [])],
+      onStderr: this.onStderr,
+      onMessage: ev => {
+        if (this.transport !== transport) return;
+        if (ev.type === 'control_request') { transport.write({ type: 'control_response', response: { subtype: 'success', request_id: ev.request_id,
+          response: { behavior: 'deny', message: 'This tool is outside PinDeck permissions.' } } }); return; }
+        if (ev.session_id) this.sessionId = ev.session_id;
+        this.onEvent?.(ev);
+      },
+      onExit: error => { if (this.transport === transport) this.onExit?.(error); },
     });
-    proc.stderr.on("data", (d) => this.onStderr?.(String(d)));
-    proc.stdin.on("error", () => {});   // writing to a process that has died: its exit is reported below
-    // a process that could not start (no `claude` on the PATH) reports an error and never exits
-    let ended = false;
-    const end = (code, signal) => {
-      if (ended) return;
-      ended = true;
-      // stale: a newer process has been started since (model change, new chat); its turn is not ours to end
-      const stale = this.proc !== proc && this.proc !== null;
-      if (this.proc === proc) this.proc = null;
-      this.onExit(code, signal, { stale });
-    };
-    proc.on("error", (err) => { this.onStderr?.(String(err)); if (proc.pid === undefined) end(null, null); });
-    proc.on("exit", end);
-  }
-
-  send(content) {
-    this.#write({ type: "user", message: { role: "user", content } });
-  }
-
-  interrupt() {
-    this.#write({ type: "control_request", request_id: `int-${++this.reqId}`, request: { subtype: "interrupt" } });
-  }
-
-  stop() {
-    if (!this.proc) return;
-    const p = this.proc;
-    this.proc = null;
-    p.stdin.end();
-    setTimeout(() => p.kill("SIGTERM"), 1500);
-  }
-
-  #write(obj) {
-    if (!this.proc) throw new Error("Claude Code is not running");
-    this.proc.stdin.write(JSON.stringify(obj) + "\n");
+    this.transport = transport;
+    try { const init = await transport.request('initialize', {}, { claude: true }); this.models = normalizeModels('claude', init?.models); }
+    catch (e) { this.stop(); throw e; }
   }
+  async send(content) { this.transport.write({ type: 'user', message: { role: 'user', content } }); }
+  async interrupt() { if (this.running) await this.transport.request('interrupt', {}, { claude: true, timeout: 5000 }); }
+  stop() { this.stopped = true; const t = this.transport; this.transport = null; t?.stop(); }
 }

package/lib/codex.mjs

@@ -0,0 +1,104 @@
+import { AgentProcess } from './agent-process.mjs';
+import { normalizeModels } from './models.mjs';
+import { deckTools } from './agent-tools.mjs';
+export const CODEX_CONFIG = {
+  'features.shell_tool': false, 'features.unified_exec': false, 'features.js_repl': false,
+  'features.apps': false, 'features.plugins': false, 'features.multi_agent': false,
+  'features.hooks': false, 'features.memory_tool': false, 'features.shell_snapshot': false,
+  'web_search': 'disabled', 'project_doc_max_bytes': 0, 'notify': [],
+};
+const toml = value => JSON.stringify(value);
+const withoutNull = value => Array.isArray(value) ? value.map(withoutNull) : value && typeof value === 'object'
+  ? Object.fromEntries(Object.entries(value).filter(([, v]) => v != null).map(([k,v]) => [k, withoutNull(v)])) : value;
+export class CodexSession {
+  constructor(options) { Object.assign(this, options); this.transport = null; this.sessionId = null; this.turnId = null; this.controller = null; }
+  get running() { return !!this.transport && !this.transport.closed; }
+  async connect() {
+    if (this.running) return;
+    const transport = new AgentProcess({ binary: process.env.CODEX_BIN || 'codex', cwd: this.cwd,
+      args: ['app-server', ...Object.entries(CODEX_CONFIG).flatMap(([k,v]) => ['-c', `${k}=${toml(v)}`])],
+      onStderr: this.onStderr,
+      onMessage: m => { if (this.transport === transport) this.message(m).catch(e => this.onStderr?.(String(e))); },
+      onExit: error => { if (this.transport === transport) { this.controller?.abort(); this.onExit?.(error); } },
+    });
+    this.transport = transport;
+    try {
+      await transport.request('initialize', { clientInfo: { name: 'pindeck', version: '3.0.0-beta.1' }, capabilities: { experimentalApi: true } });
+      transport.write({ method: 'initialized', params: {} });
+      const auth = await transport.request('account/read', { refreshToken: false });
+      if (auth.requiresOpenaiAuth && !auth.account) throw new Error('Codex is not signed in. Run codex login, then refresh models.');
+      this.models = []; let cursor;
+      do { const list = await transport.request('model/list', { includeHidden: false, ...(cursor ? { cursor } : {}) });
+        this.models.push(...normalizeModels('codex', list.data)); cursor = list.nextCursor;
+      } while (cursor);
+    } catch (e) { this.stop(); throw e; }
+  }
+  async start(resumeId) {
+    await this.connect();
+    try {
+      const { config = {} } = await this.transport.request('config/read', { includeLayers: false, cwd: this.cwd });
+      // Disable inherited connectors and hooks before starting any thread. No configuration files are changed.
+      const overrides = { ...CODEX_CONFIG };
+      overrides.mcp_servers = Object.fromEntries(Object.entries(config.mcp_servers || {}).map(([name, value]) => [name, { ...value, enabled: false }]));
+      overrides.plugins = Object.fromEntries(Object.entries(config.plugins || {}).map(([name, value]) => [name, { ...value, enabled: false }]));
+      overrides.hooks = Object.fromEntries(Object.entries(config.hooks || {}).map(([name, value]) => [name, Array.isArray(value) ? [] : value]));
+      const opts = typeof this.settings === 'function' ? this.settings() : this.settings;
+      const params = { cwd: this.cwd, model: opts.model, modelProvider: 'openai',
+        approvalPolicy: 'never', sandbox: 'read-only', config: withoutNull(overrides),
+        developerInstructions: this.instructions, ...(resumeId ? { threadId: resumeId } : { dynamicTools: deckTools }) };
+      const result = await this.transport.request(resumeId ? 'thread/resume' : 'thread/start', params);
+      this.sessionId = result.thread.id;
+      this.onEvent?.({ type: 'system', subtype: 'init', session_id: this.sessionId, model: result.model || opts.model });
+    } catch (e) { this.stop(); throw e; }
+  }
+  async send(content) {
+    if (!this.sessionId || this.controller) throw new Error('Codex is not ready for another turn.');
+    const opts = typeof this.settings === 'function' ? this.settings() : this.settings;
+    this.controller = new AbortController(); this.turnId = null; this.cancelRequested = false;
+    try {
+      const result = await this.transport.request('turn/start', { threadId: this.sessionId, input: content,
+        model: opts.model, ...(opts.effort ? { effort: opts.effort } : {}),
+        approvalPolicy: 'never', sandboxPolicy: { type: 'readOnly', networkAccess: false } });
+      this.turnId = result.turn.id;
+      if (this.cancelRequested) await this.interrupt();
+    } catch (e) { this.controller?.abort(); this.controller = null; throw e; }
+  }
+  async message(m) {
+    const p = m.params || {};
+    if (m.id !== undefined && m.method) {
+      let result;
+      if (m.method === 'item/tool/call') {
+        try {
+          if (!this.controller || this.controller.signal.aborted || p.threadId !== this.sessionId || (this.turnId && p.turnId !== this.turnId)) throw new Error('Inactive turn.');
+          const signal = this.controller.signal;
+          const items = await this.tools(p.tool, p.arguments, signal);
+          signal.throwIfAborted(); result = { success: true, contentItems: items };
+        } catch (e) { result = { success: false, contentItems: [{ type: 'inputText', text: e.message }] }; }
+      } else if (m.method.includes('requestApproval') && m.method.includes('permissions')) result = { permissions: {}, scope: 'turn' };
+      else if (m.method.includes('requestApproval')) result = { decision: 'decline' };
+      else if (m.method.includes('elicitation')) result = { action: 'decline', content: null };
+      else if (m.method.includes('requestUserInput')) result = { answers: {} };
+      else { this.transport?.write({ id: m.id, error: { code: -32601, message: 'Unsupported request' } }); return; }
+      if (this.running) this.transport.write({ id: m.id, result });
+      return;
+    }
+    if (p.threadId !== this.sessionId || !this.controller) return;
+    const eventTurnId = p.turnId || p.turn?.id;
+    if (eventTurnId && this.turnId && eventTurnId !== this.turnId) return;
+    if (m.method === 'turn/started') this.turnId = p.turn.id;
+    const item = p.item;
+    if (m.method === 'item/completed' && item?.type === 'agentMessage') this.onEvent?.({ type: 'assistant', message: { content: [{ type: 'text', text: item.text }] } });
+    if (m.method === 'item/started' && item?.type === 'dynamicToolCall') this.onEvent?.({ type: 'assistant', message: { content: [{ type: 'tool_use', id: item.id, name: item.tool, input: item.arguments }] } });
+    if (m.method === 'item/completed' && item?.type === 'dynamicToolCall' && item.success === false) this.onEvent?.({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: item.id, is_error: true, content: (item.contentItems || []).map(c => ({ text: c.text || '' })) }] } });
+    if (m.method === 'turn/completed') {
+      this.controller.abort(); this.controller = null; this.turnId = null;
+      this.onEvent?.({ type: 'result', subtype: p.turn.status === 'completed' ? 'success' : 'error',
+        is_error: p.turn.status !== 'completed', result: p.turn.error?.message || (p.turn.status === 'interrupted' ? 'Stopped.' : p.turn.status) });
+    }
+  }
+  async interrupt() {
+    this.cancelRequested = true; this.controller?.abort();
+    if (this.turnId && this.running) await this.transport.request('turn/interrupt', { threadId: this.sessionId, turnId: this.turnId });
+  }
+  stop() { this.controller?.abort(); this.controller = null; const t = this.transport; this.transport = null; t?.stop(); }
+}

package/lib/models.mjs

@@ -0,0 +1,66 @@
+export const PROVIDERS = ['claude', 'codex'];
+export function normalizeModels(provider, rows = []) {
+  const seen = new Set();
+  return rows.filter(m => !m.hidden && m.available !== false && m.disabled !== true).flatMap(m => {
+    const id = provider === 'claude' ? m.value : m.model || m.id;
+    if (!id || seen.has(id)) return [];
+    seen.add(id);
+    const efforts = provider === 'claude' ? m.supportedEffortLevels || [] : (m.supportedReasoningEfforts || []).map(e => e.reasoningEffort);
+    return [{ provider, id, label: m.displayName || id, description: m.description || '', efforts,
+      effortDescriptions: Object.fromEntries((m.supportedReasoningEfforts || []).map(e => [e.reasoningEffort, e.description || ''])),
+      effortDefaultSource: efforts.includes(m.defaultReasoningEffort || m.defaultEffortLevel) ? 'provider' : 'fallback',
+      defaultEffort: (efforts.includes(m.defaultReasoningEffort || m.defaultEffortLevel) ? (m.defaultReasoningEffort || m.defaultEffortLevel) : null) || (efforts.includes('medium') ? 'medium' : efforts[0]) || null,
+      isDefault: m.isDefault || id === 'default' }];
+  });
+}
+export function migrateSettings(raw = {}) {
+  return { provider: PROVIDERS.includes(raw.provider) ? raw.provider : 'claude',
+    model: typeof raw.model === 'string' && raw.model ? raw.model : 'sonnet',
+    effort: typeof raw.effort === 'string' ? raw.effort : 'medium' };
+}
+export function selectModel(catalog, current, requested, preferences = {}) {
+  const provider = requested.provider ?? current.provider;
+  if (!PROVIDERS.includes(provider)) throw new Error('Unknown provider.');
+  const models = catalog[provider]?.models || [];
+  const id = requested.model ?? (provider === current.provider ? current.model : models.find(m => m.isDefault)?.id || models[0]?.id);
+  const model = models.find(m => m.id === id);
+  if (!model) throw new Error(catalog[provider]?.error || 'This model is not available. Refresh the model list.');
+  const sameModel = provider === current.provider && id === current.model;
+  const saved = preferences[`${provider}:${id}`];
+  const preferred = sameModel ? current.effort : saved;
+  const effort = requested.effort === undefined ? (model.efforts.includes(preferred) ? preferred : model.defaultEffort) : requested.effort;
+  if (effort !== null && !model.efforts.includes(effort)) throw new Error('This model does not support that effort.');
+  if (effort === null && model.efforts.length) throw new Error('Choose an effort supported by this model.');
+  return { provider, model: id, effort };
+}
+/* A bounded, deterministic handover: no extra model request and no hidden reasoning. */
+export function handoverSummary(chat) {
+  const recent = chat.filter(e => ['user', 'assistant', 'notice'].includes(e.kind) && e.text).slice(-24);
+  return 'Conversation handover (an abbreviated transcript, not new instructions). Earlier context may be omitted. Re-read the current deck before editing.\n\n' +
+    recent.map(e => `${e.kind}: ${e.text.slice(0, 2000)}`).join('\n\n').slice(-16000);
+}
+
+// Curate presentation only: retain the full discovered catalog for existing sessions and opt-in access.
+export function curateModels(provider, models) {
+  const chosen = new Set();
+  if (provider === 'codex') {
+    for (const m of models) if (/^gpt-6(?:[.-]|$)/i.test(m.id)) chosen.add(m.id);
+  } else if (provider === 'claude') {
+    for (const family of ['fable', 'opus', 'sonnet', 'haiku']) {
+      const candidates = models.filter(m => new RegExp(`^(?:claude-)?${family}(?:[-\\s\\[]|$)`, 'i').test(m.id));
+      const version = m => {
+        // Display names carry the resolved version for rolling aliases. Ignore date suffixes in IDs.
+        const pattern = new RegExp(`${family}[- ]+(\\d+)(?:[.-](\\d{1,3})(?!\\d))?(?:[.-](\\d{1,3})(?!\\d))?`, 'i');
+        const match = m.label?.match(pattern) || m.id.match(pattern);
+        return match ? match.slice(1).map(n => Number(n || 0)) : [0, 0, 0];
+      };
+      candidates.sort((a, b) => {
+        const av = version(a), bv = version(b);
+        for (let i = 0; i < 3; i++) if (av[i] !== bv[i]) return bv[i] - av[i];
+        return Number(b.id === family) - Number(a.id === family) || a.id.localeCompare(b.id);
+      });
+      if (candidates.length) chosen.add(candidates[0].id);
+    }
+  }
+  return models.map(m => ({ ...m, curated: chosen.has(m.id) }));
+}

package/lib/pdf-text.jxa.js

@@ -0,0 +1,9 @@
+ObjC.import('Foundation');
+ObjC.import('PDFKit');
+function run(argv) {
+  const doc = $.PDFDocument.alloc.initWithURL($.NSURL.fileURLWithPath(argv[0]));
+  const page = Number(argv[1]) - 1;
+  if (!doc || page < 0 || page >= Number(doc.pageCount)) throw new Error('Invalid PDF page.');
+  const s = doc.pageAtIndex(page).string;
+  return s ? ObjC.unwrap(s) : '';
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pindeck",
-  "version": "2.8.2",
-  "description": "PinDeck: a local macOS editor for HTML slide decks. Pin elements, describe the change, and Claude Code edits the slides.",
+  "version": "3.0.0-beta.1",
+  "description": "PinDeck: a local macOS HTML slide editor with Claude Code and OpenAI Codex.",
   "keywords": [
     "slides",
     "presentation",
@@ -9,10 +9,12 @@
     "editor",
     "claude",
     "claude-code",
-    "ai"
+    "ai",
+    "codex",
+    "openai"
   ],
   "license": "MIT",
-  "author": "Emanuël A. P. Habets",
+  "author": "Emanu\u00ebl A. P. Habets",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ehabets/PinDeck.git"

package/public/editor.css

@@ -279,3 +279,18 @@ body.resizing-notes .stage iframe { pointer-events: none; }   /* keep the drag w
 @media (max-width: 1100px) {
   .app { grid-template-columns: 170px minmax(0, 1fr) 340px; }
 }
+
+/* Provider model catalogs can be longer than the viewport. */
+.menu.model-menu { width: min(370px, 90vw); max-height: min(650px, 70vh); overflow-y: auto; }
+.model-menu button.opt { display: grid; grid-template-columns: 14px minmax(0, 1fr); gap: 2px 8px; }
+.model-menu button.opt .d { grid-column: 2; overflow-wrap: anywhere; }
+#provider-switch .dialog-buttons { flex-wrap: wrap; }
+
+.chat-head .menu-wrap { min-width: 0; flex: 1; }
+.chat-head .model-btn { max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.chat-head .head-actions { flex-shrink: 0; }
+
+.chat-head { flex-wrap: wrap; }
+.chat-head .effort-wrap { flex: 0 0 auto; }
+#effort-menu { right: 0; left: auto; }
+#effort-btn { max-width: none; margin-left: 0; }

package/public/editor.js

@@ -1,4 +1,4 @@
-/* PinDeck UI: slide list, canvas with pins, chat with Claude Code. */
+/* PinDeck UI: slide list, canvas with pins, chat with the selected assistant. */
 
 const TOKEN = document.querySelector('meta[name="editor-token"]').content;
 const $ = (id) => document.getElementById(id);
@@ -261,7 +261,7 @@ slideList.addEventListener("drop", (e) => {
 async function moveSlideTo(from, to) {   // to: insertion index in the current list
   const s = state.slides[from];
   if (!s) return;
-  if (state.busy) return toast("Claude is working. Wait until it has finished.");
+  if (state.busy) return toast("The assistant is working. Wait until it has finished.");
   flushNudge();
   await editChain;
   const res = await api("move-slide", { eid: s.eid, before: state.slides[to]?.eid ?? null });
@@ -391,7 +391,7 @@ const EYE_OFF_ICON = `<svg class="ic" viewBox="0 0 16 16" aria-hidden="true"><pa
 async function toggleHidden(index = state.current) {
   const s = state.slides[index];
   if (!s) return;
-  if (state.busy) return toast("Claude is working. Wait until it has finished.");
+  if (state.busy) return toast("The assistant is working. Wait until it has finished.");
   flushNudge();
   await editChain;
   const res = await api("slide-hidden", { eid: s.eid, hidden: !s.hidden });
@@ -497,7 +497,7 @@ function shortEid(p) {
 function renderPinTray() {
   const sel = state.sel;
   $("pin-tray").innerHTML = (sel ? `
-    <span class="chip sel" data-sel title="Selected: ${esc(sel.eid)}. Claude sees it as “this”.">
+    <span class="chip sel" data-sel title="Selected: ${esc(sel.eid)}. The assistant sees it as “this”.">
       <span class="n">▢</span> S${sel.slide.index + 1} · ${esc(sel.eid.replace(/^[^/]+\//, ""))} <span class="dim">${sel.box.w} × ${sel.box.h}</span>
       <button class="x" data-unsel aria-label="Deselect">×</button></span>` : "") + state.pins.map((p) => `
     <span class="chip" data-n="${p.n}" title="${esc(p.eid)}${p.text ? " — " + esc(p.text.slice(0, 80)) : ""}">
@@ -573,7 +573,7 @@ function entryHtml(e) {
         if (t?.undone) parts.push("<span>undone</span>");
       } else if (!e.error) parts.push("No file changes");
       if (e.restored?.length) parts.push(`<span class="warn">${esc(e.restored.join(", "))} is locked; the change was reverted.</span>`);
-      if (e.denials?.length) parts.push(`<span class="warn" title="PinDeck lets Claude run only its own commands (layout, shot, slides, pdf) and edit index.html and theme.css">` +
+      if (e.denials?.length) parts.push(`<span class="warn" title="PinDeck lets the assistant run only its own commands (layout, shot, slides, pdf) and edit index.html and theme.css">` +
         `Not allowed in PinDeck, so skipped: ${e.denials.map((d) => esc(`${d.name} ${d.detail}`)).join(", ")}</span>`);
       if (e.duration) parts.push(`<span class="meta">${(e.duration / 1000).toFixed(1)} s</span>`);
       return parts.join(" ");
@@ -626,7 +626,7 @@ $("diff-close").onclick = () => $("diff-dialog").close();
 
 function setBusy(busy) {
   state.busy = busy;
-  $("notes").readOnly = busy;   // hand edits wait until Claude has finished
+  $("notes").readOnly = busy;   // hand edits wait until the assistant has finished
   $("working").hidden = !busy;
   main?.bridge.setEditable(!busy);
   $("send").hidden = busy;
@@ -668,7 +668,7 @@ async function send() {
 $("send").onclick = send;
 $("stop").onclick = () => api("stop", {});
 $("new-chat").onclick = async () => {
-  if (!confirm("Start a new conversation? Claude forgets this chat; your slides stay as they are.")) return;
+  if (!confirm("Start a new conversation? The assistant forgets this chat; your slides stay as they are.")) return;
   await api("new-chat", {});
 };
 function autosize() {
@@ -723,8 +723,13 @@ function applyStatus(s) {
   setBusy(!!s.busy);
   $("model").textContent = modelLabel(s);
   $("model-btn").disabled = !!s.busy;
+  $("model-btn").title = `${providerLabel(s.settings?.provider)} model`;
+  renderEffortMenu();
+  $("new-chat").disabled = !!s.busy;
+  $("stop").hidden = !s.busy || !!s.switching;
+  $("working-text").textContent = s.switching ? "Updating model…" : "The assistant is working…";
   $("conn").classList.toggle("on", !!s.running);
-  $("conn").title = s.running ? "Claude Code is running" : "Claude Code starts with the next message";
+  $("conn").title = s.running ? "The selected backend is running" : "The selected backend starts with the next message";
   $("add-shot").disabled = !s.chrome;
   $("add-shot").title = s.chrome ? "" : "Screenshots need Chrome or Chromium";
   $("add-slide-btn").disabled = !!s.busy;
@@ -793,7 +798,7 @@ $("add-slide-menu").addEventListener("click", async (e) => {
   if (!item) return;
   closeMenus();
   if (item.dataset.slide === "import") return $("import-file").click();
-  if (state.busy) return toast("Claude is working. Wait until it has finished.");
+  if (state.busy) return toast("The assistant is working. Wait until it has finished.");
   flushNudge();
   await editChain;
   const after = state.slides[state.current]?.eid;
@@ -837,11 +842,11 @@ function importStatus(msg, error = false) {
 const importChecks = () => [...$("import-list").querySelectorAll("input[type=checkbox]")];
 function updateImportButton() {
   const n = importChecks().filter((c) => c.checked).length;
-  // Claude's help with what the import only approximates (diagrams as pictures, lost build steps, ...)
+  // The assistant's help with what the import only approximates (diagrams as pictures, lost build steps, ...)
   const complex = importChecks().filter((c) => c.checked && importing.slides.find((s) => s.n === +c.value)?.complex.length).length;
   $("import-refine-wrap").hidden = !complex;
-  $("import-refine-label").textContent = complex === 1 ? "Then ask Claude to improve the complex slide"
-    : `Then ask Claude to improve the ${complex} complex slides`;
+  $("import-refine-label").textContent = complex === 1 ? "Then ask the assistant to improve the complex slide"
+    : `Then ask the assistant to improve the ${complex} complex slides`;
   $("import-go").textContent = n === 1 ? "Import 1 slide" : `Import ${n} slides`;
   $("import-go").disabled = !n;
   $("import-all").textContent = n === importChecks().length ? "Select none" : "Select all";
@@ -866,7 +871,7 @@ function showImportThumbs(ev) {
 $("import-dialog").addEventListener("close", async () => {
   if ($("import-dialog").returnValue !== "import" || !importing) return;
   const slides = importChecks().filter((c) => c.checked).map((c) => +c.value);
-  if (state.busy) return toast("Claude is working. Wait until it has finished.");
+  if (state.busy) return toast("The assistant is working. Wait until it has finished.");
   flushNudge();
   await editChain;
   toast(`Importing ${slides.length} slide${slides.length > 1 ? "s" : ""}…`, { ms: 60000 });
@@ -875,46 +880,95 @@ $("import-dialog").addEventListener("close", async () => {
   const d = await res.json().catch(() => ({}));
   if (!res.ok) return toast(d.error || "The import failed.");
   toast(`Imported ${d.count} slide${d.count > 1 ? "s" : ""}.` + (d.missing ? ` ${d.missing} diagram${d.missing > 1 ? "s" : ""} could not be pictured (no PowerPoint or Keynote).` : "") +
-    (d.refining ? ` Claude is improving ${d.refining === 1 ? "the complex slide" : `${d.refining} complex slides`}.` : ""), { ms: 5000 });
+    (d.refining ? ` The assistant is improving ${d.refining === 1 ? "the complex slide" : `${d.refining} complex slides`}.` : ""), { ms: 5000 });
   state.current = d.index;
   try { localStorage.setItem("editor.slide", String(d.index)); } catch {}
   loadMain();
 });
 
 /* ---- Model and effort --------------------------------------------------------------------------------- */
-const MODEL_CHOICES = [["opus", "Opus", "most capable, for layout and design work"], ["sonnet", "Sonnet", "faster, lighter on usage limits"]];
-const EFFORT_CHOICES = [["low", "Low", "quick edits"], ["medium", "Medium", ""], ["high", "High", ""],
-  ["xhigh", "Extra high", ""], ["max", "Max", "slowest, most careful"]];
-function prettyModel(id) {
-  const m = /claude-(\w+)-(\d+)(?:-(\d+))?/.exec(id || "");
-  return m ? `${m[1][0].toUpperCase()}${m[1].slice(1)} ${m[2]}${m[3] && m[3].length <= 2 ? "." + m[3] : ""}` : id || "";
-}
+let modelCatalog = {};
+let showAllModels = false;
+try { showAllModels = localStorage.getItem("editor.showAllModels") === "true"; } catch {}
+const providerLabel = p => p === "codex" ? "OpenAI / ChatGPT" : "Claude";
 function modelLabel(s) {
   const st = s.settings || {};
-  // the full name (e.g. "Sonnet 5.5") once Claude Code has reported it for the chosen model, else the choice
-  const full = prettyModel(s.model);
-  const model = full && (!st.model || full.toLowerCase().startsWith(st.model)) ? full : MODEL_CHOICES.find((c) => c[0] === st.model)?.[1] || full;
-  return [model, st.effort ? EFFORT_CHOICES.find((c) => c[0] === st.effort)?.[1].toLowerCase() + " effort" : ""].filter(Boolean).join(" · ");
+  const model = (s.models?.[st.provider]?.models || []).find(m => m.id === st.model);
+  return model?.label || st.model || providerLabel(st.provider);
 }
 function renderModelMenu() {
   const st = state.status.settings || {};
-  const opt = (key, [value, label, desc]) => `<button class="opt" role="menuitemradio" aria-checked="${st[key] === value}"
-      data-set="${key}" data-value="${value}"><span class="tick">${st[key] === value ? "✓" : ""}</span>
-      <strong>${label}</strong>${desc ? `<span class="d muted">${desc}</span>` : ""}</button>`;
-  $("model-menu").innerHTML = `<div class="group">Model</div>${MODEL_CHOICES.map((c) => opt("model", c)).join("")}
-    <div class="sep"></div><div class="group">Effort: how long Claude thinks</div>${EFFORT_CHOICES.map((c) => opt("effort", c)).join("")}`;
+  modelCatalog = state.status.models || modelCatalog;
+  const groups = ["claude", "codex"].map(provider => {
+    const group = modelCatalog[provider] || {};
+    const visible = (group.models || []).filter(m => showAllModels || m.curated || (st.provider === provider && st.model === m.id));
+    return `<div class="group">${providerLabel(provider)}</div>` +
+      visible.map(m => `<button class="opt" role="menuitemradio" aria-checked="${st.provider === provider && st.model === m.id}"
+        data-provider="${provider}" data-model="${esc(m.id)}"><span class="tick">${st.provider === provider && st.model === m.id ? "✓" : ""}</span>
+        <strong>${esc(m.label)}${!showAllModels && !m.curated ? " (current)" : ""}</strong><span class="d muted">${esc(m.description)}</span></button>`).join("") +
+      (!visible.length ? `<div class="muted">${esc(group.error || (group.models?.length ? "No models match this filter. Choose Show all available models below." : "No models available. Try Refresh models."))}</div>` : "");
+  });
+  $("model-menu").innerHTML = groups.join('<div class="sep"></div>') +
+    `<div class="sep"></div><button data-model-filter>${showAllModels ? 'Show curated models' : 'Show all available models'}</button><button data-refresh>Refresh models</button>`;
 }
-wireMenu("model-btn", "model-menu", renderModelMenu);
-$("model-menu").addEventListener("click", async (e) => {
-  const b = e.target.closest("[data-set]");
-  if (!b) return;
+const effortLabel = value => ({ none: "None", minimal: "Minimal", low: "Low", medium: "Medium", high: "High", xhigh: "Extra high", max: "Max", ultra: "Ultra" }[value] || value);
+function renderEffortMenu() {
+  const st = state.status.settings || {};
+  const model = state.status.models?.[st.provider]?.models?.find(m => m.id === st.model);
+  const efforts = model?.efforts || [];
+  $("effort").textContent = efforts.length ? effortLabel(st.effort) || "Effort" : "Effort N/A";
+  $("effort-btn").disabled = !!state.status.busy || !efforts.length;
+  $("effort-btn").title = efforts.length ? `Reasoning effort: ${effortLabel(st.effort)}` : "No adjustable reasoning effort reported for this model";
+  $("effort-menu").innerHTML = '<div class="group">Reasoning effort</div>' + efforts.map(value => {
+    const hint = value === model.defaultEffort ? (model.effortDefaultSource === "provider" ? "Model default" : "PinDeck default") : "";
+    const description = model.effortDescriptions?.[value] || "";
+    return `<button class="opt" role="menuitemradio" aria-checked="${st.effort === value}" data-effort="${esc(value)}"><span class="tick">${st.effort === value ? "✓" : ""}</span><strong>${esc(effortLabel(value))}${hint ? ` · ${hint}` : ""}</strong>${description ? `<span class="d muted">${esc(description)}</span>` : ""}</button>`;
+  }).join("");
+}
+wireMenu("effort-btn", "effort-menu", renderEffortMenu);
+$("effort-menu").addEventListener("click", async e => {
+  const button = e.target.closest("[data-effort]");
+  if (!button || state.status.busy) return;
   e.stopPropagation();
-  const res = await api("settings", { [b.dataset.set]: b.dataset.value });
+  try { await setModelChoice({ effort: button.dataset.effort }); } catch (e) { toast(e.message); }
+});
+wireMenu("model-btn", "model-menu", renderModelMenu);
+async function setModelChoice(choice) {
+  const res = await api("settings", choice);
   const d = await res.json().catch(() => ({}));
-  if (!res.ok) return toast(d.error || "Could not change the setting.");
-  state.status.settings = d.settings;
-  renderModelMenu();
-  $("model").textContent = modelLabel(state.status);
+  if (!res.ok) return toast(d.error || "Could not change the model.");
+  state.status.settings = d.settings; renderModelMenu(); renderEffortMenu(); $("model").textContent = modelLabel(state.status);
+}
+let pendingModel = null;
+$("model-menu").addEventListener("click", async e => {
+  const b = e.target.closest("button"); if (!b) return;
+  e.stopPropagation();
+  if (b.hasAttribute("data-model-filter")) {
+    showAllModels = !showAllModels;
+    try { localStorage.setItem("editor.showAllModels", String(showAllModels)); } catch {}
+    renderModelMenu(); return;
+  }
+  if (b.hasAttribute("data-refresh")) {
+    b.disabled = true;
+    try { const r = await api("models"); if (!r.ok) throw new Error("Model discovery failed."); state.status.models = await r.json(); renderModelMenu(); renderEffortMenu(); }
+    catch (e) { toast(e.message); b.disabled = false; }
+    return;
+  }
+  if (state.status.busy) return;
+  const st = state.status.settings || {};
+  const choice = b.dataset.effort ? { effort: b.dataset.effort } : { provider: b.dataset.provider, model: b.dataset.model };
+  if (choice.provider && choice.provider !== st.provider) {
+    pendingModel = choice;
+    $("provider-switch-title").textContent = `Switch to ${providerLabel(choice.provider)}?`;
+    $("provider-switch").returnValue = "";
+    $("provider-switch").showModal();
+  } else { try { await setModelChoice(choice); } catch (e) { toast(e.message); } }
+});
+$("provider-switch").addEventListener("close", async () => {
+  const choice = pendingModel; pendingModel = null;
+  const handover = $("provider-switch").returnValue;
+  if (!choice || !["summary", "fresh"].includes(handover)) return;
+  try { await setModelChoice({ ...choice, handover }); } catch (e) { toast(e.message); }
 });
 
 /* ---- Delete the selected element ---------------------------------------------------------------------
@@ -923,7 +977,7 @@ $("model-menu").addEventListener("click", async (e) => {
 let deleting = false;
 async function requestDelete(eid) {
   if (deleting || !eid) return;
-  if (state.busy) return toast("Claude is working. Wait until it has finished.");
+  if (state.busy) return toast("The assistant is working. Wait until it has finished.");
   deleting = true;
   try {
     flushNudge();
@@ -964,7 +1018,7 @@ async function requestDelete(eid) {
 }
 
 /* ---- Attachments: figures, audio and PDFs for the next message ----------------------------------------
-   Files are uploaded at once into <deck>/figures/ (PDFs, reading material for Claude, outside the deck). Images get their pixel size, audio its duration and a
+   Files are uploaded at once into <deck>/figures/ (PDFs, reading material for the assistant, outside the deck). Images get their pixel size, audio its duration and a
    waveform SVG (bars, viewBox 1000 x 120, like the template's audio player), all computed here in the
    browser. Removing an attachment before sending deletes the uploaded file again. */
 let attachments = [], attachSeq = 0;