@youdie006/prodex 0.3.0 → 0.5.0

package/README.md

@@ -196,18 +196,30 @@ prodex pro browser ask --model Pro --pro-mode 확장 --project "my-project" "Rev
 prodex pro browser ask --effort "매우 높음" "Draft the release notes"
 ```
 
-- `--model` picks the composer model by its visible label (for example `Pro` or `GPT-5.5`).
-- `--pro-mode 기본|확장` selects the Pro sub-mode; it applies only when the model is Pro.
-- `--effort 즉시|중간|높음|"매우 높음"` sets the reasoning effort for non-Pro models. English aliases `instant`/`medium`/`high`/`max` are accepted. `--pro-mode` and `--effort` are different model axes and cannot be combined.
-- `--project "name"` enters an existing sidebar project before sending. Creating a new project from the CLI is not supported yet; make it in ChatGPT first, then pass `--project`.
+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 `--effort`/`--pro-mode`/`--project` flags will fail with "menu item not found"; either switch the UI language, send without selection flags, or use the escape hatch: `--model "<exact label>"` clicks any radio entry in the picker by the exact text your UI shows (run `pro browser models` to list them).
 
-Persist defaults so you can omit these flags on routine asks; a per-ask flag always overrides the saved default:
+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. `--project-new "name"` creates a new project (sidebar 새 프로젝트 popover, committed with Enter) and sends inside it. Neither can be combined with `--target-url` (the project step would navigate away from the confirmed tab), and `--project-new` never comes from saved defaults — creating a project is always an explicit per-ask choice.
+
+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`, clear one with the matching `--clear-*` flag, or answer a short wizard instead of remembering flags:
 
 ```bash
 prodex setup --model Pro --pro-mode 확장 --project "my-project"
+prodex setup --clear-project
+prodex setup --interactive   # asks model / Pro sub-mode or effort / project
 ```
 
-Whatever selection is applied is recorded on the consult receipt (`metadata.selection`). `prodex` only clicks the picker you can see; it never selects a model, effort, or project silently outside the visible browser.
+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:
 
@@ -230,6 +242,14 @@ prodex results reseal <task-id> --confirm-current-result
 
 This writes a new local `task_completed` receipt for the current result payload. Prefer the explicit task id you just reviewed; `latest` is accepted for convenience but resolves from the current raw result list at execution time. It does not reseal unsigned receipts, forged receipts, or receipts that already point at a different result digest.
 
+Receipts are HMAC-signed with a local key in `.bridge/receipt-key.local`. If you suspect the key was exposed, rotate it:
+
+```bash
+prodex receipts rotate-key
+```
+
+New receipts are signed with the fresh key; previous keys stay in the file (verification only) so receipts signed before the rotation remain trusted.
+
 To send into a specific visible Project or thread, open that ChatGPT URL in the dedicated browser first, confirm it is the right destination, then pass the same URL:
 
 ```bash

package/dist/chatgpt-browser.d.ts

@@ -128,12 +128,33 @@ 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 newProjectButtonRectExpression(): string;
+export declare function newProjectNameInputRectExpression(): string;
+export declare function newProjectNameInputVisibleExpression(): 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

@@ -84,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;
 }
@@ -396,57 +403,128 @@ export async function getChatGptBrowserStatus(options = {}) {
         blocker
     };
 }
-async function dispatchMouseClickAt(cdp, x, y) {
-    await cdp.send("Input.dispatchMouseEvent", { type: "mouseMoved", x, y });
-    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 });
-}
 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 });
 }
-export function modelButtonRectExpression() {
+// 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);
+      return /\\S/.test(t) && !/파일|첨부|받아쓰기|음성|dictation|attach|file|voice|record|search|mic/i.test(t + aria);
     });
     if (!b) return { ok: false, reason: "model selector button not found" };
-    const r = b.getBoundingClientRect();
-    return { ok: true, x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+    return clickPoint(b);
   })()`;
 }
 export function menuItemRectExpression(label) {
-    return `(() => {
+    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 r = it.getBoundingClientRect();
-    return { ok: true, x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+    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 `(() => {
+    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" };
-    const r = it.getBoundingClientRect();
-    return { ok: true, x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+    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 `(() => {
+    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 = [...m.querySelectorAll('[role="menuitemradio"]')].find((r) => (r.textContent || "").trim() === "Pro");
+    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) => {
@@ -460,12 +538,11 @@ export function proSubmenuExpanderRectExpression() {
       if (dy < bestDy) { best = e; bestDy = dy; }
     }
     if (!best || bestDy > 40) return { ok: false, reason: "Pro sub-mode expander not found next to Pro" };
-    const r = best.getBoundingClientRect();
-    return { ok: true, x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+    return clickPoint(best);
   })()`;
 }
 export function projectItemRectExpression(name) {
-    return `(() => {
+    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) {
@@ -476,10 +553,17 @@ export function projectItemRectExpression(name) {
       }
     }
     if (!target) return { ok: false, reason: "project not found in sidebar" };
-    const r = target.getBoundingClientRect();
-    return { ok: true, x: Math.round(r.x + r.width / 2), y: Math.round(r.y + Math.min(r.height / 2, 18)) };
+    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;
@@ -487,52 +571,178 @@ async function selectModelReasoning(cdp, options) {
     if (!button.ok || button.x === undefined || button.y === undefined) {
         throw new Error(button.reason ?? "Could not open the ChatGPT model selector");
     }
-    await dispatchMouseClickAt(cdp, button.x, button.y);
-    await sleep(1000);
-    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) {
+    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);
-            throw new Error(expander.reason ?? "Could not open the ChatGPT Pro sub-mode submenu");
+            return;
         }
-        await dispatchMouseClickAt(cdp, expander.x, expander.y);
-        await sleep(900);
-        const subLabel = `Pro ${options.proMode}`;
-        const sub = await cdp.evaluate(submenuItemRectExpression(subLabel));
-        if (!sub.ok || sub.x === undefined || sub.y === undefined) {
+        // --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);
-            throw new Error(`ChatGPT Pro sub-mode not found: ${subLabel}`);
         }
-        await dispatchMouseClickAt(cdp, sub.x, sub.y);
-        await sleep(400);
-        return;
+        catch {
+            // best effort only
+        }
+        throw error;
     }
-    const primaryLabel = options.model ?? options.effort;
-    if (!primaryLabel) {
-        await dispatchEscapeKey(cdp);
-        return;
+}
+export function newProjectButtonRectExpression() {
+    return `(() => {${CLICK_POINT_SNIPPET}
+    const el =
+      document.querySelector('button[aria-label="새 프로젝트"]') ||
+      [...document.querySelectorAll('button,[role="button"]')].find((b) =>
+        /새 프로젝트|new project/i.test(((b.textContent || "") + (b.getAttribute("aria-label") || "")).trim())
+      );
+    if (!el) return { ok: false, reason: "new-project button not found in the sidebar" };
+    return clickPoint(el);
+  })()`;
+}
+// The new-project popover has a single visible text input for the name;
+// creation is committed by pressing Enter (there is no dedicated create button).
+const VISIBLE_TEXT_INPUT_FINDER = `
+    const findNameInput = () =>
+      [...document.querySelectorAll('input[type="text"]')].find((i) => {
+        const r = i.getBoundingClientRect();
+        return r.width > 0 && r.height > 0;
+      });`;
+export function newProjectNameInputRectExpression() {
+    return `(() => {${CLICK_POINT_SNIPPET}${VISIBLE_TEXT_INPUT_FINDER}
+    const input = findNameInput();
+    if (!input) return { ok: false, reason: "new-project name input did not appear" };
+    return clickPoint(input);
+  })()`;
+}
+export function newProjectNameInputVisibleExpression() {
+    return `(() => {${VISIBLE_TEXT_INPUT_FINDER}
+    return Boolean(findNameInput());
+  })()`;
+}
+function newProjectNameInputValueExpression() {
+    return `(() => {${VISIBLE_TEXT_INPUT_FINDER}
+    const input = findNameInput();
+    return input ? input.value : null;
+  })()`;
+}
+async function dispatchEnterKey(cdp) {
+    await cdp.send("Input.dispatchKeyEvent", { type: "keyDown", key: "Enter", code: "Enter", windowsVirtualKeyCode: 13, text: "\r" });
+    await cdp.send("Input.dispatchKeyEvent", { type: "keyUp", key: "Enter", code: "Enter", windowsVirtualKeyCode: 13 });
+}
+// Creates a project in the user's real ChatGPT account: sidebar 새 프로젝트 →
+// type the name into the popover input → Enter → wait for navigation into the
+// new project. Backs out with Escape on any failure.
+async function createChatGptProject(cdp, name) {
+    const hrefBefore = await cdp.evaluate("location.href");
+    const button = await cdp.evaluate(newProjectButtonRectExpression());
+    if (!button.ok || button.x === undefined || button.y === undefined) {
+        throw new Error(button.reason ?? "new-project button not found in the sidebar");
     }
-    const primary = await cdp.evaluate(menuItemRectExpression(primaryLabel));
-    if (!primary.ok || primary.x === undefined || primary.y === undefined) {
-        await dispatchEscapeKey(cdp);
-        throw new Error(`ChatGPT model/effort option not found: ${primaryLabel}${primary.available ? ` (available: ${primary.available.join(", ")})` : ""}`);
+    try {
+        await verifiedClickAt(cdp, button.x, button.y, "새 프로젝트");
+        const inputVisible = await waitForExpressionTrue(cdp, newProjectNameInputVisibleExpression(), MENU_OPEN_TIMEOUT_MS);
+        if (!inputVisible)
+            throw new Error("new-project name input did not appear");
+        const input = await cdp.evaluate(newProjectNameInputRectExpression());
+        if (!input.ok || input.x === undefined || input.y === undefined) {
+            throw new Error(input.reason ?? "new-project name input is not clickable");
+        }
+        await verifiedClickAt(cdp, input.x, input.y, "project name input");
+        await sleep(150);
+        await cdp.send("Input.insertText", { text: name });
+        await sleep(150);
+        const typed = await cdp.evaluate(newProjectNameInputValueExpression());
+        if (typed !== name) {
+            throw new Error(`could not type the project name into the new-project input (saw: ${typed === null ? "no input" : JSON.stringify(typed)})`);
+        }
+        await dispatchEnterKey(cdp);
+        const navigated = await waitForExpressionTrue(cdp, `location.href !== ${JSON.stringify(hrefBefore)}`, PROJECT_NAVIGATION_TIMEOUT_MS);
+        if (!navigated)
+            throw new Error(`Creating project "${name}" did not navigate into the new project`);
+        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 creating project "${name}"`);
+    }
+    catch (error) {
+        try {
+            await dispatchEscapeKey(cdp);
+            await sleep(150);
+            await dispatchEscapeKey(cdp);
+        }
+        catch {
+            // best effort only
+        }
+        throw error;
     }
-    await dispatchMouseClickAt(cdp, primary.x, primary.y);
-    await sleep(400);
 }
 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");
+        await createChatGptProject(cdp, options.projectNew);
+        return;
     }
-    if (options.project) {
-        const hit = await cdp.evaluate(projectItemRectExpression(options.project));
-        if (!hit.ok || hit.x === undefined || hit.y === undefined) {
-            throw new Error(`ChatGPT project not found in sidebar: ${options.project}`);
-        }
-        await dispatchMouseClickAt(cdp, hit.x, hit.y);
-        await sleep(1200);
+    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) {
@@ -566,12 +776,16 @@ export async function sendChatGptPrompt(options) {
     if (busyBlocker) {
         throw new ChatGptBrowserBlockerError(busyBlocker);
     }
-    const beforeSubmit = await evaluateOnPage(page, answerExpression());
+    let beforeSubmit;
     const cdp = await connectCdp(page.webSocketDebuggerUrl);
     try {
         await cdp.send("Runtime.enable");
         await selectProject(cdp, options);
         await selectModelReasoning(cdp, options);
+        // Capture the answer baseline AFTER any project navigation or model switch
+        // so assistant-message counts compare within the thread we actually send
+        // into; a --project/--project-new hop lands on a page with its own counts.
+        beforeSubmit = await evaluateOnPage(page, answerExpression());
         const inserted = await cdp.evaluate(setComposerTextExpression(options.prompt));
         if (!inserted.ok)
             throw new Error(inserted.reason ?? "Could not insert text into ChatGPT composer");
@@ -638,6 +852,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) });
@@ -810,7 +1089,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,
@@ -960,7 +1241,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,