copilot-operator 0.1.10 → 0.1.11

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

@@ -466,6 +466,10 @@ let OperatorController = class OperatorController {
      * Separate from the session's own preflight because that one only speaks when version
      * control is already on, and the question here is whether it may be turned on.
      */
+    /** The command that brings a project's branch back to its remote's main — shown, never run. */
+    repoSync(dir) {
+        return this.ops.syncPlan(dir ?? '').catch(fail);
+    }
     repo(dir) {
         const problem = this.ops.repoProblem(dir ?? '');
         return problem ? { ok: false, problem } : { ok: true };
@@ -994,6 +998,13 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "setProject", null);
+__decorate([
+    Get('repo/sync'),
+    __param(0, Query('dir')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "repoSync", null);
 __decorate([
     Get('repo'),
     __param(0, Query('dir')),

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

@@ -15,7 +15,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Injectable } from '@nestjs/common';
 import { readFile, readdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { installLayout } from '../config/layout.js';
 import { SessionStore, DEFAULT_VCS, DEFAULT_REVIEW, applyTaskPatch } from '../session/store.js';
 import { EventBus } from '../session/events.js';
@@ -47,10 +47,17 @@ import { assessIsolation, readIsolationSignals, unattendedIsolationRefusal } fro
 import { unattendedPrecondition } from '../exec/policy.js';
 import { createTransport } from '../transport/chatTransport.js';
 import { composeHandoff } from '../session/handoff.js';
+import { planSync } from '../vcs/syncCommand.js';
 import { computeMetrics } from '../session/metrics.js';
 import { resolveDesktopDir, desktopIsSynced } from '../context/contextFiles.js';
 import { saveAndReveal } from './saveToDesktop.js';
 import { Settings } from './settings.js';
+/** A folder as compared: absolute, forward slashes, no trailing slash, and case folded as Windows does. */
+function normaliseDir(dir) {
+    if (!dir.trim())
+        return '';
+    return resolve(dir.trim()).replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+}
 let OperatorService = class OperatorService {
     /** Where this install keeps its prompts and its records. See `config/layout.ts`. */
     layout = installLayout();
@@ -1774,6 +1781,26 @@ let OperatorService = class OperatorService {
     repoProblem(dir) {
         return repoUnusableReason(dir);
     }
+    /**
+     * What bringing a project back to its remote's main branch would lose, and the command that does
+     * it — for the operator to run. See `vcs/syncCommand.ts`; nothing here writes.
+     *
+     * Only for a folder this bot already works in: a project in Settings or the repository of a
+     * session. The answer lists file names and commit subjects, and a local page asking about any
+     * folder on the disk is not a question this API should answer.
+     */
+    async syncPlan(dir) {
+        await this.init();
+        const wanted = normaliseDir(dir);
+        const cfg = await this.settings.load();
+        const known = new Set([cfg.project?.rootDir ?? '', ...(cfg.project?.others ?? []).map((o) => o.rootDir), ...(await this.store.listSessions()).flatMap((s) => [s.vcs?.repoDir ?? '', s.mirror?.rootDir ?? ''])]
+            .filter((d) => d.trim())
+            .map(normaliseDir));
+        if (!wanted || !known.has(wanted)) {
+            throw new Error('That folder is not one of the projects in Settings or the repository of a session, so no command is offered for it.');
+        }
+        return await planSync(resolve(dir.trim()));
+    }
     // --- the project being worked on ---------------------------------------------------------
     /**
      * The folder new sessions start pointed at, and whether it can carry version control.

package/dist/src/config/schema.js

@@ -399,6 +399,12 @@ export const RunConfigSchema = z.object({
          * its record. Zero turns it off.
          */
         retryBlockedInFreshChat: z.number().int().nonnegative().default(2),
+        /*
+         * How many genuinely different approaches the chat must have tried before it may end a task
+         * "blocked". The reply format's own floor is 2 (replySchema.ts); this raises it. A "blocked"
+         * with fewer is sent back asking for another approach (see taskRunner.ts). Settings → Execution.
+         */
+        minApproachesBeforeBlocked: z.number().int().min(2).max(50).default(2),
     })
         .prefault({}),
     runsDir: z.string().default('./runs'),

package/dist/src/orchestrator/taskRunner.js

@@ -38,6 +38,7 @@ import { writeReport } from '../exec/reportFile.js';
 import { Pacer } from '../util/pacing.js';
 import { RunLog } from '../log/runLog.js';
 import { composeOpening, READ_ONLY_NOTE } from '../session/compose.js';
+import { MIN_TRIED_APPROACHES } from '../protocol/replySchema.js';
 import { enforceScope, scopeMessage, scopeNote } from '../vcs/scope.js';
 import { composeHandoff } from '../session/handoff.js';
 import { ProgressWatch } from './progress.js';
@@ -185,11 +186,12 @@ export async function openBrowser(cfg, bus, transportDir, sessionId) {
                 'verification-cleared': 'Verification cleared, continuing.',
                 'error-banner': 'The chat reported a transient error; reloading the page.',
                 'reply-files-ignored': 'The reply came with a file attached. It was not downloaded and will not be run: the runner takes only the text of a reply.',
+                'model-menu-stuck': 'The model menu would not close — Escape, the menu button and a click outside all left it open. Close it in the Edge window; the run goes on.',
             };
             bus.publish({
                 sessionId,
                 type: `browser:${event}`,
-                level: event === 'verification-required' || event === 'reply-files-ignored' ? 'warn' : 'info',
+                level: event === 'verification-required' || event === 'reply-files-ignored' || event === 'model-menu-stuck' ? 'warn' : 'info',
                 message: spoken[event],
                 data: detail,
             });
@@ -361,6 +363,15 @@ export async function runTask(transport, session, task, deps) {
     let runnerNotes = [];
     /** Steps the chat sent that were not run, for the handoff at the end. */
     const notRun = [];
+    /**
+     * How many different approaches "blocked" needs, from Settings, never below the format's own two.
+     * A "blocked" with fewer is sent back; after `MAX_EARLY_BLOCKS` of them in a row with nothing tried
+     * in between the verdict is accepted, so a chat that cannot think of anything else does not spend
+     * the rest of the iterations saying so.
+     */
+    const minApproaches = Math.max(MIN_TRIED_APPROACHES, cfg.limits.minApproachesBeforeBlocked ?? MIN_TRIED_APPROACHES);
+    const MAX_EARLY_BLOCKS = 3;
+    let earlyBlocks = 0;
     /** What went wrong on the way, counted for the register's figures. See `TaskStats`. */
     const stats = { formatErrors: 0, doneRejected: 0, repeatsRefused: 0, stepsRefused: 0, operatorStops: 0, reviewRejections: 0, scopeReverts: 0 };
     /** Loops the older guards do not see; see `progress.ts`. */
@@ -695,6 +706,10 @@ export async function runTask(transport, session, task, deps) {
             vcsNote: prepared.note,
             readOnlyNote: task.readOnly ? READ_ONLY_NOTE : undefined,
             scopeNote: scopeNote(scope, scopeEnforced),
+            approachesNote: minApproaches > MIN_TRIED_APPROACHES
+                ? `## Giving up\n\nThis task may end with status "blocked" only after at least ${minApproaches} genuinely different approaches, ` +
+                    `each listed in "tried". With fewer, the runner asks you for another approach instead of accepting it.`
+                : undefined,
             shellNote: shellNote(shells, defaultShell),
         });
         await setTask((t) => {
@@ -1277,9 +1292,36 @@ export async function runTask(transport, session, task, deps) {
              * what the reply said, at greater length and one message later. The reason carries the
              * approaches that were tried, and that is what the register shows.
              */
+            if (!blocked && reply.steps.length > 0)
+                earlyBlocks = 0;
+            if (blocked && reply.tried.length < minApproaches && earlyBlocks < MAX_EARLY_BLOCKS) {
+                /*
+                 * Too early to give up, by the operator's own measure (Settings → Execution). Sent back as a
+                 * request for another approach rather than accepted: the format only knows that two is the
+                 * floor, the operator decided this work deserves more tries than that.
+                 */
+                earlyBlocks += 1;
+                stats.blockedTooEarly = (stats.blockedTooEarly ?? 0) + 1;
+                sink.event('blocked-too-early', { tried: reply.tried.length, needed: minApproaches, time: earlyBlocks }, `"blocked" after ${reply.tried.length} approach(es); Settings ask for ${minApproaches}, so the chat is asked for another`, 'warn');
+                const message = `Not yet. This task is given up only after at least ${minApproaches} genuinely different approaches, and your reply lists ` +
+                    `${reply.tried.length}: ${reply.tried.map((x, i) => `(${i + 1}) ${x}`).join(' ')}. Try a different approach now — not one of ` +
+                    'these again, and not the same command reworded — and send its steps with status "continue". If it fails too, add it to ' +
+                    '"tried" and try another. Nothing you listed is lost: the runner keeps what has been tried.';
+                await record('BLOCKED TOO EARLY — MESSAGE SENT', message);
+                await pacer.throttleSend();
+                const before = await transport.sendAndConfirm(message);
+                const next = await transport.waitForReply(before);
+                await saveReply(`blocked-too-early-${earlyBlocks}`, next);
+                lastMarkdown = next.markdown;
+                await pacer.settle();
+                continue;
+            }
             if (blocked) {
                 sink.event('task-blocked', { tried: reply.tried, needed: reply.needed }, `the task was given up as blocked after ${reply.tried.length} approach(es)`, 'warn');
-                return await finish('blocked', blockedReason(reply.tried, reply.needed), reply.summary, lastMarkdown);
+                const early = reply.tried.length < minApproaches
+                    ? ` It gave up after ${reply.tried.length} of the ${minApproaches} approaches Settings ask for, having been asked ${earlyBlocks} time(s) for another.`
+                    : '';
+                return await finish('blocked', blockedReason(reply.tried, reply.needed) + early, reply.summary, lastMarkdown);
             }
             if (done && reply.steps.length === 0) {
                 const verdict = await gateOnChecks();

package/dist/src/plan/systemGuide.js

@@ -2844,6 +2844,38 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'Seconds to wait for a chat reply (default 900); a reply not finished by then fails the task with "Copilot did not finish a reply within …".',
                         doesBg: 'Секунди чакане на отговор от чата (по подразбиране 900); незавършен дотогава отговор проваля задачата с „Copilot did not finish a reply within …“.',
                     },
+                    {
+                        key: 'sync.show',
+                        kind: 'button',
+                        en: 'Command to bring this project back to the remote main branch',
+                        bg: 'Команда за връщане на проекта към основния клон на отдалеченото хранилище',
+                        doesEn: 'Under each project in Settings and on a session\u2019s version control: lists what would be lost and gives a PowerShell command to paste; the bot never runs it.',
+                        doesBg: 'Под всеки проект в Настройки и в контрола на версиите на сесия: изброява какво ще се загуби и дава команда за PowerShell; ботът никога не я пуска.',
+                    },
+                    {
+                        key: 'sync.copyPreview',
+                        kind: 'button',
+                        en: 'Copy the preview (changes nothing)',
+                        bg: 'Копирай прегледа (не променя нищо)',
+                        doesEn: 'Fetches and lists the commits, changes and new files the command would remove.',
+                        doesBg: 'Изтегля и изброява commit-ите, промените и новите файлове, които командата би махнала.',
+                    },
+                    {
+                        key: 'sync.copyCommand',
+                        kind: 'button',
+                        en: 'Copy the command',
+                        bg: 'Копирай командата',
+                        doesEn: 'fetch, reset --hard to the remote main, clean -fd — each only if the step before worked.',
+                        doesBg: 'fetch, reset --hard към основния клон, clean -fd — всяка само ако предишната е успяла.',
+                    },
+                    {
+                        key: 'exec.minApproaches',
+                        kind: 'field',
+                        en: 'Approaches the chat must try before it may give up',
+                        bg: 'Подходи, които чатът трябва да опита, преди да се откаже',
+                        doesEn: 'How many different approaches a "blocked" must list (2–20); with fewer the chat is asked for another.',
+                        doesBg: 'Колко различни подхода трябва да изброи „blocked“ (2–20); с по-малко чатът е помолен за още един.',
+                    },
                     {
                         key: 'exec.retryBlocked',
                         kind: 'field',

package/dist/src/session/compose.js

@@ -11,7 +11,7 @@ const TASK_HEADER = '## Task';
  * and a note that is empty simply leaves nothing behind.
  */
 function runnerBlock(input) {
-    const notes = [input.workDirNote, input.readOnlyNote, input.scopeNote, input.vcsNote, input.shellNote].map((n) => (n ?? '').trim()).filter((n) => n.length > 0);
+    const notes = [input.workDirNote, input.readOnlyNote, input.scopeNote, input.approachesNote, input.vcsNote, input.shellNote].map((n) => (n ?? '').trim()).filter((n) => n.length > 0);
     return notes.length > 0 ? `${notes.join('\n\n')}\n\n` : '';
 }
 /**

package/dist/src/transport/copilotTransport.js

@@ -57,65 +57,65 @@ export class SendRejectedError extends Error {
  * impossible — the runner notes it before the click and waits for it to move, so a copy that
  * did not happen reads as a failure rather than as the previous answer.
  */
-export const CLIPBOARD_GUARD = `(() => {
-  const state = { text: '', seq: 0 };
-  try {
-    Object.defineProperty(window, '__copClipboard', { value: state, enumerable: false });
-  } catch (e) {
-    window.__copClipboard = state;
-  }
-
-  const remember = (text) => {
-    if (typeof text !== 'string' || text.length === 0) return;
-    state.text = text;
-    state.seq += 1;
-  };
-
-  const clip = navigator.clipboard;
-  if (clip) {
-    try {
-      Object.defineProperty(clip, 'writeText', {
-        configurable: true,
-        writable: true,
-        value: (text) => {
-          remember(String(text));
-          return Promise.resolve();
-        },
-      });
-    } catch (e) { /* a frame that will not let its clipboard be replaced reads as a failure later */ }
-
-    try {
-      Object.defineProperty(clip, 'write', {
-        configurable: true,
-        writable: true,
-        value: async (items) => {
-          for (const item of items || []) {
-            try {
-              if (item && item.types && item.types.indexOf('text/plain') >= 0) {
-                remember(await (await item.getType('text/plain')).text());
-              }
-            } catch (e) { /* one unreadable item is not a reason to drop the rest */ }
-          }
-        },
-      });
-    } catch (e) { /* as above */ }
-  }
-
-  // The old way: select text in a hidden field, then execCommand('copy'). The selection is
-  // exactly the text being copied, so it is taken and the command is never run.
-  try {
-    const realExec = document.execCommand.bind(document);
-    document.execCommand = (command, ...rest) => {
-      if (String(command).toLowerCase() === 'copy') {
-        const selected = String(window.getSelection() || '');
-        if (selected.length > 0) {
-          remember(selected);
-          return true;
-        }
-      }
-      return realExec(command, ...rest);
-    };
-  } catch (e) { /* as above */ }
+export const CLIPBOARD_GUARD = `(() => {
+  const state = { text: '', seq: 0 };
+  try {
+    Object.defineProperty(window, '__copClipboard', { value: state, enumerable: false });
+  } catch (e) {
+    window.__copClipboard = state;
+  }
+
+  const remember = (text) => {
+    if (typeof text !== 'string' || text.length === 0) return;
+    state.text = text;
+    state.seq += 1;
+  };
+
+  const clip = navigator.clipboard;
+  if (clip) {
+    try {
+      Object.defineProperty(clip, 'writeText', {
+        configurable: true,
+        writable: true,
+        value: (text) => {
+          remember(String(text));
+          return Promise.resolve();
+        },
+      });
+    } catch (e) { /* a frame that will not let its clipboard be replaced reads as a failure later */ }
+
+    try {
+      Object.defineProperty(clip, 'write', {
+        configurable: true,
+        writable: true,
+        value: async (items) => {
+          for (const item of items || []) {
+            try {
+              if (item && item.types && item.types.indexOf('text/plain') >= 0) {
+                remember(await (await item.getType('text/plain')).text());
+              }
+            } catch (e) { /* one unreadable item is not a reason to drop the rest */ }
+          }
+        },
+      });
+    } catch (e) { /* as above */ }
+  }
+
+  // The old way: select text in a hidden field, then execCommand('copy'). The selection is
+  // exactly the text being copied, so it is taken and the command is never run.
+  try {
+    const realExec = document.execCommand.bind(document);
+    document.execCommand = (command, ...rest) => {
+      if (String(command).toLowerCase() === 'copy') {
+        const selected = String(window.getSelection() || '');
+        if (selected.length > 0) {
+          remember(selected);
+          return true;
+        }
+      }
+      return realExec(command, ...rest);
+    };
+  } catch (e) { /* as above */ }
 })();`;
 export class CopilotTransport {
     opts;
@@ -271,7 +271,7 @@ export class CopilotTransport {
             'sign-in': 'The profile is signed out. Run "cop login".',
             unknown: 'The page is not the Microsoft 365 Copilot chat.',
         };
-        throw new Error(`${explain[where] ?? explain.unknown}
+        throw new Error(`${explain[where] ?? explain.unknown}
 Current URL: ${url}`);
     }
     /**
@@ -680,14 +680,77 @@ Current URL: ${url}`);
         }
         await row.click({ timeout: 8_000 }).catch(() => undefined);
     }
-    /** Closes the picker, submenu included. */
+    /**
+     * Whether the model picker is open: its button says so (`aria-expanded`), or its rows are on screen.
+     * Both, because either alone has been wrong: rows can be mid-animation after the menu closed, and a
+     * button re-rendered by the page can lose the attribute while the menu is still up.
+     */
+    async modelMenuOpen() {
+        const button = await this.resolveModelButton(1_000);
+        const expanded = button ? await button.getAttribute('aria-expanded').catch(() => null) : null;
+        if (expanded === 'true')
+            return true;
+        return (await this.readMenuRows()).length > 0;
+    }
+    /**
+     * Closes the picker, submenu included, and makes sure it is closed.
+     *
+     * Escape pressed on the page was all this did, three times, and then it gave up without a word.
+     * Live, that left the model list open over the chat after a check of the model: Escape goes to
+     * whatever has focus, and after a click dispatched on a row, or no click at all because the model
+     * was already chosen, focus was not in the menu, so nothing heard it. Each way a person would close
+     * it is tried in turn, and the menu is looked at after each: Escape; Escape sent to the menu itself;
+     * the picker button again (it toggles); a click outside the menu, in the composer, which a Fluent
+     * popup takes as "close". A menu still open after all of them is reported, not passed over.
+     */
     async closeMenu() {
-        for (let i = 0; i < 3; i += 1) {
-            await this.p.keyboard.press('Escape').catch(() => undefined);
-            await this.p.waitForTimeout(200);
-            if ((await this.readMenuRows()).length === 0)
+        const ways = [
+            ['escape', async () => await this.p.keyboard.press('Escape')],
+            [
+                'escape in the menu',
+                async () => {
+                    for (const selector of Model.popupSelectors.slice(0, 2)) {
+                        const menu = this.p.locator(`${selector}:visible`).last();
+                        if ((await menu.count()) > 0) {
+                            await menu.press('Escape', { timeout: 2_000 });
+                            return;
+                        }
+                    }
+                },
+            ],
+            [
+                'the picker button',
+                async () => {
+                    const button = await this.resolveModelButton(1_000);
+                    // Only while the button itself says the menu is open: clicking it otherwise would open it.
+                    if (button && (await button.getAttribute('aria-expanded').catch(() => null)) === 'true')
+                        await button.click({ timeout: 3_000 });
+                },
+            ],
+            [
+                'a click outside',
+                async () => {
+                    const composer = this.composer();
+                    if ((await composer.count().catch(() => 0)) > 0 && (await composer.isVisible().catch(() => false)))
+                        await composer.click({ timeout: 3_000 });
+                    else
+                        await this.p.mouse.click(4, 4);
+                },
+            ],
+        ];
+        for (const [how, act] of ways) {
+            if (!(await this.modelMenuOpen()))
+                return;
+            await act().catch(() => undefined);
+            await this.p.waitForTimeout(250);
+            if (!(await this.modelMenuOpen())) {
+                if (how !== 'escape')
+                    this.emit('model-menu-closed', { how });
                 return;
+            }
         }
+        if (await this.modelMenuOpen())
+            this.emit('model-menu-stuck', { tried: ways.map(([how]) => how) });
     }
     /** The first popup container that becomes visible after the picker is clicked. */
     async waitForPopup(timeoutMs = 8_000) {
@@ -772,8 +835,7 @@ Current URL: ${url}`);
         await this.p.waitForTimeout(1_000);
         // Whatever the click did, the menu is not left open over the chat: a build that keeps it open
         // after a choice, or a click that did not land, would otherwise leave it for the next message.
-        if ((await this.readMenuRows()).length > 0)
-            await this.closeMenu();
+        await this.closeMenu();
         const after = await this.currentModel();
         // The button shows the choice, so it is the check. It also **shortens** it: picking
         // "GPT 5.6 Quick response" leaves the button reading "GPT 5.6 Quick". So a shown value

package/dist/src/vcs/syncCommand.js

@@ -0,0 +1,105 @@
+/**
+ * The command that brings a project's current branch back to the remote's main branch, handed to
+ * the operator rather than run.
+ *
+ * Asked for after a day of runs: a project left on a task branch, with files a step created and
+ * nobody committed, wants to go back to where the team's code is. That is `fetch`, `reset --hard`
+ * to the remote's main, and `clean -fd` for the new files git does not ignore — three commands that
+ * destroy work if pointed at the wrong folder or run a minute too early. So the bot never runs them.
+ * It reads the repository, says exactly what would be lost — commits on this branch that the
+ * remote's main does not have, changed tracked files, new files — and gives the command, ready to
+ * paste into PowerShell, with a read-only preview beside it. Ignored files (`node_modules`, `.env`,
+ * build output) are left alone: `clean` without `-x` does not touch them.
+ *
+ * Nothing here writes to the repository or the network. `git fetch` is in the command, not here:
+ * what "would be lost" is computed against the remote branch as last fetched, and the page says so.
+ */
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { git, porcelainPaths } from './git.js';
+/** A string as a single-quoted PowerShell literal: nothing inside it is expanded. */
+export function psQuote(text) {
+    return `'${text.replace(/'/g, "''")}'`;
+}
+/**
+ * The two commands, for Windows PowerShell 5.1 and PowerShell 7 alike: `;` and `$LASTEXITCODE`
+ * rather than `&&`, which 5.1 does not have, so a failed fetch stops everything after it instead
+ * of resetting to a remote branch that is out of date.
+ */
+export function syncCommands(dir, remote, target) {
+    const g = `git -C ${psQuote(dir)}`;
+    return {
+        preview: [
+            `${g} fetch ${psQuote(remote)}`,
+            `${g} log --oneline ${psQuote(`${target}..HEAD`)}`,
+            `${g} status --short`,
+            `${g} clean -nd`,
+        ].join('; '),
+        command: `${g} fetch ${psQuote(remote)}; if ($LASTEXITCODE -eq 0) { ${g} reset --hard ${psQuote(target)}; ` +
+            `if ($LASTEXITCODE -eq 0) { ${g} clean -fd } }`,
+    };
+}
+const empty = (repoDir, problem) => ({
+    ok: false,
+    problem,
+    repoDir,
+    willLose: { commits: [], changed: [], untracked: [] },
+    preview: '',
+    command: '',
+});
+export async function planSync(repoDir) {
+    const inside = await git(repoDir, ['rev-parse', '--is-inside-work-tree']);
+    if (!inside.ok || inside.stdout !== 'true')
+        return empty(repoDir, `${repoDir} is not a git repository.`);
+    const branch = await git(repoDir, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+    if (!branch.ok || !branch.stdout) {
+        return empty(repoDir, 'The repository is not on a branch (a detached HEAD), so there is no "current branch" to bring up to date. Check out a branch first.');
+    }
+    const remotes = (await git(repoDir, ['remote'])).stdout.split('\n').map((r) => r.trim()).filter(Boolean);
+    if (remotes.length === 0)
+        return empty(repoDir, 'The repository has no remote, so there is no remote main branch to go back to.');
+    const remote = remotes.includes('origin') ? 'origin' : remotes[0];
+    // The remote's own idea of its main branch first, then the two usual names.
+    let target = '';
+    const head = await git(repoDir, ['symbolic-ref', '--quiet', '--short', `refs/remotes/${remote}/HEAD`]);
+    if (head.ok && head.stdout)
+        target = head.stdout;
+    for (const name of ['main', 'master']) {
+        if (target)
+            break;
+        const found = await git(repoDir, ['rev-parse', '--verify', '--quiet', `refs/remotes/${remote}/${name}`]);
+        if (found.ok)
+            target = `${remote}/${name}`;
+    }
+    if (!target) {
+        return empty(repoDir, `No main branch of ${remote} is known here yet. Run ${syncCommands(repoDir, remote, `${remote}/main`).preview.split('; ')[0]} once, then look again.`);
+    }
+    const commits = await git(repoDir, ['log', '--format=%h %s', `${target}..HEAD`]);
+    const status = await git(repoDir, ['status', '--porcelain', '--untracked-files=no']);
+    const clean = await git(repoDir, ['clean', '-nd']);
+    let lastFetched;
+    try {
+        const gitDir = (await git(repoDir, ['rev-parse', '--absolute-git-dir'])).stdout;
+        lastFetched = statSync(join(gitDir, 'FETCH_HEAD')).mtime.toISOString();
+    }
+    catch {
+        /* never fetched: the page says so */
+    }
+    return {
+        ok: true,
+        repoDir,
+        branch: branch.stdout,
+        remote,
+        target,
+        ...(lastFetched ? { lastFetched } : {}),
+        willLose: {
+            commits: commits.ok && commits.stdout ? commits.stdout.split('\n') : [],
+            changed: porcelainPaths(status.stdout),
+            untracked: clean.stdout
+                .split('\n')
+                .map((l) => l.replace(/^Would remove\s+/, '').trim())
+                .filter(Boolean),
+        },
+        ...syncCommands(repoDir, remote, target),
+    };
+}