copilot-operator 0.1.22 → 0.1.25

package/dist/src/transport/copilotTransport.js

@@ -10,6 +10,7 @@
  *   2. Enter does not submit the composer. The Send button has to be clicked.
  *   3. A message cannot consist of an attachment alone; Send stays disabled without text.
  */
+import { pageModelFor } from './modelMatch.js';
 import { chromium } from 'playwright';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -76,65 +77,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;
@@ -290,7 +291,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}`);
     }
     /**
@@ -446,8 +447,15 @@ Current URL: ${url}`);
      */
     async nameChat(chatId, name) {
         const row = this.p.locator(`${Sidebar.conversationLink}[href*="${chatId}"]`).first();
-        if ((await row.count()) === 0)
+        // Waited for, like everything below: a new chat's row appears in the sidebar a moment after the
+        // reply, and `count()` read it as missing and returned without a word (live run 2026-10-03).
+        try {
+            await row.waitFor({ state: 'attached', timeout: 15_000 });
+        }
+        catch {
+            this.emit('chat-name-failed', { chatId, name, error: 'the conversation did not appear in the sidebar within 15 s' });
             return false;
+        }
         /*
          * Every step here waits for what it is about to click.
          *
@@ -868,7 +876,26 @@ Current URL: ${url}`);
         }
         if (!target) {
             await this.closeMenu();
-            return { ok: false, current: before, reason: `The picker does not offer "${name}" any more.` };
+            /*
+             * Not under that name: the line-up is read from the page, and the same model under its new name is
+             * chosen when exactly one fits (see `modelMatch.ts`). The list read goes back to the caller as well,
+             * so the saved catalogue follows the page (live run 2026-10-04: "GPT 5.6 Think deeper" had become
+             * "GPT 5.6 Sol Think deeper", and every run went on the default).
+             */
+            const read = await this.listModels().catch(() => null);
+            const options = read?.options ?? [];
+            const match = pageModelFor(name, options);
+            if (match && match.name.toLowerCase() !== name.toLowerCase()) {
+                const again = await this.selectModel(match.name);
+                return { ...again, matched: match.name, options };
+            }
+            const offered = options.filter((o) => !o.disabled).map((o) => o.name);
+            return {
+                ok: false,
+                current: before,
+                reason: `The picker does not offer "${name}" any more${offered.length > 0 ? `; it offers ${offered.map((o) => `"${o}"`).join(', ')}` : ''}.`,
+                ...(options.length > 0 ? { options } : {}),
+            };
         }
         /*
          * Already the one in force: close the menu and say so, without clicking.

package/dist/src/transport/modelMatch.js

@@ -0,0 +1,37 @@
+const words = (name) => name.toLowerCase().split(/\s+/).filter(Boolean);
+const isVersion = (w) => /^v?\d+(?:\.\d+)*$/.test(w);
+const versionOf = (ws) => (ws.find(isVersion) ?? '').replace(/^v/, '').split('.').map(Number).filter((n) => !Number.isNaN(n));
+function newer(a, b) {
+    for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+        const d = (a[i] ?? 0) - (b[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+export function pageModelFor(wanted, options) {
+    const offered = options.filter((o) => !o.disabled && o.name.trim());
+    const exact = offered.find((o) => o.name.trim().toLowerCase() === wanted.trim().toLowerCase());
+    if (exact)
+        return exact;
+    const want = words(wanted);
+    if (want.length === 0)
+        return null;
+    /** The options whose words hold all of `need`, same first word, fewest words added; null when two tie. */
+    const closest = (need, strip) => {
+        const fits = offered
+            .map((o) => ({ o, ws: strip(words(o.name)) }))
+            .filter(({ ws }) => ws[0] === need[0] && need.every((w) => ws.includes(w)))
+            .map(({ o, ws }) => ({ o, extra: ws.length - need.length }));
+        if (fits.length === 0)
+            return null;
+        const least = Math.min(...fits.map((f) => f.extra));
+        const best = fits.filter((f) => f.extra === least);
+        if (best.length === 1)
+            return best[0].o;
+        // The same name in several versions: the newest, which is what the line-up moved on to.
+        const byVersion = [...best].sort((a, b) => newer(versionOf(words(b.o.name)), versionOf(words(a.o.name))));
+        return newer(versionOf(words(byVersion[0].o.name)), versionOf(words(byVersion[1].o.name))) > 0 ? byVersion[0].o : null;
+    };
+    return closest(want, (ws) => ws) ?? closest(want.filter((w) => !isVersion(w)), (ws) => ws.filter((w) => !isVersion(w)));
+}

package/dist/src/vcs/artifacts.js

@@ -46,13 +46,19 @@ function excludeLine(pattern) {
     return `/${pattern.replace(/^\/+/, '')}`;
 }
 /**
- * Writes the session's artifact patterns into `.git/info/exclude`, once each. Returns the files
- * matching them that git already tracks, which an exclude does not stop from being committed.
+ * The runner's scratch folder in the project: helper scripts and temporary copies the chat needs while
+ * it works, never committed. Found live on 2026-10-03: the write-then-run pattern the contract teaches
+ * left `rewrite-report.ps1` and `tmp-report.txt` in the project root, and the task's commit swept them
+ * in with the work. The contract now sends such files here, and the folder is excluded from git.
+ */
+export const SCRATCH_DIR = '.cop-tmp';
+/**
+ * Writes the session's artifact patterns, and the runner's scratch folder, into `.git/info/exclude`,
+ * once each. Returns the files matching the patterns that git already tracks, which an exclude does
+ * not stop from being committed.
  */
 export async function excludeArtifacts(dir, session) {
     const patterns = artifactPatterns(session.vcs);
-    if (patterns.length === 0)
-        return { tracked: [] };
     const where = await git(dir, ['rev-parse', '--git-path', 'info/exclude']);
     if (!where.ok || !where.stdout)
         return { problem: "the repository's exclude file could not be found", tracked: [] };
@@ -61,16 +67,23 @@ export async function excludeArtifacts(dir, session) {
     const before = await readFile(file, 'utf8').catch(() => '');
     const have = new Set(before.split(/\r?\n/).map((l) => l.trim()));
     const add = patterns.map(excludeLine).filter((l) => !have.has(l));
-    if (add.length > 0) {
+    const scratch = `/${SCRATCH_DIR}/`;
+    const blocks = [];
+    if (!have.has(scratch))
+        blocks.push(`# copilot-operator: the runner's scratch folder — helper scripts and temporary files, never committed`, scratch);
+    if (add.length > 0)
+        blocks.push(`# copilot-operator: artifacts of session "${session.name.replace(/[\r\n]+/g, ' ')}" (${session.id}) — kept with the run, never committed`, ...add);
+    if (blocks.length > 0) {
         try {
             await mkdir(dirname(file), { recursive: true });
-            const block = [`# copilot-operator: artifacts of session "${session.name.replace(/[\r\n]+/g, ' ')}" (${session.id}) — kept with the run, never committed`, ...add, ''].join('\n');
-            await writeFile(file, `${before}${before && !before.endsWith('\n') ? '\n' : ''}${block}`, 'utf8');
+            await writeFile(file, `${before}${before && !before.endsWith('\n') ? '\n' : ''}${[...blocks, ''].join('\n')}`, 'utf8');
         }
         catch (e) {
             return { problem: `the exclude file could not be written: ${e.message}`, tracked: [] };
         }
     }
+    if (patterns.length === 0)
+        return { tracked: [] };
     const tracked = (await git(resolve(top), ['ls-files'])).stdout.split('\n').filter((p) => p && inScope(p, patterns));
     return { tracked };
 }

package/dist/src/vcs/commitHygiene.js

@@ -35,6 +35,8 @@ const GENERATED_DIRS = {
     '.mypy_cache': 'a type-checker cache',
     '.venv': 'a Python virtual environment',
     venv: 'a Python virtual environment',
+    tmp: 'a scratch folder (temporary files go in .cop-tmp, which is never committed)',
+    temp: 'a scratch folder (temporary files go in .cop-tmp, which is never committed)',
 };
 /** File names, or endings, that a tool writes and nobody reads. */
 const GENERATED_FILES = [
@@ -42,6 +44,8 @@ const GENERATED_FILES = [
     [(n) => n.endsWith('.log'), 'a log file'],
     [(n) => n === '.DS_Store' || n === 'Thumbs.db' || n === 'desktop.ini', "the operating system's folder metadata"],
     [(n) => n.endsWith('.pyc'), 'compiled Python'],
+    // The chat's own scratch copies, seen committed in a live run: tmp-report.txt, a .bak of a file it edited.
+    [(n) => /^(?:tmp|temp|scratch)(?:[-_.]|$)/i.test(n) || /\.(?:tmp|bak|orig|swp)$/i.test(n), 'a temporary copy (temporary files go in .cop-tmp, which is never committed)'],
 ];
 /** `.env` and its variants, except the ones that exist to be committed. */
 function isSecretsFile(name) {
@@ -96,7 +100,8 @@ export function findSuspicious(paths) {
 export function suspiciousDetail(found) {
     const list = found.map((s) => `${s.path} (${s.reason})`).join('; ');
     return (`${found.length} file(s) that look like tool output or secrets are in the working tree and would be committed ` +
-        `with this task: ${list}. Add them to .gitignore — they are installed, built or generated, not written — and ` +
-        'take them out of the index if git already tracks them. If one of them truly belongs in the repository, leave ' +
+        `with this task: ${list}. Add what is installed, built or generated to .gitignore, and take it out of the index if git ` +
+        'already tracks it; delete a temporary copy or scratch folder, or move it into .cop-tmp, which is never committed. ' +
+        'If one of them truly belongs in the repository, leave ' +
         'it and say why in your summary: it will be committed and marked.');
 }

package/dist/src/vcs/contentIntegrity.js

@@ -22,6 +22,11 @@ import { readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { gitBytes } from './git.js';
 import { looksGenerated } from './commitHygiene.js';
+const endingsOf = (bytes) => {
+    const text = bytes.toString('latin1');
+    const crlf = (text.match(/\r\n/g) ?? []).length;
+    return { crlf, lf: (text.match(/\n/g) ?? []).length - crlf };
+};
 /** Written files larger than this are almost always generated output. */
 export const OVERSIZED_BYTES = 1024 * 1024;
 /** Files that are binary by nature: their bytes are not text and are not looked into. */
@@ -98,8 +103,13 @@ export function traitsOf(path, bytes) {
         t['control-chars'] = `${control} control character(s)${text.includes('\u001B[') ? ', including terminal colour codes' : ''}`;
     const crlf = (text.match(/\r\n/g) ?? []).length;
     const lf = (text.match(/(?<!\r)\n/g) ?? []).length;
-    if (crlf > 0 && lf > 0)
-        t['mixed-line-endings'] = `${crlf} CRLF and ${lf} LF line ending(s) in one file`;
+    if (crlf > 0 && lf > 0) {
+        // The usual cause, said where it is the case: a here-string written with Set-Content/Out-File, which add a CRLF of their own at the end (live run 2026-10-04).
+        const lastOnly = crlf === 1 && text.endsWith('\r\n');
+        t['mixed-line-endings'] =
+            `${crlf} CRLF and ${lf} LF line ending(s) in one file` +
+                (lastOnly ? ' — only the last line ends in CRLF, as Set-Content and Out-File add one: write with -NoNewline and end the text with its own newline' : '');
+    }
     for (const [re, what] of SECRETS) {
         if (re.test(text)) {
             t.secret = `what looks like ${what}`;
@@ -114,7 +124,7 @@ export function traitsOf(path, bytes) {
  * A BOM in a new file counts only for formats it breaks; in a changed file, whenever the file had
  * none. Size counts only when the file crossed the line in this task.
  */
-export function newProblems(path, now, before) {
+export function newProblems(path, now, before, endings = { normalized: false }) {
     const ext = extensionOf(path);
     if (BINARY_EXTENSIONS.has(ext))
         return [];
@@ -126,13 +136,61 @@ export function newProblems(path, now, before) {
             continue;
         if (kind === 'bom' && !before && !BOM_BREAKS.has(ext))
             continue;
+        if (kind === 'mixed-line-endings' && endings.normalized)
+            continue;
         out.push({ path, kind, detail });
     }
+    /*
+     * A whole file turned from one ending to the other is a change on every line, and a mixed-endings
+     * test cannot see it: each version is consistent on its own. Found live on 2026-10-03, a task told to
+     * keep a JSON file's formatting rewrote it from LF to CRLF and it was committed that way. Not where git
+     * converts endings on commit.
+     */
+    if (!endings.normalized && !has['mixed-line-endings']) {
+        const n = endingsOf(now);
+        const only = n.crlf > 0 && n.lf === 0 ? 'crlf' : n.lf > 0 && n.crlf === 0 ? 'lf' : null;
+        if (only && before) {
+            const b = endingsOf(before);
+            const was = b.crlf > 0 && b.lf === 0 ? 'crlf' : b.lf > 0 && b.crlf === 0 ? 'lf' : null;
+            if (was && was !== only)
+                out.push({ path, kind: 'line-endings-changed', detail: `every line ending changed from ${was.toUpperCase()} to ${only.toUpperCase()}` });
+        }
+        /*
+         * A new file is not held to the repository's style: every file PowerShell's Set-Content writes ends
+         * its lines in CRLF, so on a repository without line-ending conversion that cost nearly every task a
+         * round. A file changed from one ending to the other is the change that misleads a diff.
+         */
+    }
     return out;
 }
+/** Whether git converts line endings in this repository on commit, and the style its files have. */
+export async function lineEndingRule(dir) {
+    const auto = (await gitBytes(dir, ['config', '--get', 'core.autocrlf'])).stdout.toString('utf8').trim().toLowerCase();
+    if (auto === 'true' || auto === 'input')
+        return { normalized: true };
+    const eol = await gitBytes(dir, ['ls-files', '--eol']);
+    let lf = 0;
+    let crlf = 0;
+    for (const line of eol.stdout.toString('utf8').split('\n')) {
+        // i/lf    w/lf    attr/text=auto   path
+        const m = /^i\/(\S*)\s+w\/\S*\s+attr\/(\S*)/.exec(line);
+        if (!m)
+            continue;
+        if (/(^|\s)(text|eol=)/.test(m[2] ?? '') && !/-text/.test(m[2] ?? ''))
+            return { normalized: true };
+        if (m[1] === 'lf')
+            lf += 1;
+        else if (m[1] === 'crlf')
+            crlf += 1;
+    }
+    const total = lf + crlf;
+    const style = total >= 3 && lf / total >= 0.8 ? 'lf' : total >= 3 && crlf / total >= 0.8 ? 'crlf' : undefined;
+    return { normalized: false, ...(style ? { style } : {}) };
+}
 /** The problems the task added to these working-tree paths, compared with `baseCommit`. */
 export async function scanChanges(dir, paths, baseCommit, limit = 400) {
     const found = [];
+    const endings = await lineEndingRule(dir);
     for (const rel of paths.slice(0, limit)) {
         if (rel.endsWith('/') || looksGenerated(rel))
             continue;
@@ -159,7 +217,7 @@ export async function scanChanges(dir, paths, baseCommit, limit = 400) {
             const shown = await gitBytes(dir, ['show', `${baseCommit}:${rel.replace(/\\/g, '/')}`]);
             before = shown.ok ? shown.stdout : null;
         }
-        found.push(...newProblems(rel, now, before));
+        found.push(...newProblems(rel, now, before, endings));
     }
     return found;
 }
@@ -168,7 +226,8 @@ export function integrityDetail(found) {
     const list = found.slice(0, 20).map((f) => `${f.path}: ${f.detail}`).join('; ');
     return (`${found.length} problem(s) in the text of files this task changed, none of them there before it: ${list}` +
         `${found.length > 20 ? `; and ${found.length - 20} more` : ''}. Write the files again as UTF-8 without a byte-order mark ` +
-        '(in PowerShell 5.1 use [IO.File]::WriteAllText with New-Object Text.UTF8Encoding($false), not Set-Content -Encoding utf8), ' +
-        'one kind of line ending per file, no terminal colour codes, and no credentials — load those from the environment. ' +
+        '(in PowerShell 5.1: $f = [IO.File]; $f::WriteAllText($path, $text, (New-Object Text.UTF8Encoding($false))) — not Set-Content -Encoding utf8), ' +
+        'the line endings the file and the repository already use (Set-Content adds a Windows line ending after the last line: use -NoNewline and end the here-string with an empty line), ' +
+        'no terminal colour codes, and no credentials — load those from the environment. ' +
         'If one of these is intended, leave it and say why in your summary: it will be committed and the finding kept on the task.');
 }

package/dist/src/vcs/git.js

@@ -16,7 +16,7 @@
  *     commit message cannot turn into another command.
  */
 import { execFile } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { readFile, stat } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
@@ -44,19 +44,56 @@ function noHooksDir() {
     return process.env.SystemRoot ? join(process.env.SystemRoot, 'System32', 'copilot-operator-no-hooks') : '/nonexistent';
 }
 /** Runs one git command in a directory. Never throws: the caller decides what a failure means. */
-export function git(cwd, args, timeoutMs = 60_000, env) {
+export function git(cwd, args, timeoutMs = 60_000, env, 
+/**
+ * `windowsHide: false` only for a fetch the operator is sitting at, whose password window must be seen.
+ * `killTree`: on the timeout, stop git and everything it started. The plain timeout stops git.exe
+ * alone, and a fetch's ssh and its password window outlived it (found 2026-10-03: the window stayed
+ * on screen after the fetch had been given up).
+ */
+opts = {}) {
     return new Promise((resolve) => {
-        execFile('git', [...SAFE_GIT, ...args], { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 8 * 1024 * 1024, ...(env ? { env } : {}) }, (error, stdout, stderr) => {
+        let timedOut = false;
+        let timer;
+        const child = execFile('git', [...SAFE_GIT, ...args], { cwd, timeout: opts.killTree ? 0 : timeoutMs, windowsHide: opts.windowsHide ?? true, maxBuffer: 8 * 1024 * 1024, ...(env ? { env } : {}) }, (error, stdout, stderr) => {
+            if (timer)
+                clearTimeout(timer);
             const code = error?.code;
             resolve({
-                ok: !error,
+                ok: !error && !timedOut,
                 stdout: (stdout ?? '').trim(),
-                stderr: (stderr ?? '').trim(),
-                code: typeof code === 'number' ? code : error ? 1 : 0,
+                stderr: `${(stderr ?? '').trim()}${timedOut ? `${stderr ? '\n' : ''}git gave up after ${Math.round(timeoutMs / 1000)} s` : ''}`.trim(),
+                code: typeof code === 'number' ? code : error || timedOut ? 1 : 0,
             });
         });
+        if (opts.killTree && child.pid) {
+            const pid = child.pid;
+            timer = setTimeout(() => {
+                timedOut = true;
+                if (process.platform === 'win32')
+                    execFile('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true }, () => undefined);
+                else
+                    child.kill('SIGKILL');
+            }, timeoutMs);
+        }
     });
 }
+/**
+ * When this repository last fetched successfully, or undefined when that cannot be told.
+ *
+ * Read from FETCH_HEAD, but only when it holds something: git empties it at the start of every fetch,
+ * so a fetch that failed — a passphrase not typed, a network down — leaves an empty file with a fresh
+ * time, and that time read as "last fetched a minute ago" (seen live on 2026-10-03).
+ */
+export function lastFetchedAt(gitDir) {
+    try {
+        const s = statSync(join(gitDir, 'FETCH_HEAD'));
+        return s.size > 0 ? s.mtime.toISOString() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Everything the runner needs to know about a repository before it touches it. */
 export async function repoState(dir) {
     const empty = { isRepo: false, branch: null, head: null, dirty: false, changed: [] };
@@ -241,7 +278,7 @@ export async function updateFromRemote(dir, branch) {
     const current = await git(dir, ['rev-parse', '--abbrev-ref', 'HEAD']);
     const moved = current.ok && current.stdout === branch
         ? await git(dir, ['merge', '--ff-only', '--quiet', to])
-        : await git(dir, ['update-ref', `refs/heads/${branch}`, to, from]);
+        : await git(dir, ['update-ref', '-m', `copilot-operator: brought up to date with ${tracking}`, `refs/heads/${branch}`, to, from]);
     if (!moved.ok)
         return { branch, remote: tracking, outcome: 'failed', from, to, detail: (moved.stderr || moved.stdout).split(/\r?\n/)[0] };
     return { branch, remote: tracking, outcome: 'updated', from, to };

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, porcelainPaths, RUNNER_EMAIL } from './git.js';
-const QUIET = { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never', GIT_ASKPASS: '', SSH_ASKPASS: '' };
+import { branchNameFrom, freeBranchName, git, lastFetchedAt, porcelainPaths, RUNNER_EMAIL } from './git.js';
+import { closePasswordWindows, describeFetchFailure, fetchCommandFor, operatorFetchEnv, QUIET_FETCH_ENV } 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()) {
@@ -62,7 +62,9 @@ const empty = (repoDir, problem) => ({
 });
 /**
  * What preparing the folder would do. Fetches the remote when `fetch` is true (the preview); reads
- * only when it is false (the preparation, which must compare against what the preview fetched).
+ * only when it is false (the preparation, which must compare against what the preview fetched, or a
+ * preview after the operator fetched in their own terminal). With `askpass`, the fetch may ask for a
+ * password through that program (see `remoteAuth.ts`); without it, it may not ask at all.
  */
 export async function planPrepare(folder, opts) {
     const inside = await git(folder, ['rev-parse', '--is-inside-work-tree']);
@@ -84,13 +86,30 @@ export async function planPrepare(folder, opts) {
     if (remotes.length === 0)
         return empty(repoDir, 'The repository has no remote, so there is no remote main branch to prepare it from.');
     const remote = remotes.includes('origin') ? 'origin' : remotes[0];
+    const fetchCommand = fetchCommandFor(repoDir, remote);
+    // Read before fetching: a fetch that fails empties FETCH_HEAD, and with it the time of the last one that worked.
+    const lastBefore = gitDir ? lastFetchedAt(gitDir) : undefined;
     let fetched;
     if (opts.fetch) {
-        const f = await git(repoDir, ['-c', 'credential.interactive=false', 'fetch', '--quiet', '--no-tags', '--prune', remote], 120_000, QUIET);
-        fetched = f.ok ? { ok: true } : { ok: false, detail: (f.stderr || f.stdout || 'git fetch failed').split(/\r?\n/)[0] };
-        // The remote's own idea of its main branch, asked of it now; a remote that will not say keeps the old answer.
+        /*
+         * 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.
+         */
+        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);
+        const f = await git(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)
-            await git(repoDir, ['remote', 'set-head', remote, '--auto'], 60_000, QUIET);
+            fetched = { ok: true, asked };
+        else {
+            const why = describeFetchFailure(f.stderr || f.stdout);
+            fetched = { ok: false, detail: why.detail, auth: why.auth, asked };
+        }
     }
     let target = '';
     const remoteHead = await git(repoDir, ['symbolic-ref', '--quiet', '--short', `refs/remotes/${remote}/HEAD`]);
@@ -102,14 +121,21 @@ export async function planPrepare(folder, opts) {
         if ((await git(repoDir, ['rev-parse', '--verify', '--quiet', `refs/remotes/${remote}/${name}`])).ok)
             target = `${remote}/${name}`;
     }
+    const last = fetched && !fetched.ok ? lastBefore : gitDir ? lastFetchedAt(gitDir) : undefined;
     if (!target) {
         return {
             ...empty(repoDir, fetched && !fetched.ok ? `The remote could not be fetched (${fetched.detail}), and no main branch of ${remote} is known here.` : `No main branch of ${remote} is known here.`),
             ...(fetched ? { fetched } : {}),
+            fetchCommand,
         };
     }
     if (fetched && !fetched.ok) {
-        return { ...empty(repoDir, `The remote could not be fetched, so the folder would be set to an old copy of ${target}: ${fetched.detail}. Nothing was changed.`), fetched };
+        return {
+            ...empty(repoDir, `The remote could not be fetched, so the folder would be set to an old copy of ${target}: ${fetched.detail}. Nothing was changed.`),
+            fetched,
+            fetchCommand,
+            ...(last ? { lastFetched: last } : {}),
+        };
     }
     const targetCommit = (await git(repoDir, ['rev-parse', '--verify', '--quiet', `refs/remotes/${target}^{commit}`])).stdout;
     if (!targetCommit)
@@ -144,6 +170,8 @@ export async function planPrepare(folder, opts) {
         localBranch,
         localHead,
         ...(fetched ? { fetched } : {}),
+        ...(last ? { lastFetched: last } : {}),
+        fetchCommand,
         changed,
         untracked,
         mainOnlyCommits,
@@ -191,8 +219,17 @@ async function keepUncommitted(dir, head, branch, message) {
     }
 }
 /** Does it, after checking the folder is still what the preview showed. */
-export async function prepareFromRemote(folder, fingerprint, opts = {}) {
+export async function prepareFromRemote(folder, fingerprint, 
+/** `names`: the saved-branch names the preview showed, used when still free, so Confirm makes what was shown. */
+opts = {}) {
     const plan = await planPrepare(folder, { fetch: false, prefix: opts.prefix });
+    // The names the operator saw, not ones stamped a minute later (live run 2026-10-03).
+    const prefix = opts.prefix || 'cop/';
+    const free = async (name) => !!name && name.startsWith(`${prefix}saved/`) && !(await git(plan.repoDir, ['rev-parse', '--verify', '--quiet', `refs/heads/${name}`])).ok;
+    if (plan.savedBranch && (await free(opts.names?.savedBranch)))
+        plan.savedBranch = opts.names.savedBranch;
+    if (plan.savedMainBranch && (await free(opts.names?.savedMainBranch)))
+        plan.savedMainBranch = opts.names.savedMainBranch;
     if (!plan.ok)
         return { ok: false, problem: plan.problem ?? 'the folder could not be read.' };
     const repoDir = plan.repoDir;