@plannotator/ui 0.45.1 → 0.46.0

package/types.ts

@@ -348,6 +348,37 @@ export interface CodeAnnotation {
   gitButlerBase?: string;
   /** Exact server snapshot that supplied the GitButler line coordinates. */
   gitButlerSnapshotId?: string;
+  /**
+   * PR reviews only (#1590): the text of the diff lines this line comment
+   * was anchored to at creation (lineStart..lineEnd on `side`, joined with
+   * "\n"). When a saved draft is restored against a different patch, the
+   * comment keeps its position only if these lines still read the same;
+   * otherwise it is marked `outdated`. Absent on older annotations and on
+   * lines outside the patch hunks.
+   */
+  anchorText?: string;
+  /**
+   * PR reviews only (#1590): the lines around the anchor on the same side
+   * (up to two before and two after; `null` where a line is outside the patch
+   * hunks) and the hunk header's function context (`hunk`, when git printed
+   * one), so a comment on a common line (`}`, `return null;`) only keeps its
+   * position when its surroundings still match too.
+   */
+  anchorContext?: { before: (string | null)[]; after: (string | null)[]; hunk?: string };
+  /**
+   * PR reviews only (#1590): the review snapshot id of the diff whose line
+   * coordinates this comment uses. Re-stamped when a later diff passes the
+   * anchor check; a line comment is only posted inline when this matches the
+   * diff currently known for its PR.
+   */
+  anchorSnapshot?: string;
+  /**
+   * Set when a restored PR draft's comment no longer matches the code it was
+   * written on (the PR changed between sessions). Its line numbers refer to
+   * the earlier version: it is listed and exported (labelled) but never drawn
+   * inline on the current diff and never posted as an inline PR comment.
+   */
+  outdated?: boolean;
 }
 
 /** Token-level metadata passed from selection to annotation creation. */

package/utils/aiProvider.ts

@@ -8,20 +8,14 @@
 
 import { storage } from './storage';
 import { AGENT_CONFIG, getAgentAIProviderTypes, type Origin } from '@plannotator/core/agents';
+import { resolveModelChoice, type CatalogModel } from '@plannotator/core/model-catalog';
 
 const PROVIDER_KEY = 'plannotator-ai-provider';
 const MODELS_KEY = 'plannotator-ai-models';
 const PROVIDER_BY_ORIGIN_KEY = 'plannotator-ai-provider-by-origin';
 
-export interface AIProviderModel {
-  id: string;
-  label: string;
-  default?: boolean;
-  /** Reasoning-effort options this model supports (provider-reported, e.g. Codex). */
-  reasoningEfforts?: { id: string; label: string }[];
-  /** The model's default reasoning effort. */
-  defaultReasoningEffort?: string;
-}
+/** A provider-reported model — the shared catalog shape. */
+export type AIProviderModel = CatalogModel;
 
 export interface AIProviderOption {
   id: string;
@@ -135,13 +129,11 @@ export function resolveAIModelForProvider(
 ): string | null {
   if (!provider) return null;
   const models = provider.models ?? [];
-  const modelIds = new Set(models.map(m => m.id));
-  const preferredModel = preferredModels[provider.id];
-  if (preferredModel && (modelIds.size === 0 || modelIds.has(preferredModel))) {
-    return preferredModel;
-  }
-  const defaultModel = models.find(m => m.default) ?? models[0];
-  return defaultModel?.id ?? null;
+  const preferredModel = preferredModels[provider.id] ?? '';
+  // Providers that report no models take the saved pick verbatim; otherwise
+  // the shared resolver (same one the server and the launchers use).
+  if (models.length === 0) return preferredModel || null;
+  return resolveModelChoice(preferredModel, models) || null;
 }
 
 export function resolveAIProviderSelection(options: {

package/utils/annotateAgentInstructions.ts

@@ -0,0 +1,162 @@
+/**
+ * Builds the clipboard payload that teaches an external agent how to post
+ * annotations into a live Plannotator **annotate** session via
+ * /api/external-annotations. The annotate twin of `planAgentInstructions.ts`:
+ * same endpoint and wire shape (annotate servers run the plan-mode
+ * validator, `transformPlanInput` in `@plannotator/core/external-annotation`),
+ * but it talks about a document instead of a plan, carries no deny/resubmit
+ * loop, and adds one short section for the surface the session is showing.
+ *
+ * Only document what the validator accepts: POST takes `source`, `type`,
+ * `text`, `originalText`, `author`, and a `diagramAnchor`; an element anchor
+ * (`htmlAnchor`) is accepted by PATCH only.
+ */
+
+export type AnnotateInstructionsSurface =
+  /** Markdown / plain-text file, URL, or converted HTML. */
+  | 'markdown'
+  /** Raw HTML file rendered as the page. */
+  | 'html'
+  /** A running local app mirrored through the live proxy. */
+  | 'live-app'
+  /** A whole-file Mermaid / Graphviz source rendered as one diagram. */
+  | 'diagram'
+  /** A folder session (file browser, one document open at a time). */
+  | 'folder'
+  /** annotate-last: the agent's own message. */
+  | 'message';
+
+interface SurfaceSection {
+  /** The one command that fetches what the user is looking at. */
+  read: (origin: string) => string;
+  /** Surface-specific targeting rules, printed after the read command. */
+  notes: (origin: string) => string;
+}
+
+const SURFACES: Record<AnnotateInstructionsSurface, SurfaceSection> = {
+  markdown: {
+    read: (origin) => `curl -s ${origin}/api/plan | jq -r .plan`,
+    notes: () => `\`originalText\` is matched against the rendered text, so leave out markdown syntax such as \`**\` or \`#\`.`,
+  },
+
+  message: {
+    read: (origin) => `curl -s ${origin}/api/plan | jq -r .plan`,
+    notes: () => `The document is an agent message. \`originalText\` is matched against the rendered message text.`,
+  },
+
+  html: {
+    read: (origin) => `curl -s ${origin}/api/plan | jq -r .rawHtml`,
+    notes: (origin) => `The document is an HTML page rendered as a real web page. Quote its **visible text**, never markup: \`originalText\` is found by a text search of the rendered page.
+
+To pin a comment to an element instead of a phrase, POST it first, then attach an element anchor with PATCH (POST ignores \`htmlAnchor\`):
+
+\`\`\`sh
+curl -s -X PATCH "${origin}/api/external-annotations?id=<uuid>" \\
+  -H 'Content-Type: application/json' \\
+  -d '{"htmlAnchor": {"selector": "#pricing > h2", "tagName": "h2", "text": "Pricing"}}'
+\`\`\`
+
+\`selector\` must match exactly one element; \`text\`, when given, is that element's visible text and is checked when the marker is restored.`,
+  },
+
+  'live-app': {
+    read: (origin) => `curl -s ${origin}/api/plan | jq -r .targetUrl   # the running app; open or fetch it`,
+    notes: () => `The user is annotating a running local app, so there is no document text in the API. Quote **visible text** from the app: it is highlighted wherever it is found on the page the user has open. A comment you post shows on every page; to tie it to one route, PATCH \`{"pageUrl": "/settings?tab=2"}\` (path plus query). Prefer \`GLOBAL_COMMENT\` for anything not about specific on-screen text.`,
+  },
+
+  diagram: {
+    read: (origin) => `curl -s ${origin}/api/plan | jq -r .plan`,
+    notes: () => `The document is one Mermaid or Graphviz diagram (the source above). To comment on a node, edge, or cluster, add a \`diagramAnchor\` naming it by its id in the source; \`originalText\` is the part's label:
+
+\`\`\`json
+{"source": "claude-code", "type": "COMMENT", "text": "Rename this step.",
+ "originalText": "Start", "diagramAnchor": {"v": 1, "family": "flowchart", "kind": "node", "id": "A", "label": "Start"}}
+\`\`\`
+
+\`family\` is one of flowchart, state, class, er, requirement, sequence, other, graphviz; \`kind\` is node, edge (use \`from\` + \`to\` instead of \`id\`), cluster, or diagram (the whole diagram, no id). A malformed anchor is a 400; one that names no part of the diagram lists as unanchored.`,
+  },
+
+  folder: {
+    read: (origin) => `curl -s "${origin}/api/doc?path=<path-relative-to-folder>&doc=1" | jq -r '.markdown // .rawHtml'`,
+    notes: (origin) => `The user browses a folder (\`curl -s ${origin}/api/plan | jq -r .filePath\`) and opens one document at a time. No API tells you which document is open.
+
+External comments cannot target a specific document. Every comment you post is a session-level entry: it lists in the annotations panel whichever document is open (or none), is **not** highlighted inline in folder documents, and is included in the feedback the user sends. Name the file in \`text\` and prefer \`GLOBAL_COMMENT\`.`,
+  },
+};
+
+export function buildAnnotateAgentInstructions(
+  origin: string,
+  surface: AnnotateInstructionsSurface = 'markdown',
+): string {
+  const section = SURFACES[surface];
+  return `# Plannotator — External Annotations (annotate session)
+
+You can leave review comments on the document the user is annotating by POSTing to a small HTTP API. They appear immediately in the user's annotations panel (and as highlights where the quoted text is found). The user decides what to send back to their agent; there is no approve, deny, or submit endpoint for you.
+
+## Base URL
+${origin}
+
+All endpoints below are relative to that base. No authentication.
+
+## Read the document
+
+\`\`\`sh
+${section.read(origin)}
+\`\`\`
+
+Line numbers do not apply. Inline comments are pinned by quoting a verbatim phrase in \`originalText\`. ${section.notes(origin)}
+
+## Post comments
+
+\`\`\`sh
+curl -s ${origin}/api/external-annotations \\
+  -H 'Content-Type: application/json' \\
+  -d '{
+    "annotations": [
+      {"source": "claude-code", "type": "COMMENT", "text": "This claim needs a source.", "originalText": "adoption doubled last year"},
+      {"source": "claude-code", "type": "GLOBAL_COMMENT", "text": "The intro and summary contradict each other."}
+    ]
+  }'
+\`\`\`
+
+A single annotation can be posted without the \`annotations\` wrapper. Returns \`201 {"ids": [...]}\`, or \`400 {"error": "..."}\` (batches are all-or-nothing).
+
+| Field | Required | Notes |
+|---|---|---|
+| \`source\` | yes | Stable identifier for you (e.g. \`"claude-code"\`); reuse it so you can clean up later. |
+| \`text\` | yes | The comment body. |
+| \`type\` | yes | \`"COMMENT"\` (pinned to \`originalText\`) or \`"GLOBAL_COMMENT"\` (panel only). |
+| \`originalText\` | for \`COMMENT\` | A verbatim phrase from the document. If it is not found, the comment stays in the panel without a highlight. |
+| \`author\` | no | Label shown next to the comment. |
+
+## List, edit, delete
+
+\`\`\`sh
+curl -s ${origin}/api/external-annotations | jq                            # list
+curl -s -X PATCH "${origin}/api/external-annotations?id=<uuid>" \\
+  -H 'Content-Type: application/json' -d '{"text": "Reworded."}'           # edit
+curl -s -X DELETE "${origin}/api/external-annotations?source=claude-code"  # remove yours before re-posting
+\`\`\`
+
+## Notes
+- Posting the same comment twice creates two entries; delete by \`source\` before a re-run.
+- The document can change while the session is open; re-read it before re-posting.
+- This API is local to the user's machine. Treat it as a UI surface, not a public service.
+`;
+}
+
+/** Which surface section an annotate session's instructions carry. A folder
+ *  session is a folder whatever file type is open (the scoping rule is what
+ *  the agent needs to know); a live app wins over its HTML render. */
+export function resolveAnnotateInstructionsSurface(input: {
+  liveApp: boolean;
+  annotateSource: 'file' | 'message' | 'folder' | null;
+  renderAs: string;
+}): AnnotateInstructionsSurface {
+  if (input.liveApp) return 'live-app';
+  if (input.annotateSource === 'folder') return 'folder';
+  if (input.annotateSource === 'message') return 'message';
+  if (input.renderAs === 'html') return 'html';
+  if (input.renderAs === 'mermaid' || input.renderAs === 'graphviz') return 'diagram';
+  return 'markdown';
+}

package/utils/codeHighlight.ts

@@ -41,6 +41,24 @@ export function codeBlockClassName(language?: string): string {
   return `${CODE_BLOCK_CLASS} font-mono${language ? ` language-${language}` : ''}`;
 }
 
+/**
+ * Plan fences soft-wrap long lines (`white-space: pre-wrap`), but a fence laid
+ * out as a grid — box-drawing diagrams, `+---+` boxes, space-aligned columns —
+ * is unreadable once a row wraps. Those keep the old unwrapped, horizontally
+ * scrolling layout: the renderers mark them with `data-keep-layout`, which the
+ * editor stylesheet turns back into `white-space: pre`.
+ *
+ * Signals: any box-drawing or block-element character, a tab between two
+ * words, or a run of two or more spaces between two words (column alignment).
+ * A double space after sentence punctuation is prose, not alignment, and
+ * leading indentation is never interior, so ordinary code still wraps.
+ */
+const ALIGNED_LAYOUT = /[\u2500-\u259F]|\S\t+\S|[^\s.!?] {2,}\S/;
+
+export function codeBlockKeepsLayout(content: string): boolean {
+  return ALIGNED_LAYOUT.test(content);
+}
+
 /** Shiki's `FontStyle` bitmask. Inlined so this module needs no shiki types. */
 const FONT_STYLE_ITALIC = 1;
 const FONT_STYLE_BOLD = 2;

package/utils/parser.ts

@@ -4,11 +4,19 @@ import { resolveReplyParents } from '@plannotator/core/annotation-threads';
 import { diagramAnchorLocationLine, parseDiagramAnchor } from '@plannotator/core/diagram-anchor';
 import { skillReferenceExportBlock } from './skillReferences';
 
+/**
+ * Parsed YAML frontmatter value: scalar string, array, or nested map.
+ */
+export type FrontmatterValue =
+  | string
+  | FrontmatterValue[]
+  | { [key: string]: FrontmatterValue };
+
 /**
  * Parsed YAML frontmatter as key-value pairs.
  */
 export interface Frontmatter {
-  [key: string]: string | string[];
+  [key: string]: FrontmatterValue;
 }
 
 /** Number of leading whitespace characters on a line. */
@@ -81,6 +89,38 @@ function parseBlockScalar(
   return { value, endIndex: j - 1 };
 }
 
+/**
+ * Parse a simple `key: value` pair from a line. Returns null if the line
+ * is not a valid YAML mapping entry (e.g. scalar URLs or quoted strings).
+ */
+function parseKeyValue(str: string): { key: string; value: string } | null {
+  // A QUOTED KEY is still a mapping entry: `"title": "Doc"` must yield
+  // { title: "Doc" }, not nothing. Only a line that is nothing but a quoted
+  // scalar (`"just a string"`) is not an entry — which is the case the char
+  // after the closing quote distinguishes.
+  const quote = str[0];
+  if (quote === '"' || quote === "'") {
+    const closing = str.indexOf(quote, 1);
+    if (closing === -1) return null;
+    if (str[closing + 1] !== ':') return null;
+    // Same rule the unquoted branch applies: `key:value` is a scalar, not a
+    // mapping entry. A colon at end of line (empty value) is fine.
+    const afterColon = str[closing + 2];
+    if (afterColon !== undefined && afterColon !== ' ' && afterColon !== '\t') {
+      return null;
+    }
+    return { key: str.slice(1, closing), value: str.slice(closing + 2).trim() };
+  }
+  const colonIndex = str.indexOf(':');
+  if (colonIndex <= 0) return null;
+  if (colonIndex < str.length - 1 && str[colonIndex + 1] !== ' ' && str[colonIndex + 1] !== '\t') {
+    return null;
+  }
+  const key = str.slice(0, colonIndex).trim();
+  const value = str.slice(colonIndex + 1).trim();
+  return { key, value };
+}
+
 /**
  * Extract YAML frontmatter from markdown if present.
  * Returns the parsed frontmatter, the remaining markdown, and the 1-based
@@ -112,57 +152,127 @@ export function extractFrontmatter(markdown: string): { frontmatter: Frontmatter
   const consumedTotal = leadingChars + consumedInTrimmed;
   const contentStartLine = (markdown.slice(0, consumedTotal).match(/\n/g) || []).length + 1;
 
-  // Parse simple YAML (key: value pairs)
+  // Parse simple YAML (key: value pairs, indentation-aware)
   const frontmatter: Frontmatter = {};
-  let currentKey: string | null = null;
-  let currentArray: string[] | null = null;
+  const mapStack: { indent: number; map: { [key: string]: FrontmatterValue } }[] = [
+    { indent: -1, map: frontmatter },
+  ];
+  const arrayStack: { indent: number; array: FrontmatterValue[] }[] = [];
+  let pendingKey: {
+    key: string;
+    indent: number;
+    parentMap: { [key: string]: FrontmatterValue };
+  } | null = null;
 
   const lines = frontmatterRaw.split('\n');
   for (let i = 0; i < lines.length; i++) {
-    const rawLine = lines[i];
+    const rawLine = lines[i].replace(/\r$/, '');
     const trimmedLine = rawLine.trim();
 
-    // Array item (- value)
-    if (trimmedLine.startsWith('- ') && currentKey) {
-      const value = trimmedLine.slice(2).trim();
-      if (!currentArray) {
-        currentArray = [];
-        frontmatter[currentKey] = currentArray;
+    if (!trimmedLine) continue;
+
+    const lineIndent = indentWidth(rawLine);
+
+    // Array item (- value or - key: value)
+    if (trimmedLine.startsWith('- ')) {
+      const afterDash = trimmedLine.slice(2).trim();
+      const kv = parseKeyValue(afterDash);
+
+      if (pendingKey && lineIndent >= pendingKey.indent) {
+        const newArray: FrontmatterValue[] = [];
+        pendingKey.parentMap[pendingKey.key] = newArray;
+        arrayStack.push({ indent: lineIndent, array: newArray });
+        pendingKey = null;
+      } else {
+        pendingKey = null;
+        while (arrayStack.length > 0 && arrayStack[arrayStack.length - 1].indent > lineIndent) {
+          arrayStack.pop();
+        }
+      }
+
+      while (mapStack.length > 1 && mapStack[mapStack.length - 1].indent >= lineIndent) {
+        mapStack.pop();
+      }
+
+      const targetArray = arrayStack.length > 0 ? arrayStack[arrayStack.length - 1].array : null;
+
+      if (kv) {
+        const blockScalar = kv.value.match(/^([|>])[+-]?$/);
+        let scalarVal = kv.value;
+        if (blockScalar) {
+          const { value: parsedScalar, endIndex } = parseBlockScalar(
+            lines,
+            i + 1,
+            lineIndent,
+            blockScalar[1] === '>',
+          );
+          scalarVal = parsedScalar;
+          i = endIndex;
+        }
+
+        const mapElem: { [key: string]: FrontmatterValue } = {};
+        if (scalarVal) {
+          mapElem[kv.key] = scalarVal;
+        } else {
+          // The key sits two columns right of the dash (`- meta:`), so that —
+          // not the dash's own indent — is the indent its nested block must be
+          // measured against. Recording `lineIndent` here made the nested map
+          // swallow the item's later sibling keys, because a sibling indented
+          // to the key's column never dedented past the dash.
+          pendingKey = { key: kv.key, indent: lineIndent + 2, parentMap: mapElem };
+        }
+
+        if (targetArray) {
+          targetArray.push(mapElem);
+        }
+        mapStack.push({ indent: lineIndent, map: mapElem });
+      } else {
+        if (targetArray) {
+          targetArray.push(afterDash);
+        }
       }
-      currentArray.push(value);
       continue;
     }
 
     // Key: value pair
-    const colonIndex = trimmedLine.indexOf(':');
-    if (colonIndex > 0) {
-      currentKey = trimmedLine.slice(0, colonIndex).trim();
-      const value = trimmedLine.slice(colonIndex + 1).trim();
-      currentArray = null;
-
-      // Block scalar: `|` (literal, keep newlines) or `>` (folded, join with
-      // spaces), each with optional chomping indicator (`-`/`+`). The value
-      // spans the following lines indented deeper than the key, e.g.
-      //   description: >-
-      //     line one
-      //     line two
-      // Without this, the indicator (">-") was stored verbatim and the body
-      // silently dropped.
-      const blockScalar = value.match(/^([|>])[+-]?$/);
+    const kv = parseKeyValue(trimmedLine);
+    if (kv) {
+      if (pendingKey) {
+        if (lineIndent > pendingKey.indent) {
+          const newMap: { [key: string]: FrontmatterValue } = {};
+          pendingKey.parentMap[pendingKey.key] = newMap;
+          mapStack.push({ indent: pendingKey.indent, map: newMap });
+        }
+        pendingKey = null;
+      }
+
+      while (arrayStack.length > 0 && arrayStack[arrayStack.length - 1].indent >= lineIndent) {
+        arrayStack.pop();
+      }
+      while (mapStack.length > 1 && mapStack[mapStack.length - 1].indent >= lineIndent) {
+        mapStack.pop();
+      }
+
+      const parentMap = mapStack[mapStack.length - 1].map;
+
+      // Block scalar: `|` or `>`
+      const blockScalar = kv.value.match(/^([|>])[+-]?$/);
       if (blockScalar) {
         const { value: scalarValue, endIndex } = parseBlockScalar(
           lines,
           i + 1,
-          indentWidth(rawLine),
+          lineIndent,
           blockScalar[1] === '>',
         );
-        frontmatter[currentKey] = scalarValue;
+        parentMap[kv.key] = scalarValue;
         i = endIndex;
         continue;
       }
 
-      if (value) {
-        frontmatter[currentKey] = value;
+      if (kv.value) {
+        parentMap[kv.key] = kv.value;
+      } else {
+        pendingKey = { key: kv.key, indent: lineIndent, parentMap };
       }
     }
   }

package/utils/terminalToolsAnnouncement.ts

@@ -53,8 +53,8 @@ export interface TerminalToolsAnnouncementGateState {
 /**
  * Chain gate for the announcement. It is LAST in each app's first-run dialog
  * chain, after every dialog that asks the user to decide something (code
- * review: guide intro, look-and-feel, review setup, edit mode, token hover
- * cards; plan and annotate: look-and-feel, goal setup, permission mode).
+ * review: guide intro, look-and-feel, edit mode, token hover cards; plan and
+ * annotate: look-and-feel, goal setup, permission mode).
  *
  * Last rather than first because none of those dialogs consume this cookie:
  * a session that is busy asking questions defers the announcement to the next

package/utils/codexModels.ts

@@ -1,79 +0,0 @@
-/**
- * Codex Model Catalog
- *
- * Single source of truth for the Codex models offered by the launch panels
- * (AgentsTab + GuideEmptyState) and their per-model reasoning efforts.
- * Aligned with the Codex CLI's own model catalog (codex-cli 0.144): each
- * entry carries the efforts that model actually accepts plus the CLI's
- * default effort for it, so the UI never offers (or launches) an effort the
- * model would reject. Lives in utils/ rather than AgentsTab so
- * useAgentSettings can clamp saved efforts without importing a component.
- */
-
-export interface CodexModelOption {
-  value: string;
-  label: string;
-  /** Reasoning efforts this model supports, per the Codex CLI catalog. */
-  efforts: string[];
-  /** The CLI's default effort for this model — the clamp target when a saved
-   *  effort isn't in `efforts`. */
-  defaultEffort: string;
-}
-
-// The two effort ladders in the current catalog. No model supports `minimal`
-// anymore (saved picks migrate to `low` — see useAgentSettings).
-const EFFORTS_THROUGH_XHIGH = ['low', 'medium', 'high', 'xhigh'];
-const EFFORTS_THROUGH_MAX = [...EFFORTS_THROUGH_XHIGH, 'max'];
-const EFFORTS_THROUGH_ULTRA = [...EFFORTS_THROUGH_MAX, 'ultra'];
-
-export const CODEX_MODELS: CodexModelOption[] = [
-  // GPT-5.6 naming scheme: `-sol` is the flagship, `-terra` is the mid
-  // price/performance tier, and `-luna` is the efficient high-volume tier.
-  { value: 'gpt-5.6-sol', label: 'GPT-5.6 Sol', efforts: EFFORTS_THROUGH_ULTRA, defaultEffort: 'low' },
-  { value: 'gpt-5.6-terra', label: 'GPT-5.6 Terra', efforts: EFFORTS_THROUGH_ULTRA, defaultEffort: 'medium' },
-  { value: 'gpt-5.6-luna', label: 'GPT-5.6 Luna', efforts: EFFORTS_THROUGH_MAX, defaultEffort: 'medium' },
-  { value: 'gpt-5.5', label: 'GPT-5.5', efforts: EFFORTS_THROUGH_XHIGH, defaultEffort: 'medium' },
-  { value: 'gpt-5.4', label: 'GPT-5.4', efforts: EFFORTS_THROUGH_XHIGH, defaultEffort: 'medium' },
-  { value: 'gpt-5.3-codex-spark', label: 'GPT-5.3 Codex Spark', efforts: EFFORTS_THROUGH_XHIGH, defaultEffort: 'high' },
-  // gpt-5.2 is retained: it was retired from the ChatGPT product (steered to
-  // 5.5) but the API still serves it, so API-key Codex users keep it. The
-  // rest of the 5.2/5.1 family (gpt-5.2-codex, gpt-5.1-codex-max,
-  // gpt-5.1-codex-mini — and gpt-5.3-codex before them) is API-shut-down per
-  // OpenAI's deprecations page (2026-07-23), dead for ALL auth modes; saved
-  // picks migrate in useAgentSettings. gpt-5.2 predates max/ultra, so it
-  // gets the safe historical effort set.
-  { value: 'gpt-5.2', label: 'GPT-5.2', efforts: EFFORTS_THROUGH_XHIGH, defaultEffort: 'medium' },
-  { value: 'gpt-5.4-mini', label: 'GPT-5.4 Mini', efforts: EFFORTS_THROUGH_XHIGH, defaultEffort: 'medium' },
-];
-
-/** Display labels for the reasoning-effort ids across every model. */
-export const CODEX_EFFORT_LABELS: Record<string, string> = {
-  low: 'Low',
-  medium: 'Medium',
-  high: 'High',
-  xhigh: 'XHigh',
-  max: 'Max',
-  ultra: 'Ultra',
-};
-
-// Fallback effort set for a model we don't know (a saved pick of a future
-// model id passes through migration untouched, so the picker still needs
-// SOMETHING to offer). low..xhigh is supported by every catalog model.
-const UNKNOWN_MODEL_EFFORTS = EFFORTS_THROUGH_XHIGH;
-
-/** The reasoning-effort picker options for one model — only the efforts that
- *  model actually supports. */
-export function codexReasoningOptions(model: string): Array<{ value: string; label: string }> {
-  const entry = CODEX_MODELS.find((m) => m.value === model);
-  const efforts = entry?.efforts ?? UNKNOWN_MODEL_EFFORTS;
-  return efforts.map((value) => ({ value, label: CODEX_EFFORT_LABELS[value] ?? value }));
-}
-
-/** Clamp a saved reasoning effort to what the model supports: an unsupported
- *  effort snaps to the model's catalog default effort. Unknown models pass
- *  through unchanged (we can't know their supported set). */
-export function clampCodexReasoning(model: string, reasoning: string): string {
-  const entry = CODEX_MODELS.find((m) => m.value === model);
-  if (!entry) return reasoning;
-  return entry.efforts.includes(reasoning) ? reasoning : entry.defaultEffort;
-}