@youdie006/prodex 0.2.0 → 0.4.0

package/README.md

@@ -184,6 +184,42 @@ prodex sessions show latest
 
 This uses the currently available ChatGPT web session and model selection. It is not a hidden API client, and it does not read cookies, tokens, localStorage, or sessionStorage.
 
+#### Choosing the model, reasoning effort, and project
+
+The visible-browser send drives the same composer picker you use by hand, so you can pick the model, reasoning effort, or a sidebar project per ask:
+
+```bash
+# Pro extended sub-mode, inside an existing sidebar project
+prodex pro browser ask --model Pro --pro-mode 확장 --project "my-project" "Review the migration plan"
+
+# A non-Pro model at a specific reasoning effort
+prodex pro browser ask --effort "매우 높음" "Draft the release notes"
+```
+
+Prerequisite: selection matches menu items by their visible text in the **Korean ChatGPT UI** (즉시/중간/높음/매우 높음, Pro 기본/확장, "프로젝트" sidebar labels). If your ChatGPT display language is not Korean, the selection flags will fail with "menu item not found"; either switch the UI language or send without selection flags.
+
+To see the labels your account currently shows, list them read-only (opens the menu, reads it, presses Escape — nothing is selected):
+
+```bash
+prodex pro browser models
+```
+
+- `--model` picks the composer model by its exact menu label. `Pro` is verified end-to-end. Models whose menu entry opens a submenu of variants (for example GPT-5.5) are rejected with a clear error instead of silently keeping the previous model; direct variant selection is planned.
+- `--pro-mode 기본|확장` selects the Pro sub-mode; it applies only when the model is Pro. `확장` can think for minutes, so it raises the default `--timeout-ms` from 90000 to 300000 (an explicit `--timeout-ms` always wins).
+- `--effort 즉시|중간|높음|"매우 높음"` sets the reasoning effort. English aliases `instant`/`medium`/`high`/`max` are accepted. The effort options and Pro share one radio group in ChatGPT, so picking an effort switches the composer to the standard reasoning model and deselects Pro; for the same reason `--pro-mode` and `--effort` cannot be combined.
+- `--project "name"` enters an existing sidebar project before sending. It cannot be combined with `--target-url` (the project click would navigate away from the confirmed tab). Creating a new project from the CLI is not supported yet; make it in ChatGPT first, then pass `--project`.
+
+Selection clicks are guarded: prodex refuses to click a control that is covered or out of view, waits for the menu to actually open instead of sleeping a fixed delay, and treats a menu that stays open after a pick as a failed selection. If any step fails, it backs out with Escape and reports a blocker instead of sending with the wrong model. Note that an applied selection stays active in your ChatGPT session after the send — switch back manually if you were on a different model.
+
+Persist defaults so you can omit these flags on routine asks; a per-ask flag always overrides the saved default. View saved defaults with `prodex status`, and clear one with the matching `--clear-*` flag:
+
+```bash
+prodex setup --model Pro --pro-mode 확장 --project "my-project"
+prodex setup --clear-project
+```
+
+Whatever selection is applied is recorded on the consult receipt (`metadata.selection`); receipt display output redacts the project name, keeping only the model axes visible. `prodex` only clicks the picker you can see; it never selects a model, effort, or project silently outside the visible browser.
+
 For a source checkout, keep the explicit send and inspection commands source-aware too:
 
 ```bash

package/dist/chatgpt-browser.d.ts

@@ -34,11 +34,27 @@ export declare class ChatGptBrowserBlockerError extends Error {
     readonly blocker: NonNullable<ChatGptBrowserStatus["blocker"]>;
     constructor(blocker: NonNullable<ChatGptBrowserStatus["blocker"]>);
 }
+export type ChatGptReasoningEffort = "즉시" | "중간" | "높음" | "매우 높음";
+export type ChatGptProMode = "기본" | "확장";
+/** Normalize a CLI reasoning-effort value onto the exact ChatGPT menu label. */
+export declare function parseReasoningEffort(raw: string): ChatGptReasoningEffort;
+/** Normalize a CLI Pro sub-mode value onto the exact ChatGPT menu label. */
+export declare function parseProMode(raw: string): ChatGptProMode;
 export interface SendChatGptPromptOptions {
     port?: number;
     prompt: string;
     targetUrl?: string;
     timeoutMs?: number;
+    /** Switch into this sidebar project (by visible name) before sending. */
+    project?: string;
+    /** Create a new project with this name before sending. */
+    projectNew?: string;
+    /** Model to select in the composer picker, e.g. "Pro" or "GPT-5.5". */
+    model?: string;
+    /** Pro sub-mode, used when model is Pro. */
+    proMode?: ChatGptProMode;
+    /** Reasoning effort, used for non-Pro models. */
+    effort?: ChatGptReasoningEffort;
 }
 export interface SendChatGptPromptResult {
     url: string;
@@ -112,7 +128,30 @@ export declare function getChatGptBrowserStatus(options?: {
     port?: number;
     timeoutMs?: number;
 }): Promise<ChatGptBrowserStatus>;
+export declare function menuOpenExpression(): string;
+export declare function menuClosedExpression(): string;
+export declare function menuItemPresentExpression(label: string): string;
+export declare function modelButtonRectExpression(): string;
+export declare function menuItemRectExpression(label: string): string;
+export declare function submenuItemRectExpression(label: string): string;
+export declare function proRadioRectExpression(): string;
+export declare function proSubmenuExpanderRectExpression(): string;
+export declare function projectItemRectExpression(name: string): string;
 export declare function sendChatGptPrompt(options: SendChatGptPromptOptions): Promise<SendChatGptPromptResult>;
+export interface ChatGptModelOption {
+    label: string;
+    kind: "radio" | "submenu";
+    checked: boolean;
+}
+export interface ListChatGptModelOptionsResult {
+    url: string;
+    options: ChatGptModelOption[];
+}
+export declare function modelMenuOptionsExpression(): string;
+export declare function listChatGptModelOptions(input?: {
+    port?: number;
+    timeoutMs?: number;
+}): Promise<ListChatGptModelOptionsResult>;
 export declare function statusExpression(): string;
 export declare function setComposerTextExpression(text: string): string;
 export declare function submitExpression(): string;

package/dist/chatgpt-browser.js

@@ -10,6 +10,43 @@ export class ChatGptBrowserBlockerError extends Error {
         this.blocker = blocker;
     }
 }
+const REASONING_EFFORTS = ["즉시", "중간", "높음", "매우 높음"];
+const PRO_MODES = ["기본", "확장"];
+// Aliases map friendly CLI input onto the exact Korean menu labels the picker
+// clicks by text. Keys are lowercased and space-stripped before lookup.
+const REASONING_EFFORT_ALIASES = {
+    "매우높음": "매우 높음",
+    instant: "즉시",
+    medium: "중간",
+    high: "높음",
+    max: "매우 높음"
+};
+const PRO_MODE_ALIASES = {
+    standard: "기본",
+    extended: "확장"
+};
+/** Normalize a CLI reasoning-effort value onto the exact ChatGPT menu label. */
+export function parseReasoningEffort(raw) {
+    const trimmed = raw.trim();
+    const match = REASONING_EFFORTS.find((effort) => effort === trimmed);
+    if (match)
+        return match;
+    const alias = REASONING_EFFORT_ALIASES[trimmed.toLowerCase().replace(/\s+/g, "")];
+    if (alias)
+        return alias;
+    throw new Error(`--effort must be one of ${REASONING_EFFORTS.join(", ")}`);
+}
+/** Normalize a CLI Pro sub-mode value onto the exact ChatGPT menu label. */
+export function parseProMode(raw) {
+    const trimmed = raw.trim();
+    const match = PRO_MODES.find((mode) => mode === trimmed);
+    if (match)
+        return match;
+    const alias = PRO_MODE_ALIASES[trimmed.toLowerCase().replace(/\s+/g, "")];
+    if (alias)
+        return alias;
+    throw new Error(`--pro-mode must be one of ${PRO_MODES.join(", ")}`);
+}
 export const CHATGPT_RUNTIME_BLOCKER_TEXT_EXCLUDED_ANCESTORS = '[data-message-author-role],script,style,noscript,[aria-hidden="true"],div[role="textbox"],textarea,[contenteditable="true"]';
 export const CHATGPT_COMPOSER_CANDIDATE_EXCLUDED_ANCESTORS = '[data-message-author-role],script,style,noscript,[aria-hidden="true"]';
 export const PRODEX_ACTIVE_COMPOSER_ATTRIBUTE = "data-prodex-active-composer";
@@ -47,8 +84,15 @@ export function isUsableChatGptAnswer(answer) {
     const normalized = answer.trim();
     if (!normalized)
         return false;
-    if (/^(생각 중|thinking|thought for|thought about)/i.test(normalized.replace(/\.+$/, ""))) {
-        return normalized.split(/\r?\n/).filter(Boolean).length > 1;
+    const stripped = normalized.replace(/\.+$/, "");
+    const lineCount = normalized.split(/\r?\n/).filter(Boolean).length;
+    if (/^(생각 중|thinking|thought for|thought about)/i.test(stripped)) {
+        return lineCount > 1;
+    }
+    // Model-prefixed thinking status, e.g. "Pro 생각 중": a single short line
+    // ending in 생각 중 is the placeholder, not an answer.
+    if (lineCount <= 1 && /(^|\s)생각 중$/.test(stripped)) {
+        return false;
     }
     return true;
 }
@@ -359,6 +403,260 @@ export async function getChatGptBrowserStatus(options = {}) {
         blocker
     };
 }
+async function dispatchEscapeKey(cdp) {
+    await cdp.send("Input.dispatchKeyEvent", { type: "keyDown", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 });
+    await cdp.send("Input.dispatchKeyEvent", { type: "keyUp", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 });
+}
+// Poll a boolean page expression instead of sleeping a fixed duration, so slow
+// renders wait longer and fast ones do not waste time.
+async function waitForExpressionTrue(cdp, expression, timeoutMs, intervalMs = 150) {
+    const startedAt = Date.now();
+    for (;;) {
+        if (await cdp.evaluate(expression))
+            return true;
+        if (Date.now() - startedAt >= timeoutMs)
+            return false;
+        await sleep(intervalMs);
+    }
+}
+const MENU_OPEN_TIMEOUT_MS = 5_000;
+const MENU_SETTLE_TIMEOUT_MS = 5_000;
+const PROJECT_NAVIGATION_TIMEOUT_MS = 8_000;
+export function menuOpenExpression() {
+    return `Boolean(document.querySelector('[data-testid="composer-intelligence-picker-content"]'))`;
+}
+export function menuClosedExpression() {
+    return `!document.querySelector('[data-testid="composer-intelligence-picker-content"]')`;
+}
+export function menuItemPresentExpression(label) {
+    return `[...document.querySelectorAll('[role="menuitemradio"],[role="menuitem"]')].some((r) => (r.textContent || "").trim() === ${JSON.stringify(label)})`;
+}
+// Shared click-point resolver: scroll the target into view, tag it with a
+// temporary attribute, and return its center. The coverage check happens later
+// in verifiedClickAt AFTER the pointer hovers the point, because ChatGPT uses
+// hover-revealed controls (e.g. the Pro sub-mode chevron) that only become
+// hit-testable once the row is hovered.
+const CLICK_POINT_SNIPPET = `
+    const clickPoint = (el, yCap) => {
+      document.querySelectorAll('[data-prodex-click]').forEach((n) => n.removeAttribute('data-prodex-click'));
+      el.scrollIntoView({ block: "center", inline: "nearest" });
+      const r = el.getBoundingClientRect();
+      if (r.width < 1 || r.height < 1) return { ok: false, reason: "target element has no visible area" };
+      el.setAttribute('data-prodex-click', '1');
+      const x = Math.round(r.x + r.width / 2);
+      const y = Math.round(r.y + (yCap ? Math.min(r.height / 2, yCap) : r.height / 2));
+      return { ok: true, x, y };
+    };`;
+function hoverVerifyExpression(x, y) {
+    return `(() => {
+    const el = document.querySelector('[data-prodex-click]');
+    const hit = document.elementFromPoint(${x}, ${y});
+    const ok = Boolean(el && hit && (hit === el || el.contains(hit) || hit.contains(el)));
+    if (el) el.removeAttribute('data-prodex-click');
+    return ok;
+  })()`;
+}
+// Move the pointer first, give hover styles a beat to apply, then confirm the
+// tagged target is what would actually receive the click before pressing.
+// These clicks land in the user's real session, so a covered or scrolled-out
+// target must fail loudly instead of clicking whatever sits at the point.
+async function verifiedClickAt(cdp, x, y, label) {
+    await cdp.send("Input.dispatchMouseEvent", { type: "mouseMoved", x, y });
+    await sleep(150);
+    const onTarget = await cdp.evaluate(hoverVerifyExpression(x, y));
+    if (!onTarget) {
+        throw new Error(`Refusing to click "${label}": another element covers its click point (overlay, scroll, or layout change). Retry, or interact manually in the visible browser.`);
+    }
+    await cdp.send("Input.dispatchMouseEvent", { type: "mousePressed", x, y, button: "left", clickCount: 1 });
+    await cdp.send("Input.dispatchMouseEvent", { type: "mouseReleased", x, y, button: "left", clickCount: 1 });
+}
+export function modelButtonRectExpression() {
+    return `(() => {${CLICK_POINT_SNIPPET}
+    const c = document.querySelector('#prompt-textarea,[contenteditable="true"],textarea');
+    const scope = c ? (c.closest('form') || document) : document;
+    const b = [...scope.querySelectorAll('[aria-haspopup="menu"]')].find((el) => {
+      const t = (el.textContent || "").trim();
+      const aria = el.getAttribute("aria-label") || "";
+      return /\\S/.test(t) && !/파일|첨부|받아쓰기|음성|dictation|attach/i.test(t + aria);
+    });
+    if (!b) return { ok: false, reason: "model selector button not found" };
+    return clickPoint(b);
+  })()`;
+}
+export function menuItemRectExpression(label) {
+    return `(() => {${CLICK_POINT_SNIPPET}
+    const m = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
+    if (!m) return { ok: false, reason: "reasoning/model menu did not open" };
+    const items = [...m.querySelectorAll('[role="menuitemradio"],[role="menuitem"]')];
+    const it = items.find((r) => (r.textContent || "").trim() === ${JSON.stringify(label)});
+    if (!it) return { ok: false, reason: "menu item not found", available: items.map((r) => (r.textContent || "").trim()).slice(0, 12) };
+    const point = clickPoint(it);
+    if (!point.ok) return point;
+    return { ...point, role: it.getAttribute("role"), haspopup: it.getAttribute("aria-haspopup") };
+  })()`;
+}
+export function submenuItemRectExpression(label) {
+    return `(() => {${CLICK_POINT_SNIPPET}
+    const items = [...document.querySelectorAll('[role="menuitemradio"],[role="menuitem"]')];
+    const it = items.find((r) => (r.textContent || "").trim() === ${JSON.stringify(label)});
+    if (!it) return { ok: false, reason: "submenu item not found" };
+    return clickPoint(it);
+  })()`;
+}
+// "Pro" itself is a plain radio; its sub-modes (Pro 기본 / Pro 확장) live behind an
+// unlabeled aria-haspopup="menu" chevron sitting next to the Pro radio. Clicking
+// that chevron (hovering does not work) opens the sub-mode submenu.
+// The Pro radio's visible label reflects the active sub-mode ("Pro", "Pro 기본",
+// or "Pro 확장"), so it must be matched by prefix, never by exact text.
+const PRO_RADIO_FINDER_SNIPPET = `
+    const findProRadio = (scope) =>
+      [...scope.querySelectorAll('[role="menuitemradio"]')].find((r) => /^Pro( |$)/.test((r.textContent || "").trim()));`;
+export function proRadioRectExpression() {
+    return `(() => {${CLICK_POINT_SNIPPET}${PRO_RADIO_FINDER_SNIPPET}
+    const m = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
+    if (!m) return { ok: false, reason: "reasoning/model menu did not open" };
+    const proRadio = findProRadio(m);
+    if (!proRadio) return { ok: false, reason: "Pro option not found in the model menu" };
+    return clickPoint(proRadio);
+  })()`;
+}
+export function proSubmenuExpanderRectExpression() {
+    return `(() => {${CLICK_POINT_SNIPPET}${PRO_RADIO_FINDER_SNIPPET}
+    const m = document.querySelector('[data-testid="composer-intelligence-picker-content"],[role="menu"]');
+    if (!m) return { ok: false, reason: "model menu is not open" };
+    const proRadio = findProRadio(m);
+    if (!proRadio) return { ok: false, reason: "Pro option not found in the model menu" };
+    const proTop = proRadio.getBoundingClientRect().top;
+    const expanders = [...m.querySelectorAll('[role="menuitem"][aria-haspopup="menu"]')].filter((e) => {
+      const t = (e.textContent || "").trim();
+      return !/gpt|claude|gemini|o\\d|mini|thinking/i.test(t);
+    });
+    let best = null;
+    let bestDy = Infinity;
+    for (const e of expanders) {
+      const dy = Math.abs(e.getBoundingClientRect().top - proTop);
+      if (dy < bestDy) { best = e; bestDy = dy; }
+    }
+    if (!best || bestDy > 40) return { ok: false, reason: "Pro sub-mode expander not found next to Pro" };
+    return clickPoint(best);
+  })()`;
+}
+export function projectItemRectExpression(name) {
+    return `(() => {${CLICK_POINT_SNIPPET}
+    const opt = [...document.querySelectorAll('[aria-label*="프로젝트 옵션 열기"]')].find((b) => (b.getAttribute("aria-label") || "").startsWith(${JSON.stringify(name)}));
+    let target = opt ? (opt.closest('a,[role="link"],li') || opt.parentElement) : null;
+    if (!target) {
+      const icons = [...document.querySelectorAll('[data-testid="project-folder-icon"]')];
+      for (const ic of icons) {
+        const row = ic.closest('a,li,[role="link"]') || ic.parentElement?.parentElement;
+        if (row && (row.textContent || "").includes(${JSON.stringify(name)})) { target = row; break; }
+      }
+    }
+    if (!target) return { ok: false, reason: "project not found in sidebar" };
+    return clickPoint(target, 18);
+  })()`;
+}
+// Clicking a menuitemradio commits the choice and closes the picker; a menu
+// that stays open means the click did not land where we intended.
+async function assertSelectionCommitted(cdp, label) {
+    const closed = await waitForExpressionTrue(cdp, menuClosedExpression(), MENU_SETTLE_TIMEOUT_MS);
+    if (!closed) {
+        throw new Error(`ChatGPT selection "${label}" did not commit; the model menu stayed open. Retry, or pick it manually in the visible browser.`);
+    }
+}
+async function selectModelReasoning(cdp, options) {
+    if (!options.model && !options.proMode && !options.effort)
+        return;
+    const button = await cdp.evaluate(modelButtonRectExpression());
+    if (!button.ok || button.x === undefined || button.y === undefined) {
+        throw new Error(button.reason ?? "Could not open the ChatGPT model selector");
+    }
+    try {
+        await verifiedClickAt(cdp, button.x, button.y, "model selector");
+        const opened = await waitForExpressionTrue(cdp, menuOpenExpression(), MENU_OPEN_TIMEOUT_MS);
+        if (!opened)
+            throw new Error("ChatGPT model menu did not open after clicking the selector");
+        const wantsProMode = Boolean(options.proMode) && (!options.model || /pro/i.test(options.model));
+        if (wantsProMode && options.proMode) {
+            // Open the Pro sub-mode submenu via the chevron, then pick 기본/확장.
+            const expander = await cdp.evaluate(proSubmenuExpanderRectExpression());
+            if (!expander.ok || expander.x === undefined || expander.y === undefined) {
+                throw new Error(expander.reason ?? "Could not open the ChatGPT Pro sub-mode submenu");
+            }
+            await verifiedClickAt(cdp, expander.x, expander.y, "Pro sub-mode expander");
+            const subLabel = `Pro ${options.proMode}`;
+            const subVisible = await waitForExpressionTrue(cdp, menuItemPresentExpression(subLabel), MENU_OPEN_TIMEOUT_MS);
+            if (!subVisible)
+                throw new Error(`ChatGPT Pro sub-mode not found: ${subLabel}`);
+            const sub = await cdp.evaluate(submenuItemRectExpression(subLabel));
+            if (!sub.ok || sub.x === undefined || sub.y === undefined) {
+                throw new Error(sub.reason ?? `ChatGPT Pro sub-mode not clickable: ${subLabel}`);
+            }
+            await verifiedClickAt(cdp, sub.x, sub.y, subLabel);
+            await assertSelectionCommitted(cdp, subLabel);
+            return;
+        }
+        const primaryLabel = options.model ?? options.effort;
+        if (!primaryLabel) {
+            await dispatchEscapeKey(cdp);
+            return;
+        }
+        // --model Pro without a sub-mode: the Pro radio's label carries the active
+        // sub-mode, so exact-label lookup would miss it.
+        if (options.model && /^pro$/i.test(options.model)) {
+            const proRadio = await cdp.evaluate(proRadioRectExpression());
+            if (!proRadio.ok || proRadio.x === undefined || proRadio.y === undefined) {
+                throw new Error(proRadio.reason ?? "Pro option not found in the model menu");
+            }
+            await verifiedClickAt(cdp, proRadio.x, proRadio.y, "Pro");
+            await assertSelectionCommitted(cdp, "Pro");
+            return;
+        }
+        const primary = await cdp.evaluate(menuItemRectExpression(primaryLabel));
+        if (!primary.ok || primary.x === undefined || primary.y === undefined) {
+            throw new Error(`ChatGPT model/effort option not found: ${primaryLabel}${primary.available ? ` (available: ${primary.available.join(", ")})` : ""}`);
+        }
+        if (primary.role === "menuitem" && primary.haspopup === "menu") {
+            throw new Error(`ChatGPT model "${primaryLabel}" opens a submenu of variants instead of committing; selecting it is not supported yet. Supported today: reasoning efforts (--effort) and Pro via --pro-mode.`);
+        }
+        await verifiedClickAt(cdp, primary.x, primary.y, primaryLabel);
+        await assertSelectionCommitted(cdp, primaryLabel);
+    }
+    catch (error) {
+        // Leave the user's screen clean: back out of any open menu before rethrowing.
+        try {
+            await dispatchEscapeKey(cdp);
+            await sleep(150);
+            await dispatchEscapeKey(cdp);
+        }
+        catch {
+            // best effort only
+        }
+        throw error;
+    }
+}
+async function selectProject(cdp, options) {
+    if (options.projectNew) {
+        throw new Error("projectNew (new-project modal) automation is not implemented yet; create the project manually and use --project");
+    }
+    if (!options.project)
+        return;
+    const hrefBefore = await cdp.evaluate("location.href");
+    const hit = await cdp.evaluate(projectItemRectExpression(options.project));
+    if (!hit.ok || hit.x === undefined || hit.y === undefined) {
+        const detail = hit.reason && hit.reason !== "project not found in sidebar" ? ` (${hit.reason})` : "";
+        throw new Error(`ChatGPT project not found in sidebar: ${options.project}${detail}`);
+    }
+    await verifiedClickAt(cdp, hit.x, hit.y, `project ${options.project}`);
+    const navigated = await waitForExpressionTrue(cdp, `location.href !== ${JSON.stringify(hrefBefore)}`, PROJECT_NAVIGATION_TIMEOUT_MS);
+    if (!navigated) {
+        throw new Error(`Clicking project "${options.project}" did not navigate the visible tab. If the tab is already inside this project, omit --project and retry.`);
+    }
+    const composerReady = await waitForExpressionTrue(cdp, `Boolean(document.querySelector('#prompt-textarea,[contenteditable="true"],textarea'))`, PROJECT_NAVIGATION_TIMEOUT_MS);
+    if (!composerReady) {
+        throw new Error(`ChatGPT composer did not appear after entering project "${options.project}"`);
+    }
+}
 export async function sendChatGptPrompt(options) {
     const port = options.port ?? 9333;
     const timeoutMs = options.timeoutMs ?? 90_000;
@@ -394,6 +692,8 @@ export async function sendChatGptPrompt(options) {
     const cdp = await connectCdp(page.webSocketDebuggerUrl);
     try {
         await cdp.send("Runtime.enable");
+        await selectProject(cdp, options);
+        await selectModelReasoning(cdp, options);
         const inserted = await cdp.evaluate(setComposerTextExpression(options.prompt));
         if (!inserted.ok)
             throw new Error(inserted.reason ?? "Could not insert text into ChatGPT composer");
@@ -460,6 +760,71 @@ export async function sendChatGptPrompt(options) {
         warnings: []
     };
 }
+export function modelMenuOptionsExpression() {
+    return `(() => {
+    const m = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
+    if (!m) return [];
+    return [...m.querySelectorAll('[role="menuitemradio"],[role="menuitem"]')]
+      .map((it) => ({
+        label: (it.textContent || "").trim(),
+        kind: it.getAttribute("aria-haspopup") === "menu" ? "submenu" : "radio",
+        checked: it.getAttribute("aria-checked") === "true"
+      }))
+      .filter((o) => o.label.length > 0);
+  })()`;
+}
+// Read-only discovery: open the composer model menu, read the option labels,
+// and press Escape. Nothing is clicked inside the menu, so the user's model
+// selection is never changed.
+export async function listChatGptModelOptions(input = {}) {
+    const port = input.port ?? 9333;
+    const timeoutMs = input.timeoutMs ?? 15_000;
+    const pageResult = await findChatGptPage(port, computePageDiscoveryTimeout(timeoutMs), undefined);
+    if (!pageResult.ok) {
+        throwBlockerOrError(pageResult.blocker, "ChatGPT browser page is not available");
+    }
+    if (!pageResult.page) {
+        if (pageResult.blocker)
+            throw new ChatGptBrowserBlockerError(pageResult.blocker);
+        assertChatGptPageAvailable();
+    }
+    const page = pageResult.page;
+    const status = await evaluateOnPage(page, statusExpression());
+    const blocker = detectChatGptPageBlocker(status);
+    if (blocker)
+        throw new ChatGptBrowserBlockerError(blocker);
+    assertChatGptReadyForPrompt(inferChatGptPageLoggedInLikely(status), status.hasComposer);
+    assertVisibleChatGptTab(status.visibilityState, status.url, undefined);
+    const cdp = await connectCdp(page.webSocketDebuggerUrl);
+    try {
+        await cdp.send("Runtime.enable");
+        const button = await cdp.evaluate(modelButtonRectExpression());
+        if (!button.ok || button.x === undefined || button.y === undefined) {
+            throw new Error(button.reason ?? "Could not open the ChatGPT model selector");
+        }
+        try {
+            await verifiedClickAt(cdp, button.x, button.y, "model selector");
+            const opened = await waitForExpressionTrue(cdp, menuOpenExpression(), MENU_OPEN_TIMEOUT_MS);
+            if (!opened)
+                throw new Error("ChatGPT model menu did not open after clicking the selector");
+            const options = await cdp.evaluate(modelMenuOptionsExpression());
+            return { url: status.url, options };
+        }
+        finally {
+            try {
+                await dispatchEscapeKey(cdp);
+                await sleep(150);
+                await dispatchEscapeKey(cdp);
+            }
+            catch {
+                // best effort only
+            }
+        }
+    }
+    finally {
+        cdp.close();
+    }
+}
 async function findChatGptPage(port, timeoutMs, targetUrl) {
     try {
         const response = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(timeoutMs) });
@@ -632,7 +997,9 @@ export function statusExpression() {
     }));
     const assistant = messages.filter((message) => message.role === "assistant").at(-1);
     const answer = assistant?.text || "";
-    const placeholder = /^(생각 중|thinking|thought for|thought about)/i.test(answer.trim().replace(/\\.+$/, ""));
+    const ansStripped = answer.trim().replace(/\\.+$/, "");
+    const ansLines = ansStripped.split(/\\r?\\n/).filter((l) => l.trim());
+    const placeholder = /^(생각 중|thinking|thought for|thought about)/i.test(ansStripped) || (ansLines.length <= 1 && /(^|\\s)생각 중$/.test(ansStripped));
     const hasComposer = Boolean(findChatGptComposerCandidate());
     return {
       title: document.title,
@@ -782,7 +1149,9 @@ function answerExpression() {
       .map((node) => (node.innerText || node.getAttribute("aria-label") || node.getAttribute("data-testid") || "").trim())
       .filter(Boolean);
     const answer = assistant?.text || "";
-    const placeholder = /^(생각 중|thinking|thought for|thought about)/i.test(answer.trim().replace(/\\.+$/, ""));
+    const ansStripped = answer.trim().replace(/\\.+$/, "");
+    const ansLines = ansStripped.split(/\\r?\\n/).filter((l) => l.trim());
+    const placeholder = /^(생각 중|thinking|thought for|thought about)/i.test(ansStripped) || (ansLines.length <= 1 && /(^|\\s)생각 중$/.test(ansStripped));
     return {
       title: document.title,
       url: location.href,