copilot-operator 0.1.39 → 0.1.41

package/dist/src/plan/schema.js

@@ -52,6 +52,11 @@ const VcsInput = z
         .optional(),
     /** The local branch `startFrom: "branch"` starts from, and `previous-session`'s fallback. */
     baseBranch: z.string().trim().optional(),
+    /**
+     * The remote `baseBranch` was chosen from in the start window (`origin`): the session starts from
+     * that remote branch as fetched there. Written by the export; the start window asks every time.
+     */
+    baseRemote: z.string().trim().optional(),
     /**
      * The existing local branch the whole session works on, exactly as named: no new branch, no
      * prefix. Given alone it means `startFrom: "existing-branch"`. See `VersionControl.startFrom`.

package/dist/src/plan/systemGuide.js

@@ -40,8 +40,8 @@ export const SYSTEM_GUIDE = [
         route: 'every page',
         nameEn: 'The header and the navigation',
         nameBg: 'Заглавната лента и навигацията',
-        purposeEn: 'The links down the side of every page, the language switch, the round to-the-top and to-the-bottom buttons of a long page, the box that asks before anything irreversible, and the banner of steps waiting for a decision, which appears on every page.',
-        purposeBg: 'Връзките отстрани на всяка страница, смяната на езика, кръглите бутони към началото и края на дълга страница, прозорецът, който пита преди нещо необратимо, и лентата със стъпки, чакащи решение, която се появява на всяка страница.',
+        purposeEn: 'The links down the side of every page, the language switch, the round to-the-top and to-the-bottom buttons of a long page, the box that asks before anything irreversible, the start window every start button opens first (where the work starts), the notice of a start that did not happen, and the banner of steps waiting for a decision, which appears on every page.',
+        purposeBg: 'Връзките отстрани на всяка страница, смяната на езика, кръглите бутони към началото и края на дълга страница, прозорецът, който пита преди нещо необратимо, прозорецът за старт, който всеки бутон за пускане отваря първо (откъде тръгва работата), съобщението за пускане, което не е започнало, и лентата със стъпки, чакащи решение, която се появява на всяка страница.',
         sections: [
             {
                 headingKey: 'nav.label',
@@ -177,6 +177,148 @@ export const SYSTEM_GUIDE = [
                     },
                 ],
             },
+            {
+                headingKey: 'startdlg.title',
+                en: 'Where the work starts',
+                bg: 'Откъде да тръгне работата',
+                controls: [
+                    {
+                        key: 'startdlg.keep',
+                        kind: 'radio',
+                        en: 'Keep the start prepared before this run',
+                        bg: 'Запази началото, подготвено преди това пускане',
+                        doesEn: 'Only for a session whose start was prepared before the run — a starting snapshot approved on the run panel — and chosen first then: the run starts from it as approved. Any other choice below drops it.',
+                        doesBg: 'Само за сесия, чието начало е подготвено преди пускането — стартова снимка, одобрена в панела за пускане — и тогава е избрано първо: пускането тръгва от нея, както е одобрена. Всеки друг избор по-долу я отменя.',
+                    },
+                    {
+                        key: 'startdlg.local',
+                        kind: 'radio',
+                        en: 'Local branch',
+                        bg: 'Локален клон',
+                        doesEn: 'The start window opens on every start button — the run buttons on /, a session\'s Start, "Run this task", the register\'s Continue and "Run only this one again" — and nothing starts until its own button is pressed. This choice: the work starts from the local branch picked in the list beside it, as it is in the folder; nothing is fetched.',
+                        doesBg: 'Прозорецът за старт се отваря от всеки бутон за пускане — бутоните за пускане на /, „Старт“ на сесия, „Пусни тази задача“, „Продължи“ и „Пусни само тази отново“ в регистъра — и нищо не тръгва, преди да се натисне неговият бутон. Този избор: работата тръгва от локалния клон, избран в списъка до него, какъвто е в папката; нищо не се изтегля.',
+                    },
+                    {
+                        key: 'startdlg.remote',
+                        kind: 'radio',
+                        en: 'Remote branch (fetched now)',
+                        bg: 'Remote клон (изтегля се сега)',
+                        doesEn: 'The work starts from the branch as it is on the server: type its name (feature/…) or pick it from the list. It is fetched when the window\'s start button is pressed; if the SSH key has a passphrase, Git\'s own window asks for it (it may be behind the browser) — the operator types it there, the bot never sees it. The local branch of that name is not touched.',
+                        doesBg: 'Работата тръгва от клона, какъвто е на сървъра: напиши името му (feature/…) или го избери от списъка. Изтегля се при натискане на бутона за старт на прозореца; ако SSH ключът има passphrase, собственият прозорец на Git я иска (може да е зад браузъра) — операторът я въвежда там, ботът не я вижда. Локалният клон със същото име не се пипа.',
+                    },
+                    {
+                        key: 'startdlg.refreshRemote',
+                        kind: 'button',
+                        en: 'Get the list of branches from the remote',
+                        bg: 'Вземи списъка с клонове от remote',
+                        doesEn: 'Fetches the whole remote (the password window may open) so the list of remote branches to pick from is current.',
+                        doesBg: 'Изтегля целия remote (може да се отвори прозорецът за парола), за да е актуален списъкът с remote клонове за избор.',
+                    },
+                    {
+                        key: 'startdlg.previous',
+                        kind: 'radio',
+                        en: 'Carry on from the session before it',
+                        bg: 'Продължи от предната сесия',
+                        doesEn: 'Offered for a session that follows another in the same repository: carries on from the end of that session\'s branch.',
+                        doesBg: 'Предлага се за сесия след друга в същото хранилище: продължава от края на клона на онази сесия.',
+                    },
+                    {
+                        key: 'startdlg.onBranch',
+                        kind: 'checkbox',
+                        en: 'Work directly on this branch, without a new branch',
+                        bg: 'Работи направо на този клон, без нов клон',
+                        doesEn: 'Off, as usual: the bot cuts a branch of its own from the chosen one. On: the tasks commit on the chosen branch itself; a remote branch is first made locally, or the local one brought up to it (fast-forward only). A local branch that has gone its own way from the remote one is refused, with nothing changed.',
+                        doesBg: 'Изключено, както обикновено: ботът прави свой клон от избрания. Включено: задачите комитват направо на избрания клон; при remote клон първо се прави локален или локалният се довежда до него (само fast-forward). Локален клон, тръгнал по свой път спрямо remote, се отказва, без да се променя нищо.',
+                    },
+                    {
+                        key: 'startdlg.goStep',
+                        kind: 'button',
+                        en: 'Start, asking before each command',
+                        bg: 'Започни, с питане преди всяка команда',
+                        doesEn: 'The window\'s own start button, for a run that asks before each command: fetches what was chosen from the remote, writes the choice on the sessions and starts.',
+                        doesBg: 'Собственият бутон за старт на прозореца, за пускане с питане преди всяка команда: изтегля избраното от remote, записва избора в сесиите и стартира.',
+                    },
+                    {
+                        key: 'startdlg.goUnattended',
+                        kind: 'button',
+                        en: 'Start without asking',
+                        bg: 'Започни без питане',
+                        doesEn: 'The same, for a run without asking.',
+                        doesBg: 'Същото, за пускане без питане.',
+                    },
+                    {
+                        key: 'startdlg.retryFetch',
+                        kind: 'button',
+                        en: 'Fetch again',
+                        bg: 'Изтегли отново',
+                        doesEn: 'After a fetch that did not get through — a passphrase not typed, a branch name the remote does not have: fetches again.',
+                        doesBg: 'След изтегляне, което не е минало — непопълнен passphrase, име на клон, което remote няма: изтегля отново.',
+                    },
+                    {
+                        key: 'startdlg.useFetched',
+                        kind: 'button',
+                        en: 'Go on with what was last fetched',
+                        bg: 'Продължи с последно изтегленото',
+                        doesEn: 'After such a fetch, when that branch was fetched here before: starts from that older copy instead.',
+                        doesBg: 'След такова изтегляне, ако клонът е бил изтеглян тук преди: тръгва от онова по-старо копие.',
+                    },
+                    {
+                        key: 'startdlg.back',
+                        kind: 'button',
+                        en: 'Back to the choice',
+                        bg: 'Обратно към избора',
+                        doesEn: 'Back to the choice of branches, after a fetch or a start that did not go through.',
+                        doesBg: 'Обратно към избора на клонове след изтегляне или старт, които не са минали.',
+                    },
+                    {
+                        key: 'startdlg.tryAgain',
+                        kind: 'button',
+                        en: 'Try to start again',
+                        bg: 'Опитай пак да започнеш',
+                        doesEn: 'After a start that did not happen — for instance once the version control fixes shown in the window are done: starts again with the same choice, without fetching again.',
+                        doesBg: 'След старт, който не се е случил — например след като поправките на контрола на версиите, показани в прозореца, са направени: стартира пак със същия избор, без ново изтегляне.',
+                    },
+                ],
+            },
+            {
+                headingKey: null,
+                en: 'A start that did not happen',
+                bg: 'Пускане, което не е започнало',
+                controls: [
+                    {
+                        key: 'startfail.title',
+                        kind: 'note',
+                        en: 'The work did not start',
+                        bg: 'Работата не започна',
+                        doesEn: 'In the start window when its button did not start the work, on / under the run buttons once the window is closed, and on every page when a run was accepted and then could not begin (the browser, the profile, the sign-in, a session refused at its turn): the error itself and where it stopped.',
+                        doesBg: 'В прозореца за старт, когато бутонът му не е стартирал работата, на / под бутоните за пускане след затварянето му, и на всяка страница, когато пускане е прието, а после не е могло да започне (браузърът, профилът, влизането, сесия, отказана на своя ред): самата грешка и къде е спряло.',
+                    },
+                    {
+                        key: 'startfail.download',
+                        kind: 'link',
+                        en: 'Download what happened (error, run record and terminal)',
+                        bg: 'Изтегли какво се случи (грешка, запис на пускането и терминал)',
+                        doesEn: 'A text file with the error, where it stopped, the run\'s own record, the sessions\' events and every line the bot\'s console printed from the press until a few seconds after. Ask the operator for it when a run does not start.',
+                        doesBg: 'Текстов файл с грешката, къде е спряло, собствения запис на пускането, събитията на сесиите и всеки ред, който конзолата на бота е отпечатала от натискането до няколко секунди след това. Поискай го от оператора, когато пускане не тръгва.',
+                    },
+                    {
+                        key: 'startfail.terminal',
+                        kind: 'link',
+                        en: 'Download what the terminal showed',
+                        bg: 'Изтегли какво показа терминалът',
+                        doesEn: 'The latest lines the bot\'s console (npm start or cop start) printed, with the time of each, as a text file. Also on /system.',
+                        doesBg: 'Последните редове, отпечатани от конзолата на бота (npm start или cop start), с часа на всеки, като текстов файл. Има го и на /system.',
+                    },
+                    {
+                        key: 'startfail.dismiss',
+                        kind: 'button',
+                        en: 'Close this notice',
+                        bg: 'Затвори съобщението',
+                        doesEn: 'Closes the notice of a run that could not begin, on every page; the files stay on record.',
+                        doesBg: 'Затваря съобщението за пускане, което не е могло да започне, на всяка страница; файловете остават.',
+                    },
+                ],
+            },
             {
                 headingKey: 'approval.waitingHere',
                 en: 'A step is waiting for your decision',
@@ -722,8 +864,8 @@ export const SYSTEM_GUIDE = [
                         kind: 'note',
                         en: 'Prepare version control for this run',
                         bg: 'Подготви контрола на версиите за това пускане',
-                        doesEn: 'Shown under the run settings when a repository of the ticked sessions is not ready: one box per repository, with the fixes. The run buttons stay off until every box is ready, and a start is refused before the browser opens.',
-                        doesBg: 'Показва се под настройките на пускането, когато хранилище на отметнатите сесии не е готово: по една кутия на хранилище, с решенията. Бутоните за пускане остават изключени, докато всяка кутия не е готова, а старт се отказва преди да се отвори браузърът.',
+                        doesEn: 'Shown under the run settings when a repository of the ticked sessions is not ready: one box per repository, with the fixes. The run buttons stay off until every box is ready — unless all that is wrong is where a session starts (a branch that is not here), which the start window settles — and a start is refused before the browser opens.',
+                        doesBg: 'Показва се под настройките на пускането, когато хранилище на отметнатите сесии не е готово: по една кутия на хранилище, с решенията. Бутоните за пускане остават изключени, докато всяка кутия не е готова — освен ако единственият проблем е откъде тръгва сесия (клон, който го няма тук), което се решава в прозореца за старт — а старт се отказва преди да се отвори браузърът.',
                     },
                     {
                         key: 'runvcs.repo',
@@ -834,24 +976,16 @@ export const SYSTEM_GUIDE = [
                         kind: 'button',
                         en: 'Run {n} session(s)',
                         bg: 'Пусни {n} сесия(и)',
-                        doesEn: 'Starts the ticked sessions one after another and runs every command without asking. It asks "are you sure" first, unless Settings → Execution → "Starting a run without supervision" is "Start it without asking".',
-                        doesBg: 'Пуска отметнатите сесии една след друга и изпълнява всяка команда без питане. Първо пита „сигурен ли си“, освен ако Настройки → Изпълнение → „Пускане без надзор“ е „Пускай, без да питаш“.',
+                        doesEn: 'Starts the ticked sessions one after another and runs every command without asking. It asks "are you sure" first, unless Settings → Execution → "Starting a run without supervision" is "Start it without asking". The start window opens first ("Where the work starts"), where the branch of each session is chosen.',
+                        doesBg: 'Пуска отметнатите сесии една след друга и изпълнява всяка команда без питане. Първо пита „сигурен ли си“, освен ако Настройки → Изпълнение → „Пускане без надзор“ е „Пускай, без да питаш“. Първо се отваря прозорецът за старт („Откъде да тръгне работата“), където се избира клонът на всяка сесия.',
                     },
                     {
                         key: 'batch.runStep',
                         kind: 'button',
                         en: 'Step by step',
                         bg: 'Стъпка по стъпка',
-                        doesEn: 'Starts the same sessions but stops before every command and waits for a decision.',
-                        doesBg: 'Пуска същите сесии, но спира преди всяка команда и чака решение.',
-                    },
-                    {
-                        key: 'batch.notStartedTitle',
-                        kind: 'note',
-                        en: 'The run did not start',
-                        bg: 'Пускането не тръгна',
-                        doesEn: 'The box over the two run buttons when a press was refused, with the reason under it. Nothing was opened and nothing ran; read the reason before pressing again.',
-                        doesBg: 'Карето над двата бутона за пускане, когато натискането е отказано, с причината под него. Нищо не е отваряно и нищо не е пускано; прочети причината, преди да натиснеш пак.',
+                        doesEn: 'Starts the same sessions but stops before every command and waits for a decision. The start window opens first, as for the other button.',
+                        doesBg: 'Пуска същите сесии, но спира преди всяка команда и чака решение. Първо се отваря прозорецът за старт, както при другия бутон.',
                     },
                     {
                         key: 'batch.notStartedIsolation',
@@ -3505,6 +3639,14 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'The block showing the settings as saved and the paths they resolve to.',
                         doesBg: 'Блокът с настройките, както са запазени, и пътищата, до които водят.',
                     },
+                    {
+                        key: 'startfail.terminal',
+                        kind: 'link',
+                        en: 'Download what the terminal showed',
+                        bg: 'Изтегли какво показа терминалът',
+                        doesEn: 'Under "This machine": the latest lines the bot\'s console printed, with their times, as a text file — what to ask for when something went wrong and nothing on the pages says why.',
+                        doesBg: 'Под „Тази машина“: последните редове, отпечатани от конзолата на бота, с часовете им, като текстов файл — това се иска, когато нещо се е объркало и нищо по страниците не казва защо.',
+                    },
                     {
                         key: 'sys.profileHeld',
                         kind: 'note',

package/dist/src/session/exports.js

@@ -147,6 +147,7 @@ export function buildPlanExport(scope) {
                     // Only when chosen: absent is the old behaviour, and writing it out would suggest a choice.
                     ...(s.vcs?.startFrom ? { startFrom: s.vcs.startFrom } : {}),
                     ...(s.vcs?.baseBranch ? { baseBranch: s.vcs.baseBranch } : {}),
+                    ...(s.vcs?.baseRemote ? { baseRemote: s.vcs.baseRemote } : {}),
                     ...(s.vcs?.existingBranch ? { existingBranch: s.vcs.existingBranch } : {}),
                     // Only when switched off: absent is on.
                     ...(s.vcs?.updateFromRemote === false ? { updateFromRemote: false } : {}),

package/dist/src/session/startFailure.js

@@ -0,0 +1,91 @@
+/**
+ * A start that did not get as far as the first task, kept so the operator can see why and download
+ * what happened.
+ *
+ * Asked for on 2026-10-13: "if something fails and the bot does not start at all, I want to see what
+ * the error is — the specific error, and a place to download what happened in the terminal". Some of
+ * these were answered under the button that was pressed, in a sentence; others were not answered at
+ * all: a run accepted, then the browser would not open, and the reason was in the console and in a
+ * table row further down the page. Each one is now recorded here with where it stopped, the message,
+ * the run and its sessions, and the page offers a file that puts the run's own record, the sessions'
+ * events and the console lines of those moments in one place.
+ *
+ * Kept in memory only, for this process: the files it points at (the run log, the terminal log) are
+ * what stays.
+ */
+import { randomBytes } from 'node:crypto';
+import { formatTerminal, localTime } from '../log/terminal.js';
+const STAGE_SAID = {
+    refused: 'the start was not let in, before anything opened',
+    branch: 'choosing the branch the work starts from',
+    preflight: 'the version control check, before the browser opened',
+    browser: 'opening the browser (Edge), its profile or the chat',
+    run: 'the run, before its first task began',
+    'at-turn': "the session's turn in the run, before its first task",
+    error: 'the bot itself, while starting',
+};
+export function describeStage(stage) {
+    return STAGE_SAID[stage];
+}
+const KEEP = 50;
+export class StartFailures {
+    list = [];
+    record(f) {
+        const full = { ...f, id: `sf-${Date.now().toString(36)}-${randomBytes(3).toString('hex')}`, at: f.at ?? new Date().toISOString() };
+        this.list.push(full);
+        if (this.list.length > KEEP)
+            this.list.splice(0, this.list.length - KEEP);
+        return full;
+    }
+    get(id) {
+        return this.list.find((f) => f.id === id);
+    }
+    /** The newest first; only those nobody was answered with, when asked for. */
+    recent(opts = {}) {
+        return [...this.list].reverse().filter((f) => !opts.unansweredOnly || !f.answered);
+    }
+}
+export function refOf(f) {
+    return { id: f.id, at: f.at, stage: f.stage, message: f.message, ...(f.runId ? { runId: f.runId } : {}), answered: f.answered, sessions: f.sessions.map((s) => s.name) };
+}
+/**
+ * The file the page offers: what failed and where, then the run's own record, the sessions' events,
+ * and what the console printed from the press to a few seconds after the failure. Plain text, so it
+ * opens anywhere and can be pasted into a message; the caller redacts it.
+ */
+export function failureReport(f, parts) {
+    const out = [];
+    out.push('copilot-operator — the work did not start');
+    out.push('');
+    out.push(`When:              ${localTime(f.at)} (pressed ${localTime(f.pressedAt)})`);
+    out.push(`Where it stopped:  ${describeStage(f.stage)} [${f.stage}]`);
+    if (f.runId)
+        out.push(`Run:               ${f.runId}`);
+    if (f.sessions.length > 0)
+        out.push(`Sessions:          ${f.sessions.map((s) => `"${s.name}" (${s.id})`).join(', ')}`);
+    if (parts.version)
+        out.push(`Version:           ${parts.version}`);
+    out.push('');
+    out.push('What went wrong:');
+    out.push(...f.message.split(/\r?\n/).map((l) => `  ${l}`));
+    out.push('');
+    out.push(`The run's record (${parts.runLog.length} entr${parts.runLog.length === 1 ? 'y' : 'ies'}):`);
+    if (parts.runLog.length === 0)
+        out.push('  (none: the start stopped before the run was recorded)');
+    for (const e of parts.runLog)
+        out.push(`  ${localTime(e.at)}  ${e.type}  ${e.message}`);
+    out.push('');
+    out.push(`The sessions' events since the press (${parts.events.length}):`);
+    if (parts.events.length === 0)
+        out.push('  (none)');
+    for (const e of parts.events)
+        out.push(`  ${localTime(e.at)}  ${e.level === 'info' ? '    ' : e.level.toUpperCase().padEnd(4)}  ${e.type}  ${e.message ?? ''}`);
+    out.push('');
+    out.push(`What the terminal showed (the bot's console, ${parts.terminal.length} line(s) from the press to a few seconds after):`);
+    out.push(parts.terminal.length > 0 ? formatTerminal(parts.terminal) : '  (nothing was printed)');
+    out.push('');
+    if (parts.terminalFile)
+        out.push(`The whole console is kept in ${parts.terminalFile}; past 5 MB the older part goes to terminal.1.log beside it.`);
+    out.push('');
+    return out.join('\n');
+}

package/dist/src/transport/copilotTransport.js

@@ -39,6 +39,29 @@ export function isReplyTimeout(e) {
     return e instanceof ReplyTimeoutError || (e instanceof Error && e.name === 'ReplyTimeoutError' && typeof e.seconds === 'number');
 }
 const ORIGIN = 'https://m365.cloud.microsoft';
+/**
+ * Which Copilot an address is, by its host — not by whether the text appears anywhere in it: the
+ * consumer Copilot and a sign-in page carry the work chat's address in their query (`ru=`,
+ * `redirect_uri=`), and a check of the whole URL took them for each other. `work` here only says the
+ * host is the work Copilot's; `surface()` also looks for its composer.
+ */
+export function surfaceOfUrl(url) {
+    let host = '';
+    try {
+        host = new URL(url).hostname.toLowerCase();
+    }
+    catch {
+        return 'unknown';
+    }
+    const on = (h) => host === h || host.endsWith(`.${h}`);
+    if (on(Signal.loginHost))
+        return 'sign-in';
+    if (Surface.consumerHosts.some(on))
+        return 'consumer';
+    if (Surface.workHosts.some(on))
+        return 'work';
+    return 'unknown';
+}
 /**
  * Which of the operator's locators a chosen model is. Groups first, by the word the locator is written
  * with ("Sonnet", "Opus", "GPT-5.6 Sol Think deeper") contained in the name, longest first; then the
@@ -256,16 +279,11 @@ export class CopilotTransport {
      * when it is really a sign-in problem.
      */
     async surface() {
-        const url = this.p.url();
-        if (url.includes(Signal.loginHost))
-            return 'sign-in';
-        if (Surface.consumerHosts.some((h) => url.includes(h)))
-            return 'consumer';
-        if (url.includes(Surface.workHost)) {
-            const hasWorkComposer = (await this.p.locator(Surface.workMarkers[0]).count()) > 0;
-            return hasWorkComposer ? 'work' : 'unknown';
-        }
-        return 'unknown';
+        const where = surfaceOfUrl(this.p.url());
+        if (where !== 'work')
+            return where;
+        const hasWorkComposer = (await this.p.locator(Surface.workMarkers[0]).count()) > 0;
+        return hasWorkComposer ? 'work' : 'unknown';
     }
     /**
      * Email addresses visible in the page, as a way to tell which account is signed in.

package/dist/src/transport/locators.js

@@ -283,7 +283,13 @@ export const Blocker = {
  * bot when it is really a sign-in problem.
  */
 export const Surface = {
-    workHost: 'm365.cloud.microsoft',
+    /**
+     * The work Copilot's hosts. `copilot.cloud.microsoft` since Microsoft began moving the chat there: on
+     * 2026-10-13 the work machine's `m365.cloud.microsoft/chat` landed on
+     * `copilot.cloud.microsoft/chat?es=SSR&redirfrom=mcmToCcm`, the same chat with the same composer, and
+     * the sign-in was refused as "not the Microsoft 365 Copilot chat" because only the old host was known.
+     */
+    workHosts: ['m365.cloud.microsoft', 'copilot.cloud.microsoft'],
     /** Only the work surface has this composer id and these test ids. */
     workMarkers: ['#m365-chat-editor-target-element'],
     consumerHosts: ['copilot.microsoft.com', 'www.bing.com', 'bing.com'],

package/dist/src/vcs/prepareFromRemote.js

@@ -29,8 +29,8 @@ import { rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { createHash } from 'node:crypto';
-import { branchNameFrom, freeBranchName, git, gitFetch, lastFetchedAt, porcelainPaths, RUNNER_EMAIL } from './git.js';
-import { closePasswordWindows, describeFetchFailure, fetchCommandFor, operatorFetchEnv, QUIET_FETCH_ENV } from './remoteAuth.js';
+import { branchNameFrom, freeBranchName, git, lastFetchedAt, porcelainPaths, RUNNER_EMAIL } from './git.js';
+import { fetchAsOperator, fetchCommandFor } from './remoteAuth.js';
 const short = (c) => (c ?? '').slice(0, 8);
 const lines = (s) => s.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
 function stamp(now = new Date()) {
@@ -92,25 +92,12 @@ export async function planPrepare(folder, opts) {
     let fetched;
     if (opts.fetch) {
         /*
-         * With the password window: five minutes for the operator to type, and the window not hidden. One
-         * connection only — `remote set-head --auto` would open a second and ask for the password again —
-         * so the remote's main is read from what was fetched, below.
+         * With the password window when there is one, the whole remote in one connection, so the remote's
+         * main is read from what was fetched, below. Once more when the first try fails: see `gitFetch`
+         * (2026-10-05, every first press failed at work).
          */
-        const asked = !!opts.askpass;
-        const env = asked ? operatorFetchEnv(opts.askpass) : QUIET_FETCH_ENV;
-        const args = [...(asked ? [] : ['-c', 'credential.interactive=false']), 'fetch', '--quiet', '--no-tags', '--prune', remote];
-        const started = new Date(Date.now() - 1000);
-        // Once more when the first try fails: see `gitFetch` (2026-10-05, every first press failed at work).
-        const f = await gitFetch(repoDir, args, asked ? 300_000 : 120_000, env, { windowsHide: !asked, killTree: true });
-        // Given up on with the window still open: closed, so it is not left on screen asking for nothing.
-        if (!f.ok && asked && /gave up after/.test(f.stderr))
-            await closePasswordWindows(opts.askpass, started);
-        if (f.ok)
-            fetched = { ok: true, asked, ...(f.retried ? { retried: true, ...(f.firstError ? { firstError: f.firstError } : {}) } : {}) };
-        else {
-            const why = describeFetchFailure(f.stderr || f.stdout);
-            fetched = { ok: false, detail: why.detail, auth: why.auth, asked };
-        }
+        const f = await fetchAsOperator(repoDir, remote, { askpass: opts.askpass ?? null });
+        fetched = f.ok ? { ok: true, asked: f.asked, ...(f.retried ? { retried: true, ...(f.firstError ? { firstError: f.firstError } : {}) } : {}) } : { ok: false, detail: f.detail, auth: f.auth, asked: f.asked };
     }
     let target = '';
     const remoteHead = await git(repoDir, ['symbolic-ref', '--quiet', '--short', `refs/remotes/${remote}/HEAD`]);

package/dist/src/vcs/remoteAuth.js

@@ -20,7 +20,7 @@
 import { execFile } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { git } from './git.js';
+import { git, gitFetch } from './git.js';
 import { psQuote } from './syncCommand.js';
 /** No prompt anywhere: what every fetch of a run uses. */
 export const QUIET_FETCH_ENV = { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never', GIT_ASKPASS: '', SSH_ASKPASS: '' };
@@ -90,3 +90,28 @@ export function closePasswordWindows(program, since) {
 export function fetchCommandFor(dir, remote) {
     return `git -C ${psQuote(dir)} fetch --prune ${psQuote(remote)}`;
 }
+/**
+ * A fetch the operator just pressed a button for, and is looking at: with Git's password window when
+ * there is one (five minutes to type, the window not hidden), quiet otherwise. One connection only —
+ * `remote set-head --auto` would open a second and ask for the password again. Tried once more when
+ * the first try fails (see `gitFetch`), and a window left on screen by a fetch that was given up on is
+ * closed. `refspecs` fetches only those branches; without them the whole remote is fetched and pruned.
+ *
+ * The one fetch behind "Prepare the folder from the remote main branch" and the start window's
+ * remote branches (`startChoice.ts`).
+ */
+export async function fetchAsOperator(repoDir, remote, opts) {
+    const asked = !!opts.askpass;
+    const env = asked ? operatorFetchEnv(opts.askpass) : QUIET_FETCH_ENV;
+    const whole = !opts.refspecs || opts.refspecs.length === 0;
+    const args = [...(asked ? [] : ['-c', 'credential.interactive=false']), 'fetch', '--quiet', '--no-tags', ...(whole ? ['--prune'] : []), remote, ...(opts.refspecs ?? [])];
+    const started = new Date(Date.now() - 1000);
+    const f = await gitFetch(repoDir, args, asked ? 300_000 : 120_000, env, { windowsHide: !asked, killTree: true });
+    // Given up on with the window still open: closed, so it is not left on screen asking for nothing.
+    if (!f.ok && asked && /gave up after/.test(f.stderr))
+        await closePasswordWindows(opts.askpass, started);
+    if (f.ok)
+        return { ok: true, asked, ...(f.retried ? { retried: true, ...(f.firstError ? { firstError: f.firstError } : {}) } : {}) };
+    const why = describeFetchFailure(f.stderr || f.stdout);
+    return { ok: false, detail: why.detail, auth: why.auth, asked };
+}

package/dist/src/vcs/runPreflight.js

@@ -27,7 +27,7 @@ import { join, resolve } from 'node:path';
 import { branchNameFrom, describeUpdate, freeBranchName, git, updateFromRemote } from './git.js';
 import { commitOnto, dirtyBesidesInputs, inputSettings, inputSumsAt, missingInputPatterns } from './inputs.js';
 import { approvalMismatch, dirtyPolicy, takeSnapshot } from './snapshot.js';
-import { repoDirOf, sessionBranchName, vcsPreflight } from './taskVcs.js';
+import { baseRefOf, repoDirOf, sessionBranchName, vcsPreflight } from './taskVcs.js';
 import { artifactPatterns } from './artifacts.js';
 import { inScope } from './scope.js';
 import { findSuspicious } from './commitHygiene.js';
@@ -58,8 +58,15 @@ async function groupFor(list, allSessions) {
     const branch = branchR.ok && branchR.stdout !== 'HEAD' ? branchR.stdout : null;
     const head = headR.ok && headR.stdout ? headR.stdout : null;
     const startFrom = first.vcs?.startFrom ?? 'head';
-    const baseBranch = startFrom === 'branch' || startFrom === 'previous-session' ? first.vcs?.baseBranch?.trim() || 'main' : undefined;
-    const baseHead = baseBranch ? (await git(repoDir, ['rev-parse', '--verify', '--quiet', `refs/heads/${baseBranch}^{commit}`])).stdout || null : undefined;
+    /*
+     * The branch the sessions start from, by its name on screen (`origin/x` for a remote branch chosen in
+     * the start window) and the ref git reads for it: a remote-tracking branch is never the local one of
+     * the same name, and is not brought up to anything here — the start window fetched it.
+     */
+    const base = startFrom === 'branch' || startFrom === 'previous-session' ? baseRefOf(first.vcs) : undefined;
+    const baseBranch = base?.name;
+    const baseHead = base ? (await git(repoDir, ['rev-parse', '--verify', '--quiet', `${base.ref}^{commit}`])).stdout || null : undefined;
+    const updates = first.vcs?.updateFromRemote !== false && !base?.remote;
     const settings = inputSettings(first.vcs);
     const workName = first.vcs?.startFrom === 'existing-branch'
         ? first.vcs.existingBranch?.trim()
@@ -69,7 +76,7 @@ async function groupFor(list, allSessions) {
     const workBranch = workName ? { name: workName, head: (await git(repoDir, ['rev-parse', '--verify', '--quiet', `refs/heads/${workName}^{commit}`])).stdout || null } : undefined;
     const sessions = list.map((s, i) => {
         const sf = s.vcs?.startFrom ?? 'head';
-        const role = i === 0 ? 'first' : sf === 'previous-session' ? 'inherits' : sf === 'branch' && (s.vcs?.baseBranch?.trim() || 'main') === baseBranch && !s.vcsBaseCommit ? 'shares' : 'own';
+        const role = i === 0 ? 'first' : sf === 'previous-session' ? 'inherits' : sf === 'branch' && baseRefOf(s.vcs).name === baseBranch && !s.vcsBaseCommit ? 'shares' : 'own';
         // Started means a task of it ran; a start recorded by the panel (a snapshot) is not that (live run 2026-10-03).
         const started = s.tasks.some((t) => !!t.startedAt || (t.attempts ?? []).some((a) => !!a.startedAt));
         return { id: s.id, name: s.name, startFrom: sf, started, hasStart: !!s.vcsBaseCommit, role };
@@ -111,16 +118,21 @@ async function groupFor(list, allSessions) {
      * The branches the sessions name, before the browser opens rather than at their first task: a
      * branch to carry on that is not there, a base branch that is not there.
      */
+    const otherThanStart = (!!problem && !pre.startProblem) || blocking;
+    let branchMissing = false;
     for (const s of list) {
         if (s.vcsBaseCommit)
             continue;
-        const named = s.vcs?.startFrom === 'existing-branch' ? s.vcs.existingBranch?.trim() : s.vcs?.startFrom === 'branch' ? s.vcs.baseBranch?.trim() || 'main' : '';
-        if (!named)
+        const named = s.vcs?.startFrom === 'existing-branch' ? { ref: `refs/heads/${s.vcs.existingBranch?.trim() ?? ''}`, name: s.vcs.existingBranch?.trim() ?? '', remote: undefined } : s.vcs?.startFrom === 'branch' ? baseRefOf(s.vcs) : null;
+        if (!named?.name)
             continue;
-        const there = (await git(repoDir, ['rev-parse', '--verify', '--quiet', `refs/heads/${named}^{commit}`])).stdout;
+        const there = (await git(repoDir, ['rev-parse', '--verify', '--quiet', `${named.ref}^{commit}`])).stdout;
         if (!there) {
             blocking = true;
-            problem = `${problem ? `${problem} ` : ''}"${s.name}" is set to ${s.vcs?.startFrom === 'existing-branch' ? 'carry on' : 'start from'} the local branch "${named}", and there is no such branch: create it, or change "Start from" on the session's page.`;
+            branchMissing = true;
+            problem =
+                `${problem ? `${problem} ` : ''}"${s.name}" is set to ${s.vcs?.startFrom === 'existing-branch' ? 'carry on' : 'start from'} the ${named.remote ? 'remote' : 'local'} branch "${named.name}", and there is no such branch` +
+                    (named.remote ? ' here: start the run again and choose it in the start window, which fetches it.' : ': create it, or choose another branch when you start the run.');
         }
     }
     const noCommits = first.vcs?.commitOnFinish === false;
@@ -136,7 +148,7 @@ async function groupFor(list, allSessions) {
     }
     if (baseBranch && !first.vcsBaseCommit && inputs.length > 0) {
         const why = !baseHead
-            ? `there is no local branch "${baseBranch}"`
+            ? `there is no ${base?.remote ? 'fetched copy of the remote' : 'local'} branch "${baseBranch}"`
             : unrelated.length > 0
                 ? `besides the input files there are other uncommitted changes (${unrelated.slice(0, 5).map((u) => u.path).join(', ')}${unrelated.length > 5 ? '…' : ''}): commit or stash them first${branch !== baseBranch ? ', or use the current branch instead' : ', or take them as a starting snapshot'}`
                 : blockedInputs.length > 0
@@ -151,11 +163,11 @@ async function groupFor(list, allSessions) {
             recommended: !why,
             ...(why ? { why } : {}),
             // The update from the remote said first: it moves the base branch, and the checkout with it when that is the branch checked out (live run 2026-10-04).
-            result: (first.vcs?.updateFromRemote !== false
+            result: (updates
                 ? `First brings "${baseBranch}" up to its remote, fast-forward only${branch === baseBranch ? ', which moves your checkout with it' : ''}; then commits`
                 : 'Commits') +
-                ` the ${inputs.length} input file(s) on top of "${baseBranch}" (${short(baseHead)}${first.vcs?.updateFromRemote !== false ? ' now, or where the update takes it' : ''}) as "Capture user-provided inputs", on the new branch ${baselineName}, ` +
-                `without switching branches: your checkout${branch ? ` of "${branch}"` : ''} and the files stay as they are${first.vcs?.updateFromRemote !== false && branch === baseBranch ? ', apart from that update' : ''}. ` +
+                ` the ${inputs.length} input file(s) on top of "${baseBranch}" (${short(baseHead)}${updates ? ' now, or where the update takes it' : ''}) as "Capture user-provided inputs", on the new branch ${baselineName}, ` +
+                `without switching branches: your checkout${branch ? ` of "${branch}"` : ''} and the files stay as they are${updates && branch === baseBranch ? ', apart from that update' : ''}. ` +
                 `${names(sharing)} ${verb(sharing, 'starts', 'start')} from it${inheriting.length > 0 ? `; ${names(inheriting)} ${verb(inheriting, 'carries', 'carry')} it on through the chain` : ''}.`,
         });
     }
@@ -218,6 +230,7 @@ async function groupFor(list, allSessions) {
         head,
         ...(baseBranch ? { baseBranch, baseHead } : {}),
         ...(workBranch && workBranch.name !== branch ? { workBranch } : {}),
+        ...(!ready && !otherThanStart && (branchMissing || pre.startProblem) ? { startChoiceCanFix: true } : {}),
         ...(settings && inputs.length === 0 && !first.vcsBaseCommit && !blocking
             ? { carry: `the input files (${settings.patterns.join(', ')}) are not in the working tree: when the first task starts they are committed on top of its start as ${prefix}input/${first.id}, from the latest earlier capture of them` }
             : {}),
@@ -257,6 +270,8 @@ export async function runVcsPrepare(sessions, repoDir, action, choices, bus, sav
                 if (x.vcs) {
                     x.vcs.startFrom = 'branch';
                     x.vcs.baseBranch = group.branch ?? undefined;
+                    // The branch the repository is on is a local one.
+                    delete x.vcs.baseRemote;
                 }
                 x.vcsBaseCommit = undefined;
                 x.vcsStart = undefined;
@@ -289,8 +304,10 @@ export async function runVcsPrepare(sessions, repoDir, action, choices, bus, sav
      * branch does: the snapshot is the commit every session here starts from, and it skipped the update
      * without a word, so a run cut its work from a main the team had already moved past (live run 2026-10-03).
      */
-    const update = first.vcs?.updateFromRemote !== false ? await updateFromRemote(top, group.baseBranch) : undefined;
-    const baseHead = (await git(top, ['rev-parse', '--verify', '--quiet', `refs/heads/${group.baseBranch}^{commit}`])).stdout || group.baseHead;
+    // Not a remote branch chosen in the start window: that was fetched there, and has no local branch to move.
+    const baseRef = baseRefOf(first.vcs);
+    const update = first.vcs?.updateFromRemote !== false && !baseRef.remote ? await updateFromRemote(top, group.baseBranch) : undefined;
+    const baseHead = (await git(top, ['rev-parse', '--verify', '--quiet', `${baseRef.ref}^{commit}`])).stdout || group.baseHead;
     const files = [];
     for (const path of paths) {
         const blob = await git(top, ['hash-object', '-w', `--path=${path}`, '--', join(top, path)]);

package/dist/src/vcs/snapshot.js

@@ -119,7 +119,9 @@ async function startProblem(session, dir, branch, head, allSessions) {
     const commit = resolved.start?.commit;
     if (!commit || commit === head)
         return undefined;
-    const wanted = resolved.start?.kind === 'previous-session' ? `the end of "${resolved.start.fromSession?.name ?? ''}"'s branch ${resolved.start.branch}` : `the local branch ${resolved.start?.branch ?? ''}`;
+    const wanted = resolved.start?.kind === 'previous-session'
+        ? `the end of "${resolved.start.fromSession?.name ?? ''}"'s branch ${resolved.start.branch}`
+        : `the ${resolved.start?.remote ? 'remote' : 'local'} branch ${resolved.start?.branch ?? ''}`;
     return (`the changes are on ${where}, and this session is set to start from ${wanted} (${commit.slice(0, 8)}). ` +
         'A snapshot is taken where the changes are, so the session would not start where it was told to. ' +
         `Put the repository on ${resolved.start?.branch ?? 'that branch'} first, or choose "From wherever the repository is (as until now)".`);