@youdie006/prodex 0.38.1 → 0.39.1

package/dist/chatgpt-browser.js

@@ -6,7 +6,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { captureBrowserDiagnostics, diagnosticsEnabled, diagnosticsNote } from "./browser-diagnostics.js";
 import os from "node:os";
-import { readPowerSliderSelection } from "./picker-interaction.js";
+import { chatSurfaceChoice, menuKeyboardStep, readPowerSliderSelection, sliderRestoreStep } from "./picker-interaction.js";
 export class ChatGptBrowserBlockerError extends Error {
     blocker;
     constructor(blocker) {
@@ -20,7 +20,15 @@ export class ChatGptBrowserBlockerError extends Error {
 // of this control rather than a model. Leaving it out meant --effort could not
 // reach the top of the slider at all, and the only route there - --model Pro -
 // answered with advice to "say --effort Pro", which then failed.
-const REASONING_EFFORTS = ["즉시", "중간", "높음", "매우 높음", "Pro"];
+/** A full trip round the menu is far more than any real picker needs. */
+const MENU_KEYBOARD_WALK_LIMIT = 16;
+/** Enough presses to cross any slider this code accepts, twice over. */
+const POWER_SLIDER_RESTORE_ATTEMPTS = 26;
+// Two more rungs than before. Measured live: with the model row chosen rather
+// than the recommended set, the slider reads Light / Medium / High / Extra High
+// / Max / Ultra, and Ultra is the top of the machine. Pro is kept because older
+// pickers still name the top step that way.
+const REASONING_EFFORTS = ["즉시", "중간", "높음", "매우 높음", "Max", "Ultra", "Pro"];
 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.
@@ -29,19 +37,26 @@ const REASONING_EFFORT_ALIASES = {
     instant: "즉시",
     medium: "중간",
     high: "높음",
-    max: "매우 높음",
     extrahigh: "매우 높음",
+    max: "매우 높음",
+    light: "즉시",
+    "가벼움": "즉시",
+    "최대": "Max",
+    ultra: "Ultra",
+    "울트라": "Ultra",
     pro: "Pro",
     "프로": "Pro"
 };
 // Menu labels per canonical value, verified live in both the Korean and the
 // English (US) ChatGPT UI. Matching tries every candidate so either UI works.
 const EFFORT_MENU_LABELS = {
-    "즉시": ["즉시", "Instant"],
+    "즉시": ["즉시", "Instant", "Light"],
     "중간": ["중간", "Medium"],
     "높음": ["높음", "High"],
     "매우 높음": ["매우 높음", "Extra High"],
-    Pro: ["Pro", "프로"]
+    Max: ["Max", "최대"],
+    Ultra: ["Ultra", "울트라"],
+    Pro: ["Pro", "프로", "6-pro", "GPT-6 Pro", "6 Pro"]
 };
 const PRO_MODE_SUBMENU_LABELS = {
     "기본": ["Pro 기본", "Pro Standard", "Standard", "기본"],
@@ -60,7 +75,7 @@ export function parseReasoningEffort(raw) {
     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(", ")} (English aliases: instant, medium, high, max)`);
+    throw new Error(`--effort must be one of ${REASONING_EFFORTS.join(", ")} (English aliases: instant/light, medium, high, extrahigh, max, ultra)`);
 }
 /** Normalize a CLI Pro sub-mode value onto the exact ChatGPT menu label. */
 export function parseProMode(raw) {
@@ -1422,6 +1437,52 @@ export function powerSliderStateExpression() {
     };
   })()`;
 }
+export function activeMenuItemExpression() {
+    return `(() => {
+    const a = document.activeElement;
+    if (!a) return null;
+    const menu = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
+    if (menu && !menu.contains(a)) return null;
+    const label = ((a.innerText || a.textContent || "").trim().split(String.fromCharCode(10))[0] || "").trim();
+    return { role: a.getAttribute("role"), label };
+  })()`;
+}
+export function chatWorkSurfaceExpression() {
+    return `(() => {${CLICK_POINT_SNIPPET}
+    const buttons = [...document.querySelectorAll('[role="radio"],[role="tab"]')].filter((el) => {
+      const t = ((el.innerText || el.textContent || "").trim());
+      return t === "Chat" || t === "Work";
+    });
+    const surfaces = buttons.map((el) => ({
+      label: ((el.innerText || el.textContent || "").trim()),
+      checked: el.getAttribute("aria-checked") === "true" || el.getAttribute("aria-selected") === "true"
+    }));
+    const chat = buttons.find((el) => ((el.innerText || el.textContent || "").trim()) === "Chat");
+    return { surfaces, chat: chat ? clickPoint(chat) : { ok: false, reason: "no Chat toggle" } };
+  })()`;
+}
+export function powerSliderPresentExpression() {
+    return `Boolean(document.querySelector('[data-testid="composer-intelligence-picker-content"] [role="slider"]'))`;
+}
+export function pickerClosedExpression() {
+    return `!document.querySelector('[data-testid="composer-intelligence-picker-content"]')`;
+}
+export function focusPickerMenuExpression() {
+    return `(() => {
+    const menu = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
+    if (!menu) return { ok: false, reason: "picker menu not open" };
+    // Leave the focus the menu gave itself. It opens on the checked model row,
+    // and ArrowDown from there walks the model list. Focusing the first item
+    // instead lands on the label row above the slider, where ArrowDown only
+    // cycles that row's own widgets - measured as four steps that repeat
+    // forever and never reach a radio.
+    if (menu.contains(document.activeElement)) return { ok: true };
+    const radios = [...menu.querySelectorAll('[role="menuitemradio"]')];
+    const target = radios.find((r) => r.getAttribute("aria-checked") === "true") || radios[0];
+    if (target && typeof target.focus === "function") target.focus();
+    return { ok: menu.contains(document.activeElement) };
+  })()`;
+}
 export function focusPowerSliderExpression() {
     return `(() => {
     const slider = document.querySelector('[role="slider"]');
@@ -1680,7 +1741,45 @@ export function stepSelectionUnavailableWarning(requested, offered) {
     return (`step_not_applied: this ChatGPT picker has no "${requested}" step, so the send used the slider's current setting.${list} ` +
         'Pick one of those with --effort, or clear a saved default with `prodex setup --clear-model`.');
 }
+/**
+ * Choose a model row through the menu's roving focus.
+ *
+ * The rows carry pointer-events: none and sit outside the menu's box, so
+ * verifiedClickAt refuses them and .focus() is declined. ArrowDown from the row
+ * the menu opens on does reach them, and Enter commits. Doing this BEFORE the
+ * slider matters: with the recommended set active the slider walks a short
+ * mixed ladder ending at Extra High, and picking the model swaps in that
+ * model's own ladder, which continues past it.
+ */
+async function selectPickerModelByKeyboard(cdp, candidates) {
+    const focused = await cdp.evaluate(focusPickerMenuExpression());
+    if (!focused?.ok)
+        return false;
+    const limit = MENU_KEYBOARD_WALK_LIMIT;
+    for (let pressed = 0;; pressed += 1) {
+        const active = await cdp.evaluate(activeMenuItemExpression());
+        const move = menuKeyboardStep({ active, requested: candidates, pressed, limit });
+        if (move === "exhausted")
+            return false;
+        if (move === "select") {
+            await dispatchMenuKey(cdp, "Enter", 13);
+            // Committing closes the menu. Waiting for it to finish closing keeps the
+            // reopen below from landing mid-animation and toggling it shut again.
+            await waitForExpressionTrue(cdp, pickerClosedExpression(), 3_000);
+            return true;
+        }
+        await dispatchMenuKey(cdp, "ArrowDown", 40);
+        await sleep(140);
+    }
+}
+async function dispatchMenuKey(cdp, key, code) {
+    for (const type of ["keyDown", "keyUp"]) {
+        await cdp.send("Input.dispatchKeyEvent", { type, key, code: key, windowsVirtualKeyCode: code });
+    }
+}
 async function selectPickerModel(cdp, requested, warnings = []) {
+    if (await selectPickerModelByKeyboard(cdp, [requested]))
+        return;
     const hit = await cdp.evaluate(menuItemRectExpression(requested));
     if (!hit.ok || hit.x === undefined || hit.y === undefined) {
         const unavailable = modelSelectionUnavailableWarning(requested, hit.reason ?? "", hit.available);
@@ -1692,6 +1791,56 @@ async function selectPickerModel(cdp, requested, warnings = []) {
     }
     await verifiedClickWithRetry(cdp, () => cdp.evaluate(menuItemRectExpression(requested)), requested);
 }
+/**
+ * Make sure the composer picker is open, reopening it if it is not.
+ *
+ * Committing a model row closes the menu, and the slider lives inside it - so
+ * without this the step that follows reported "the picker did not expose its
+ * power slider" on a picker that was simply shut.
+ */
+/**
+ * Put the browser back on ChatGPT's Chat surface when it has drifted onto Work.
+ *
+ * The two have different pickers - Work's offers no Pro at all - and nothing on
+ * the page announces which one is live, so a drifted browser silently drives
+ * the wrong picker. Returns a warning to carry to the caller when it moved.
+ */
+async function ensureChatSurface(cdp) {
+    let probe;
+    try {
+        probe = await cdp.evaluate(chatWorkSurfaceExpression());
+    }
+    catch {
+        return undefined;
+    }
+    if (!probe)
+        return undefined;
+    if (chatSurfaceChoice(probe.surfaces ?? []) !== "switch-to-chat")
+        return undefined;
+    const chat = probe.chat;
+    if (!chat?.ok || chat.x === undefined || chat.y === undefined) {
+        return "ChatGPT is on its Work surface, whose picker offers different models and no Pro, and the Chat toggle could not be clicked.";
+    }
+    await verifiedClickAt(cdp, chat.x, chat.y, "Chat surface toggle");
+    await sleep(1_500);
+    return "ChatGPT was on its Work surface, whose picker offers different models and no Pro. Switched back to Chat.";
+}
+async function ensurePickerOpen(cdp) {
+    // The slider, not the menu, is what the caller needs - and an open menu that
+    // has not painted its slider yet looks identical to one that has.
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (await cdp.evaluate(powerSliderPresentExpression()))
+            return true;
+        await waitForExpressionTrue(cdp, pickerClosedExpression(), 1_500);
+        const button = await cdp.evaluate(modelButtonRectExpression());
+        if (!button.ok || button.x === undefined || button.y === undefined)
+            return false;
+        await verifiedClickAt(cdp, button.x, button.y, "model selector");
+        if (await waitForExpressionTrue(cdp, powerSliderPresentExpression(), MENU_OPEN_TIMEOUT_MS))
+            return true;
+    }
+    return false;
+}
 async function selectPowerStep(cdp, requested) {
     // The menu paints a moment after it opens, and on a page that has just been
     // built - a project created seconds ago - that moment is longer. Failing the
@@ -1764,6 +1913,11 @@ export function sliderWalkPlan(state) {
 async function selectModelReasoning(cdp, options, selectionWarnings = []) {
     if (!options.model && !options.proMode && !options.effort)
         return;
+    // Which surface is live decides which picker exists at all, so settle that
+    // before looking for anything in it.
+    const surfaceWarning = await ensureChatSurface(cdp);
+    if (surfaceWarning)
+        selectionWarnings.push(surfaceWarning);
     // --pro-mode selects a Pro sub-mode, so it is meaningless with a non-Pro
     // --model. Fail loudly instead of silently dropping the requested sub-mode.
     if (options.proMode && options.model && !/pro/i.test(options.model)) {
@@ -1800,7 +1954,11 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
         // the whole send). Retry briefly with FRESH coordinates; a persistent
         // cover still fails with the refusal message.
         const clickDeadline = Date.now() + 5_000;
-        for (;;) {
+        // Clicking the trigger TOGGLES the picker, so clicking one that is already
+        // open shuts it and the next step reports "power slider not found" about a
+        // control that was on screen a moment earlier.
+        const alreadyOpen = await cdp.evaluate(powerSliderPresentExpression());
+        for (; !alreadyOpen;) {
             try {
                 await verifiedClickAt(cdp, button.x, button.y, "model selector");
                 break;
@@ -1832,7 +1990,16 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
             });
             if (plan.warning)
                 selectionWarnings.push(plan.warning);
+            // The model goes first: choosing it replaces the ladder the slider walks,
+            // so a step picked before it would be a step of the old ladder.
+            if (plan.modelLabel) {
+                await selectPickerModel(cdp, plan.modelLabel, selectionWarnings);
+            }
             if (plan.sliderLabel) {
+                // Committing the model closed the menu; the slider is inside it.
+                if (!(await ensurePickerOpen(cdp))) {
+                    throw new Error("ChatGPT's model picker would not reopen after the model was chosen.");
+                }
                 try {
                     await selectPowerStep(cdp, plan.sliderLabel);
                 }
@@ -1847,9 +2014,6 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
                     selectionWarnings.push(stepSelectionUnavailableWarning(plan.sliderLabel, offered));
                 }
             }
-            if (plan.modelLabel) {
-                await selectPickerModel(cdp, plan.modelLabel, selectionWarnings);
-            }
             // This branch cannot honour a sub-mode, and used to return without
             // saying so - the caller got a clean receipt for a 확장 it never got.
             const proModeWarning = proModeNotAppliedWarning(options.proMode, sliderState.effort ?? undefined);
@@ -2839,7 +3003,11 @@ export function modelMenuOptionsExpression() {
     return `(() => {
     const m = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
     if (!m) return [];
-    return [...m.querySelectorAll('[role="menuitemradio"],[role="menuitem"]')]
+    // Only the radios are models. The plain menuitems above them are the power
+    // slider's own rows - its track, and the label pair naming the current model
+    // and effort - and listing those put GPT-6 Astra in twice and Extra High in
+    // as if it were a model.
+    return [...m.querySelectorAll('[role="menuitemradio"]')]
       .map((it) => {
         // A submenu row renders as label over value ("Model" / "GPT-5.6 Sol"),
         // and the value is the part a person actually wants to read.
@@ -3260,44 +3428,75 @@ export async function listChatGptSidebarProjects(input = {}) {
  * listing exactly as it was rather than failing a read-only command.
  */
 async function readEffortSteps(cdp) {
+    const focused = await cdp.evaluate(focusPowerSliderExpression());
+    if (!focused?.ok)
+        return undefined;
+    const start = await cdp.evaluate(powerSliderStateExpression());
+    if (!start?.ok)
+        return undefined;
+    const plan = sliderWalkPlan({ position: start.position, min: start.min, max: start.max });
+    if (!plan)
+        return undefined;
+    const current = start.effort ?? null;
+    const startedAt = start.position;
     try {
-        const focused = await cdp.evaluate(focusPowerSliderExpression());
-        if (!focused?.ok)
-            return undefined;
-        const start = await cdp.evaluate(powerSliderStateExpression());
-        if (!start?.ok)
-            return undefined;
-        const plan = sliderWalkPlan({ position: start.position, min: start.min, max: start.max });
-        if (!plan)
-            return undefined;
-        const current = start.effort ?? null;
         for (let i = 0; i < plan.toBottom; i += 1) {
             await dispatchArrowKey(cdp, "ArrowLeft");
             await sleep(120);
         }
-        const labels = [];
+        // Every position is recorded, including repeats. The slider can walk a
+        // ladder of model-and-effort pairs, so one effort name is several rungs -
+        // collapsing by label lost which model each one would send with.
+        const rungs = [];
         const record = async () => {
             const state = await cdp.evaluate(powerSliderStateExpression());
-            const label = state?.effort?.trim();
-            if (label && !labels.includes(label))
-                labels.push(label);
+            if (!state?.ok)
+                return;
+            const effort = state.effort?.trim();
+            if (!effort)
+                return;
+            rungs.push({ position: state.position ?? rungs.length, model: state.model?.trim() || null, effort });
         };
         await record();
         for (let i = 0; i < plan.climb; i += 1) {
             await dispatchArrowKey(cdp, "ArrowRight");
-            await sleep(120);
+            await sleep(220);
             await record();
         }
-        // Put it back. Reading someone's setting must not change it.
-        for (let i = 0; i < plan.climb - plan.back; i += 1) {
-            await dispatchArrowKey(cdp, "ArrowLeft");
-            await sleep(120);
-        }
-        return labels.length > 0 ? { labels, current } : undefined;
+        return rungs.length > 0 ? { rungs, current } : undefined;
     }
     catch {
         return undefined;
     }
+    finally {
+        // Whatever happened above, the setting goes back. Replaying a precomputed
+        // count skipped this whenever the walk was interrupted, and one run left a
+        // slider on High that had been on Pro.
+        await restorePowerSlider(cdp, startedAt);
+    }
+}
+async function restorePowerSlider(cdp, target) {
+    for (let guard = 0; guard < POWER_SLIDER_RESTORE_ATTEMPTS; guard += 1) {
+        let state;
+        try {
+            state = await cdp.evaluate(powerSliderStateExpression());
+        }
+        catch {
+            return;
+        }
+        if (!state?.ok)
+            return;
+        const move = sliderRestoreStep({ ...(state.position !== undefined ? { current: state.position } : {}), ...(target !== undefined ? { target } : {}) });
+        if (move === "done")
+            return;
+        try {
+            await dispatchArrowKey(cdp, move === "left" ? "ArrowLeft" : "ArrowRight");
+        }
+        catch {
+            return;
+        }
+        await sleep(150);
+    }
 }
 export async function listChatGptModelOptions(input = {}) {
     const port = resolveCdpPort(input.port);
@@ -3333,7 +3532,18 @@ export async function listChatGptModelOptions(input = {}) {
                 throw new Error("ChatGPT model menu did not open after clicking the selector");
             const options = await cdp.evaluate(modelMenuOptionsExpression());
             const effortSteps = await readEffortSteps(cdp);
-            return { url: status.url, options, ...(effortSteps ? { effortSteps } : {}) };
+            // Chat and Work have different pickers - Work's offers no Pro - and a
+            // listing that does not say which one it read is how a browser sitting on
+            // Work convinced two machines that Pro had been removed from the account.
+            let surface;
+            try {
+                const probe = await cdp.evaluate(chatWorkSurfaceExpression());
+                surface = probe?.surfaces?.find((entry) => entry.checked)?.label;
+            }
+            catch {
+                // the toggle predates some builds; saying nothing is right there
+            }
+            return { url: status.url, options, ...(effortSteps ? { effortSteps } : {}), ...(surface ? { surface } : {}) };
         }
         finally {
             try {

package/dist/cli-pro.js

@@ -443,17 +443,27 @@ export async function runProCommand(rest, io, runCliFn) {
                 });
                 throw new Error(blocker.next_step ? `${blocker.message} Next: ${blocker.next_step}` : errorMessage(error));
             }
+            if (listed.surface) {
+                io.stdout(`Read from ChatGPT's ${listed.surface} surface. Chat and Work have different pickers - only one of them offers Pro.`);
+            }
             io.stdout("Model menu options in the visible ChatGPT tab (read-only; nothing was selected):");
             for (const option of listed.options) {
                 io.stdout(formatModelMenuOption(option));
             }
             if (listed.effortSteps) {
                 io.stdout("");
-                io.stdout("Effort steps on this account (the slider was walked and put back):");
-                for (const label of listed.effortSteps.labels) {
-                    io.stdout(`${label === listed.effortSteps.current ? "*" : " "} ${label}`);
+                // One slider walks a ladder of model-and-effort pairs, so the same
+                // effort name appears at more than one rung with a different model
+                // behind it. Printing bare names hid that.
+                io.stdout("Power slider on this account (the slider was walked and put back):");
+                const rungs = listed.effortSteps.rungs;
+                const width = String(rungs.length).length;
+                for (const rung of rungs) {
+                    const here = rung.effort === listed.effortSteps.current ? "*" : " ";
+                    const step = String(rung.position + 1).padStart(width, " ");
+                    io.stdout(`${here} ${step}/${rungs.length}  ${rung.model ?? "?"}  -  ${rung.effort}`);
                 }
-                io.stdout("Pass any of these to --effort. The list is complete: the slider shows one step at a time, so reading it any other way sees only the current one.");
+                io.stdout("Each row is one position of that single slider: it sets the model and the effort together, so they cannot be chosen apart. The list is complete - the slider shows one position at a time, so reading it any other way sees only the current one.");
             }
             else {
                 io.stdout("An arrow shows what that row is set to now; --model / --effort reach into those submenus (e.g. --model Pro).");

package/dist/config.js

@@ -11,7 +11,7 @@ const BrowserDefaultsSchema = z.object({
     model: z.string().min(1).optional(),
     pro_mode: z.enum(["기본", "확장"]).optional(),
     // Pro is the slider's fifth step, so a saved default may name it.
-    effort: z.enum(["즉시", "중간", "높음", "매우 높음", "Pro"]).optional(),
+    effort: z.enum(["즉시", "중간", "높음", "매우 높음", "Max", "Ultra", "Pro"]).optional(),
     project: z.string().min(1).optional()
 });
 const LocalConfigSchema = z.object({

package/dist/picker-interaction.js

@@ -10,6 +10,7 @@ export function readPowerSliderSelection(snapshot) {
     }));
     const powerLabels = new Set([
         "instant",
+        "light",
         "즉시",
         "빠름",
         "fast",
@@ -29,12 +30,70 @@ export function readPowerSliderSelection(snapshot) {
     const legacyModel = items.find((item) => item.lines[0] === "Model")?.lines[1] ?? null;
     const legacyEffort = items.find((item) => item.lines[0] === "Effort")?.lines[1] ?? null;
     const checkedModel = items.find((item) => item.role === "menuitemradio" && item.checked)?.lines[0] ?? null;
-    const sliderOwner = items.find((item) => item.role === "menuitem" && item.containsSlider)?.lines[0] ?? null;
+    // The slider stopped being an effort control: one slider now walks a ladder of
+    // model-and-effort pairs, and a row above the track reads "<model>" then
+    // "<effort>". Measured live, that pair sits in a SIBLING row - the row that
+    // literally contains the slider carries no text - so the pair is found by its
+    // shape rather than by ownership of the track. Reading the pair's first line
+    // as the effort is what made the listing announce "Extra High" as a model.
+    const pairRow = items.find((item) => item.role === "menuitem" && item.lines.length >= 2 && item.lines[0] !== "Model" && item.lines[0] !== "Effort");
+    const owner = items.find((item) => item.role === "menuitem" && item.containsSlider);
+    const sliderOwnerModel = pairRow?.lines[0] ?? null;
+    // A single-line row is the older form, where it carried only the step name.
+    const sliderOwner = pairRow?.lines[1] ?? (owner && owner.lines.length === 1 ? owner.lines[0] : null) ?? null;
     const visiblePowerLabel = items.find((item) => item.role === "menuitem" && powerLabels.has((item.lines[0] ?? "").toLowerCase()))?.lines[0] ?? null;
     const accessibleCandidate = snapshot.sliderValueText?.trim() || null;
     const accessibleValue = accessibleCandidate && powerLabels.has(accessibleCandidate.toLowerCase()) ? accessibleCandidate : null;
     return {
-        model: legacyModel ?? checkedModel,
+        // The checked radio is "Default" - the recommended set - while the slider
+        // decides the model a send actually uses, so the slider's row wins.
+        model: legacyModel ?? sliderOwnerModel ?? checkedModel,
         effort: accessibleValue ?? legacyEffort ?? sliderOwner ?? visiblePowerLabel
     };
 }
+/**
+ * Decide the next move when walking the composer picker's menu by keyboard.
+ *
+ * The model rows carry pointer-events: none and refuse focus(), so the menu's
+ * own roving focus is the only way to reach them. Only a radio counts as the
+ * target: the row above the slider repeats the model name as its first line,
+ * and committing there selects nothing.
+ */
+export function menuKeyboardStep(input) {
+    const { active, requested, pressed, limit } = input;
+    if (!active)
+        return "exhausted";
+    if (active.role === "menuitemradio") {
+        const label = active.label.trim().toLowerCase();
+        if (requested.some((candidate) => candidate.trim().toLowerCase() === label))
+            return "select";
+    }
+    return pressed < limit ? "down" : "exhausted";
+}
+/**
+ * One move towards putting the power slider back where the walk found it.
+ *
+ * Driven by the position actually read rather than by a replayed count, so an
+ * interrupted walk still converges instead of abandoning the setting wherever
+ * it stopped.
+ */
+export function sliderRestoreStep(input) {
+    const { current, target } = input;
+    if (!Number.isInteger(current) || !Number.isInteger(target))
+        return "done";
+    if (current === target)
+        return "done";
+    return current > target ? "left" : "right";
+}
+/**
+ * Decide whether the browser needs putting back on ChatGPT's Chat surface.
+ *
+ * Chat and Work have different model pickers - Work's has no Pro at all - so a
+ * browser that has drifted onto Work silently drives the wrong one.
+ */
+export function chatSurfaceChoice(surfaces) {
+    const chat = surfaces.find((surface) => surface.label.trim().toLowerCase() === "chat");
+    if (!chat)
+        return "no-toggle";
+    return chat.checked ? "already-chat" : "switch-to-chat";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdie006/prodex",
-  "version": "0.38.1",
+  "version": "0.39.1",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",