copilot-operator 0.1.34 → 0.1.36

package/dist/src/api/operator.service.js

@@ -1102,6 +1102,7 @@ let OperatorService = class OperatorService {
             // The page is the source of the model names: Settings and the saved list follow it (see `ModelHooks`).
             models: {
                 locate: async (name) => (await this.store.getModels())?.options.find((o) => sameModel(o.name, name))?.locator,
+                askHelp: (ask) => this.askModelHelp(ask, controller.signal),
                 renamedDefault: async (which, from, to) => {
                     const now = (await this.settings.load()).copilot;
                     if (which === 'model' && (now.defaultModel ?? '').trim() === from)
@@ -1866,6 +1867,34 @@ let OperatorService = class OperatorService {
         };
     }
     // --- approvals ------------------------------------------------------------------------
+    /**
+     * Asks the operator to choose the model in the Copilot window, when the runner could not (operator's
+     * request, 2026-10-06). It waits on the approvals card like a held step, in every mode, until it is
+     * answered or the run is stopped.
+     */
+    askModelHelp(ask, signal) {
+        return new Promise((resolveAnswer) => {
+            if (signal.aborted) {
+                resolveAnswer('stop');
+                return;
+            }
+            const approval = {
+                id: newId('a-'),
+                sessionId: ask.sessionId,
+                taskId: '',
+                stepId: 0,
+                description: ask.asked ? `Choose "${ask.asked}" in the Copilot window` : 'Choose the model in the Copilot window',
+                createdAt: new Date().toISOString(),
+                model: { asked: ask.asked, shown: ask.shown, why: ask.why, tries: ask.tries, ...(ask.manual ? { manual: true } : {}) },
+            };
+            this.waiting.set(approval.id, {
+                approval,
+                resolve: (d) => resolveAnswer(d.action === 'run' ? 'recheck' : d.action === 'skip' ? 'continue' : 'stop'),
+            });
+            this.bus.publish({ sessionId: ask.sessionId, type: 'approval-requested', level: 'warn',
+                message: `choose "${ask.asked}" in the Copilot window, then answer on the card`, data: { approvalId: approval.id, model: approval.model } });
+        });
+    }
     pendingApprovals(sessionId) {
         return [...this.waiting.values()].map((w) => w.approval).filter((a) => !sessionId || a.sessionId === sessionId);
     }
@@ -1952,7 +1981,7 @@ let OperatorService = class OperatorService {
                 if (w.approval.sessionId !== sessionId)
                     continue;
                 // A fetch waits for its own answer: "run the rest without asking" is not an answer to it.
-                if (w.approval.network)
+                if (w.approval.network || w.approval.model)
                     continue;
                 this.waiting.delete(id);
                 w.resolve({ action: 'run' });

package/dist/src/cli.js

@@ -195,7 +195,7 @@ program
         replyTimeoutMs: 60_000,
         signInTimeoutMs: 15 * 60_000,
         humanWaitMs: 15 * 60_000,
-        onEvent: (e, d) => process.stdout.write(`  ${e}${d && Object.keys(d).length ? ' ' + JSON.stringify(d) : ''}
+        onEvent: (e, d) => process.stdout.write(`  ${e}${d && Object.keys(d).length ? ' ' + JSON.stringify(d) : ''}
 `),
     });
     await transport.open();
@@ -383,6 +383,7 @@ program
     .option('--url <url>', 'chat url', Url.chat)
     .option('--json', 'print the raw list, for pasting into an issue')
     .option('--set <name>', 'also switch the chat to this model, by its exact name')
+    .option('--steps', 'with --set: print each step of the choice with its time, and keep a picture of each in runs/_models')
     .action(async (opts) => {
     const transport = new CopilotTransport({
         profileDir: opts.profile,
@@ -392,7 +393,9 @@ program
         headless: false,
         replyTimeoutMs: 60_000,
         signInTimeoutMs: 900_000,
-        onEvent: (e, d) => console.log(`  [${e}]${d ? ' ' + JSON.stringify(d) : ''}`),
+        // The time of each step, to the millisecond: the pauses between them are what is being looked at.
+        onEvent: (e, d) => console.log(`  ${new Date().toISOString().slice(11, 23)} [${e}]${d ? ' ' + JSON.stringify(d) : ''}`),
+        ...(opts.steps ? { modelStepShots: true } : {}),
     });
     try {
         await transport.open();
@@ -488,14 +491,14 @@ program
     console.log('');
     console.log(`task "${done?.title}": ${done?.status} after ${done?.iterations ?? 0} iteration(s)`);
     if (done?.summary)
-        console.log(`
-Summary:
+        console.log(`
+Summary:
 ${done.summary}`);
     if (done?.reason)
-        console.log(`
+        console.log(`
 Reason: ${done.reason}`);
     if (final?.chat)
-        console.log(`
+        console.log(`
 chat: ${final.chat.name} — ${final.chat.url}`);
     if (done?.runId)
         console.log(`log: ${join(cfg.resolved.runsDir, done.runId, 'task-log.txt')}`);
@@ -515,8 +518,8 @@ program
         return;
     }
     const c = withChat.chat;
-    console.log(`${c.name}
-${c.url}
+    console.log(`${c.name}
+${c.url}
 session ${withChat.id}, ${withChat.tasks.length} task(s), created ${c.createdAt}`);
 });
 program.parseAsync(process.argv).catch((e) => {

package/dist/src/config/schema.js

@@ -97,6 +97,12 @@ export const RunConfigSchema = z.object({
          * different from whatever did the work.
          */
         defaultReviewModel: z.string().default(''),
+        /**
+         * Choose the model by hand (operator's workaround, 2026-10-06): at the start of a run, and of a review's
+         * conversation, the runner does not touch the picker; a card in the UI asks the operator to choose the
+         * model in the Copilot window and press "Ready". A conversation already on the model is not asked about.
+         */
+        manualModel: z.boolean().default(false),
         replyTimeoutSec: z.number().int().positive().default(900),
         signInTimeoutSec: z.number().int().positive().default(900),
         humanWaitSec: z.number().int().positive().default(900),

package/dist/src/orchestrator/taskRunner.js

@@ -13,6 +13,7 @@
 import { createHash } from 'node:crypto';
 import { readFile, mkdir, writeFile, appendFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
+import { buttonShows } from '../transport/modelMatch.js';
 import { createTransport, isReplyTimeout } from '../transport/chatTransport.js';
 import { buildChatName, chatCode, loadPointer, savePointer } from '../transport/chatSession.js';
 import { parseReply, formatErrorMessage, findLikelyDamage, damageGuidance } from '../protocol/parser.js';
@@ -532,14 +533,44 @@ export function effectiveModels(session, cfg) {
 async function applySessionModel(transport, session, bus, cfg, store, hooks) {
     const { model: wanted, modelFrom } = effectiveModels(session, cfg);
     const fromSettings = modelFrom === 'settings';
-    if (!wanted)
+    const manual = !!cfg.copilot.manualModel && !!hooks?.askHelp;
+    if (!wanted && !manual)
         return {};
-    const locator = await hooks?.locate?.(wanted).catch(() => undefined);
-    const result = await transport.selectModel(wanted, { locator }).catch((e) => ({
-        ok: false,
-        current: null,
-        reason: e.message,
-    }));
+    let result;
+    if (manual) {
+        /*
+         * Chosen by hand (operator's workaround, 2026-10-06): the picker is not touched. A conversation already
+         * on the model — the chat keeps its model — is not asked about; otherwise the card asks for it.
+         */
+        const shown = await transport.currentModel().catch(() => null);
+        const hand = wanted && buttonShows(shown, wanted)
+            ? { result: { ok: true, current: wanted, by: 'already' }, goOnAsItIs: false }
+            : await withOperatorHand(transport, wanted, { ok: false, current: shown, reason: 'Settings ask for the model to be chosen by hand' }, hooks, session.id, bus, true);
+        if (!wanted) {
+            const now = await transport.currentModel().catch(() => null);
+            if (hand.result.ok || hand.goOnAsItIs) {
+                await store?.updateSession(session.id, (s) => { s.modelInUse = now ?? undefined; }).catch(() => undefined);
+                return { current: now ?? undefined };
+            }
+            return { refused: 'The model was to be chosen by hand, and the operator stopped the run. Nothing was sent.' };
+        }
+        result = hand.result;
+        if (hand.goOnAsItIs) {
+            bus.publish({ sessionId: session.id, type: 'model-selected', level: 'warn', message: `model: ${result.current ?? 'unknown'} (chosen by hand; not "${wanted}")`, data: { asked: wanted, current: result.current, ok: false, by: 'hand' } });
+            return { current: result.current ?? undefined };
+        }
+    }
+    else {
+        const locator = await hooks?.locate?.(wanted).catch(() => undefined);
+        result = await transport.selectModel(wanted, { locator }).catch((e) => ({
+            ok: false,
+            current: null,
+            reason: e.message,
+        }));
+    }
+    const hand = await withOperatorHand(transport, wanted, result, hooks, session.id, bus, false);
+    result = hand.result;
+    const goOnAsItIs = hand.goOnAsItIs;
     const renamed = await followPageModels('model', wanted, result, session, store, hooks, modelFrom);
     if (renamed)
         bus.publish({ sessionId: session.id, type: 'model-renamed', level: 'warn', message: renamed, data: { asked: wanted, chosen: result.matched } });
@@ -550,7 +581,7 @@ async function applySessionModel(transport, session, bus, cfg, store, hooks) {
         message: result.ok
             ? `model: ${result.current ?? wanted} (${modelFrom === 'settings' ? 'from Settings' : modelFrom === 'session' ? "the session's own" : 'from the plan'})`
             : `could not switch to "${wanted}" (${modelFrom === 'settings' ? 'the default model in Settings' : modelFrom === 'session' ? "the session's own" : 'from the plan'}): ${(result.reason ?? 'unknown reason').replace(/[.\s]+$/, '')}. Nothing is sent on ${result.current ?? 'the chat default'} instead.`,
-        data: { asked: wanted, from: modelFrom, fromSettings, current: result.current, ok: result.ok, by: result.by ?? null, savedLocator: !!locator },
+        data: { asked: wanted, from: modelFrom, fromSettings, current: result.current, ok: result.ok, by: result.by ?? null, manual },
     });
     // Kept on the session, so each task's record says which model it ran on and why (see `runTask`).
     await store
@@ -570,6 +601,8 @@ async function applySessionModel(transport, session, bus, cfg, store, hooks) {
      * A model the operator chose and the chat is not on is not worked around: the run went on Auto with a
      * warning nobody saw, and its work was then taken for the chosen model's (2026-10-05). Nothing goes out.
      */
+    if (!result.ok && goOnAsItIs)
+        return { current: result.current ?? undefined };
     if (!result.ok) {
         return {
             current: result.current ?? undefined,
@@ -579,6 +612,35 @@ async function applySessionModel(transport, session, bus, cfg, store, hooks) {
     }
     return { current: result.current ?? undefined };
 }
+/**
+ * The operator's hand, when the runner could not put the chat on the model, or when Settings ask for it to
+ * be chosen by hand (operator's requests, 2026-10-06): the run waits on a card in the UI asking them to
+ * choose it in the Copilot window; "check and go on" reads the picker button again, and asks again while it
+ * still shows another model. With no model asked for, whatever the operator chose is taken.
+ */
+async function withOperatorHand(transport, wanted, first, hooks, sessionId, bus, manual) {
+    let result = first;
+    for (let tries = 1; !result.ok && hooks?.askHelp; tries += 1) {
+        const shown = await transport.currentModel().catch(() => null);
+        bus.publish({ sessionId, type: 'model-help-asked', level: 'warn',
+            message: manual
+                ? `asking the operator to choose ${wanted ? `"${wanted}"` : 'the model'} in the Copilot window (Settings: by hand; picker shows "${shown ?? 'nothing'}")`
+                : `the chat could not be put on "${wanted}" by the runner; asking the operator to choose it in the Copilot window (picker shows "${shown ?? 'nothing'}")`,
+            data: { asked: wanted, shown, why: result.reason ?? '', tries, manual } });
+        const answer = await hooks.askHelp({ sessionId, asked: wanted, shown, why: result.reason ?? 'unknown reason', tries, ...(manual ? { manual: true } : {}) });
+        if (answer === 'stop')
+            return { result, goOnAsItIs: false };
+        if (answer === 'continue') {
+            bus.publish({ sessionId, type: 'model-help-continue', level: 'warn', message: `the operator chose to go on with the model the chat is on ("${shown ?? 'unknown'}")${wanted ? `, not "${wanted}"` : ''}`, data: { asked: wanted, shown } });
+            return { result: { ok: false, current: shown, reason: `the operator chose to go on with "${shown ?? 'unknown'}"` }, goOnAsItIs: true };
+        }
+        const now = await transport.currentModel().catch(() => null);
+        result = !wanted || buttonShows(now, wanted)
+            ? { ok: true, current: wanted || now, by: 'hand' }
+            : { ok: false, current: now, reason: `the picker still shows "${now ?? 'nothing'}", not "${wanted}"` };
+    }
+    return { result, goOnAsItIs: false };
+}
 /** Runs one task to completion inside an already-open transport. */
 export async function runTask(transport, session, task, deps) {
     const { cfg, store, bus, authorizer, signal } = deps;
@@ -1756,8 +1818,18 @@ export async function runTask(transport, session, task, deps) {
             try {
                 await transport.newChat();
                 if (model) {
-                    const reviewLocator = await deps.models?.locate?.(model).catch(() => undefined);
-                    const picked = await transport.selectModel(model, { locator: reviewLocator }).catch((e) => ({ ok: false, current: null, reason: e.message }));
+                    let picked;
+                    if (cfg.copilot.manualModel && deps.models?.askHelp) {
+                        // By hand, as the work's model (see `applySessionModel`): the review's fresh conversation is asked about too.
+                        const shown = await transport.currentModel().catch(() => null);
+                        picked = buttonShows(shown, model)
+                            ? { ok: true, current: model, by: 'already' }
+                            : (await withOperatorHand(transport, model, { ok: false, current: shown, reason: 'Settings ask for the model to be chosen by hand (the review)' }, deps.models, session.id, bus, true)).result;
+                    }
+                    else {
+                        const reviewLocator = await deps.models?.locate?.(model).catch(() => undefined);
+                        picked = await transport.selectModel(model, { locator: reviewLocator }).catch((e) => ({ ok: false, current: null, reason: e.message }));
+                    }
                     const renamed = await followPageModels('review', model, picked, session, store, deps.models, effectiveModels(session, cfg).reviewModelFrom);
                     if (renamed)
                         sink.event('model-renamed', { asked: model, chosen: picked.matched, review: true }, renamed, 'warn');

package/dist/src/plan/systemGuide.js

@@ -230,6 +230,38 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'Ends the whole task here, aborted; its remaining steps are not run.',
                         doesBg: 'Прекратява цялата задача тук; останалите ѝ стъпки не се изпълняват.',
                     },
+                    {
+                        key: 'approval.modelChosen',
+                        kind: 'button',
+                        en: 'I chose it — check and continue',
+                        bg: 'Избрах го — провери и продължи',
+                        doesEn: 'On the card that appears when the bot could not choose the model: after you chose it in the Copilot window, the bot reads the picker and goes on, or asks again if it shows another model.',
+                        doesBg: 'На картата, която се появява, когато ботът не успее да избере модела: след като го изберете в прозореца на Copilot, ботът проверява менюто и продължава, или пита пак, ако то показва друг модел.',
+                    },
+                    {
+                        key: 'approval.manualReady',
+                        kind: 'button',
+                        en: 'Ready — check and continue',
+                        bg: 'Готово — провери и продължи',
+                        doesEn: 'On the card shown when Settings ask for the model to be chosen by hand: after you chose it in the Copilot window, the bot checks the picker and starts.',
+                        doesBg: 'На картата при ръчен избор на модела (от Настройки): след като го изберете в прозореца на Copilot, ботът проверява менюто и започва.',
+                    },
+                    {
+                        key: 'approval.modelAsItIs',
+                        kind: 'button',
+                        en: 'Continue on the model it is on',
+                        bg: 'Продължи на текущия модел',
+                        doesEn: 'The run goes on with whatever model the chat is on, and the record says so.',
+                        doesBg: 'Изпълнението продължава с модела, на който е чатът, и записът го казва.',
+                    },
+                    {
+                        key: 'approval.modelStop',
+                        kind: 'button',
+                        en: 'Stop',
+                        bg: 'Спри',
+                        doesEn: 'Nothing is sent: the session stops, its tasks stay queued.',
+                        doesBg: 'Нищо не се изпраща: сесията спира, задачите ѝ остават на опашката.',
+                    },
                 ],
             },
         ],
@@ -3004,6 +3036,14 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'How many different approaches a "blocked" must list (2–20); with fewer the chat is asked for another.',
                         doesBg: 'Колко различни подхода трябва да изброи „blocked“ (2–20); с по-малко чатът е помолен за още един.',
                     },
+                    {
+                        key: 'def.manualModel',
+                        kind: 'field',
+                        en: 'Choose the model by hand at the start of each run',
+                        bg: 'Избирай модела ръчно в началото на всяко пускане',
+                        doesEn: 'The bot leaves the model picker alone and asks, on a card, for the model to be chosen in the Copilot window; a conversation already on the model is not asked about.',
+                        doesBg: 'Ботът не пипа менюто с моделите и моли, с карта, моделът да бъде избран в прозореца на Copilot; разговор, който вече е на модела, не се пита.',
+                    },
                     {
                         key: 'exec.maxReviewRounds',
                         kind: 'field',

package/dist/src/transport/copilotTransport.js

@@ -940,31 +940,60 @@ Current URL: ${url}`);
         const textOf = async (el) => (((await el.innerText().catch(() => '')) ?? '').split('\n')[0] ?? '').trim();
         // A fixed pause after every opening and every press (see `ModelPicking`); the checks give it less.
         const settle = () => this.p.waitForTimeout(this.opts.modelSettleMs ?? ModelPicking.settleMs);
-        // And a fixed pause before every press in the picker: the button, the group, the model (2026-10-06).
-        const beforePress = () => this.p.waitForTimeout(this.opts.modelBeforePressMs ?? ModelPicking.beforePressMs);
+        const pause = this.opts.modelBeforePressMs ?? ModelPicking.beforePressMs;
+        const poll = this.opts.modelPollMs ?? ModelPicking.pollMs;
         const appear = this.opts.modelAppearMs ?? ModelPicking.appearMs;
-        /** Waits until the element is there and visible. */
-        const present = async (el) => await el.waitFor({ state: 'visible', timeout: appear }).then(() => true).catch(() => false);
+        let shot = 0;
+        /** With `modelStepShots`, a picture and the menu's HTML at each step, numbered, beside the transport's files. */
+        const picture = async (label) => {
+            if (!this.opts.modelStepShots)
+                return;
+            shot += 1;
+            await this.captureMenu(`step-${String(shot).padStart(2, '0')}-${label.replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 40)}`, await this.readMenuRows().catch(() => [])).catch(() => undefined);
+        };
+        /*
+         * The operator's rhythm for every element of the picker (2026-10-06): look for it; while it is not
+         * there, wait two seconds and look again; once it is there, wait two seconds more, then press it.
+         * Each look and each pause is in the record with its time, so the pauses can be seen.
+         */
+        const waitThenFind = async (label, find) => {
+            const deadline = Date.now() + appear;
+            let looks = 1;
+            let el = await find();
+            while (!el && Date.now() < deadline) {
+                this.emit('model-step', { step: 'not there yet, waiting', what: label, look: looks, waitMs: poll });
+                await this.p.waitForTimeout(poll);
+                looks += 1;
+                el = await find();
+            }
+            if (!el) {
+                this.emit('model-step', { step: 'never appeared', what: label, looks });
+                return null;
+            }
+            this.emit('model-step', { step: 'there, pausing before the press', what: label, look: looks, text: await textOf(el), pauseMs: pause });
+            await this.p.waitForTimeout(pause);
+            await picture(`before-${label}`);
+            return el;
+        };
+        const visible = async (el) => (el && (await el.isVisible().catch(() => false)) ? el : null);
         const reach = async () => {
-            const button = await this.resolveModelButton();
+            const button = await waitThenFind('the picker button', async () => visible(await this.resolveModelButton(1_000)));
             if (!button)
                 return { problem: 'This chat does not show a model picker.' };
-            await beforePress();
-            await button.click();
+            await button.click({ timeout: 5_000 }).catch(() => undefined);
             await settle();
             if (!(await this.waitForPopup()))
                 return { problem: 'The model picker did not open.' };
             this.emit('model-step', { step: 'picker opened' });
             if (target.group) {
-                const group = await this.rowByXPath(target.group.xpath, target.group.name, appear);
-                if (!group || !(await present(group)))
+                const group = await waitThenFind(`the "${target.group.name}" group`, () => this.rowByXPath(target.group.xpath, target.group.name, 0));
+                if (!group)
                     return { problem: `the "${target.group.name}" row was not found by ${target.group.xpath}` };
-                this.emit('model-step', { step: 'group found', text: await textOf(group) });
                 /*
                  * Opened without the mouse first: a mouse click goes to coordinates, and the picker moves while it
                  * opens, so on the work machine a press meant for "GPT" (now second) opened "Claude" (now first)
                  * (2026-10-06). A click sent to the element itself cannot land on another row; then the keyboard
-                 * (focus, ArrowRight opens a submenu); the mouse only last. Each time, its model must be on screen.
+                 * (focus, ArrowRight opens a submenu); the mouse only last. Each time, its model must appear.
                  */
                 const ways = [
                     ['click on the element', async () => { await group.evaluate((el) => el.click(), undefined, { timeout: 3_000 }); }],
@@ -973,26 +1002,75 @@ Current URL: ${url}`);
                     ['mouse click', async () => { await group.click({ timeout: 3_000 }); }],
                 ];
                 for (const [how, act] of ways) {
-                    await beforePress();
                     await act().catch(() => undefined);
                     await settle();
-                    const row = await this.rowByXPath(target.xpath, target.model, appear);
-                    if (row && (await present(row))) {
+                    const row = await waitThenFind(`"${target.model}"`, () => this.rowByXPath(target.xpath, target.model, 0));
+                    if (row) {
                         this.emit('model-step', { step: 'group opened', how, model: await textOf(row) });
                         return { row };
                     }
                     this.emit('model-step', { step: 'group not opened', how });
+                    await this.p.waitForTimeout(pause);
                 }
                 await this.captureMenu('select-failed', await this.readMenuRows().catch(() => [])).catch(() => undefined);
                 return { problem: `"${target.model}" did not appear after opening "${target.group.name}" every way (${target.xpath}); the menu is kept as models-select-failed.html/.png` };
             }
-            const row = await this.rowByXPath(target.xpath, target.model, appear);
-            if (!row || !(await present(row))) {
+            const row = await waitThenFind(`"${target.model}"`, () => this.rowByXPath(target.xpath, target.model, 0));
+            if (!row) {
                 await this.captureMenu('select-failed', await this.readMenuRows().catch(() => [])).catch(() => undefined);
                 return { problem: `"${target.model}" was not found by ${target.xpath}; the menu is kept as models-select-failed.html/.png` };
             }
             return { row };
         };
+        /*
+         * A model in a group, by the keyboard (operator's choice, 2026-10-06: the submenu failed when it was
+         * expanded by click or hover). The picker opened, the group's row is focused, ArrowRight opens its
+         * submenu and puts the focus in it, ArrowDown moves the focus until it is on the model — read from the
+         * focused row's own text — and Enter chooses it. No hover, no coordinates.
+         */
+        const byKeyboard = async (attempt) => {
+            if (!target.group)
+                return false;
+            const button = await waitThenFind('the picker button', async () => visible(await this.resolveModelButton(1_000)));
+            if (!button)
+                return false;
+            await button.click({ timeout: 5_000 }).catch(() => undefined);
+            await settle();
+            if (!(await this.waitForPopup()))
+                return false;
+            const group = await waitThenFind(`the "${target.group.name}" group`, () => this.rowByXPath(target.group.xpath, target.group.name, 0));
+            if (!group) {
+                await this.closeMenu();
+                return false;
+            }
+            await group.focus({ timeout: 3_000 }).catch(() => undefined);
+            await this.p.keyboard.press('ArrowRight');
+            this.emit('model-step', { step: 'group opened by the keyboard (ArrowRight)', attempt });
+            await settle();
+            const focused = () => this.p.evaluate(() => {
+                const el = document.activeElement;
+                const row = el?.closest('[role="menuitemradio"],[role="menuitem"]');
+                return { text: (row?.innerText ?? '').trim(), radio: !!el?.closest('[role="menuitemradio"]') };
+            });
+            for (let presses = 0; presses < 12; presses += 1) {
+                const now = await focused();
+                const line = now.text.split('\n')[0]?.trim() ?? '';
+                if (now.radio && (sameModel(line, name) || sameModel(line, target.model) || containsModel(now.text, target.model))) {
+                    this.emit('model-step', { step: 'model reached by the keyboard, pausing before Enter', attempt, text: line, presses, pauseMs: pause });
+                    await this.p.waitForTimeout(pause);
+                    await picture('before-enter');
+                    await this.p.keyboard.press('Enter');
+                    await settle();
+                    return true;
+                }
+                await this.p.keyboard.press('ArrowDown');
+                await this.p.waitForTimeout(400);
+            }
+            this.emit('model-step', { step: 'model not reached by the keyboard', attempt });
+            await this.closeMenu();
+            await settle();
+            return false;
+        };
         const checked = async (row) => (await row.getAttribute('aria-checked').catch(() => null)) === 'true';
         /*
          * The whole choice, tried again from a closed menu while the picker does not show the model as chosen,
@@ -1002,6 +1080,17 @@ Current URL: ${url}`);
         let why = '';
         for (let attempt = 1; attempt <= attempts; attempt += 1) {
             this.emit('model-step', { step: 'attempt', attempt, of: attempts, model: name });
+            // A model in a group: the keyboard first; the other ways only when it does not get there.
+            if (target.group && (await byKeyboard(attempt))) {
+                await this.closeMenu();
+                await settle();
+                const shownNow = await this.currentModel();
+                if (buttonShows(shownNow, name)) {
+                    this.emit('model-selected', { model: name, buttonShows: shownNow, by: 'operator', attempt, seenOn: 'button', how: 'keyboard' });
+                    return { ok: true, current: name, by: 'operator' };
+                }
+                this.emit('model-step', { step: 'not shown on the button after Enter, trying the other ways', attempt, buttonShows: shownNow });
+            }
             const found = await reach();
             if ('problem' in found) {
                 why = found.problem;
@@ -1017,14 +1106,14 @@ Current URL: ${url}`);
             }
             // On the element itself, for the same reason as the group; the mouse only when that does nothing.
             this.emit('model-step', { step: 'model pressed', attempt, text: await textOf(found.row) });
-            await beforePress();
             await found.row.evaluate((el) => el.click(), undefined, { timeout: 3_000 }).catch(() => undefined);
             await settle();
             if ((await this.modelMenuOpen()) && !(await checked(found.row))) {
-                await beforePress();
+                await this.p.waitForTimeout(pause);
                 await found.row.click({ timeout: 3_000 }).catch(() => undefined);
                 await settle();
             }
+            await picture('after-press');
             await this.closeMenu();
             await settle();
             /*

package/dist/src/transport/locators.js

@@ -167,10 +167,15 @@ export const OperatorModelLocators = {
  */
 export const ModelPicking = {
     attempts: 6,
-    /** A fixed pause before every press in the picker: the button, the group, the model (2026-10-06: 2 s). */
+    /**
+     * The operator's rhythm (2026-10-06): an element of the picker is looked for; while it is not there the
+     * runner waits `pollMs` and looks again, up to `appearMs`; once it is there it waits `beforePressMs`
+     * more, then presses it.
+     */
+    pollMs: 2_000,
     beforePressMs: 2_000,
     settleMs: 1_500,
-    appearMs: 10_000,
+    appearMs: 20_000,
 };
 /** A text as an XPath string literal, whatever quotes it holds. */
 export function xpathText(text) {

package/dist/src/transport/modelMatch.js

@@ -19,7 +19,18 @@ export function buttonShows(shown, asked) {
         return false;
     const s = normModel(shown);
     const a = normModel(asked);
-    return s.length > 0 && (s === a || a.startsWith(`${s} `));
+    if (s.length === 0)
+        return false;
+    if (s === a)
+        return true;
+    /*
+     * The button drops the last word ("GPT-5.6 Sol Think deeper" reads "GPT-5.6 Sol Think"), no more: a
+     * shorter start — "GPT" alone — would agree with every model of the group, and a run would take the
+     * chat for set and choose nothing (2026-10-06).
+     */
+    const sw = s.split(' ');
+    const aw = a.split(' ');
+    return sw.length >= aw.length - 1 && aw.length > 1 && a.startsWith(`${s} `);
 }
 const words = (name) => normModel(name).split(' ').filter(Boolean);
 const isVersion = (w) => /^v?\d+(?:\.\d+)*$/.test(w);