copilot-operator 0.1.11 → 0.1.13

package/dist/src/session/story.js

@@ -12,9 +12,42 @@
  * Nothing here is inferred. An entry is a file, or a section of the task log, or a field of
  * the task record; the reader decides what it means.
  */
-import { readdir, readFile } from 'node:fs/promises';
+import { readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 const MAX_TEXT = 60_000;
+/*
+ * When each thing happened.
+ *
+ * Every entry of the story is a file the runner wrote at the moment it happened: a reply is saved
+ * as it arrives, a step's log is opened as the step starts, a results file is written just before
+ * it is sent. So a file's creation time is the entry's time, for runs recorded long before anyone
+ * asked for times as much as for new ones — nothing had to be recorded differently. The modification
+ * time is the fallback on a file system that keeps no creation time. The opening message has no file
+ * of its own and takes its time from the transcript's first "message-sent".
+ */
+async function createdAt(path) {
+    const info = await stat(path).catch(() => null);
+    if (!info)
+        return undefined;
+    const ms = info.birthtimeMs > 0 ? info.birthtimeMs : info.mtimeMs;
+    return new Date(ms).toISOString();
+}
+async function firstSentAt(dir) {
+    const text = await readFile(join(dir, 'transcript.jsonl'), 'utf8').catch(() => '');
+    for (const line of text.split('\n')) {
+        if (!line.includes('"message-sent"'))
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (e.type === 'message-sent' && e.at)
+                return e.at;
+        }
+        catch {
+            /* a line cut off by a crash */
+        }
+    }
+    return undefined;
+}
 function clip(text) {
     return text.length > MAX_TEXT ? `${text.slice(0, MAX_TEXT)}\n… (${text.length - MAX_TEXT} more characters in the run folder)` : text;
 }
@@ -73,6 +106,7 @@ async function stepsIn(dir) {
         const iteration = Number(m[1]);
         const parsed = parseStepLog(await readFile(join(dir, name), 'utf8').catch(() => ''));
         const entry = {
+            at: await createdAt(join(dir, name)),
             kind: 'step',
             iteration,
             id: Number(m[2]),
@@ -103,21 +137,41 @@ async function reviewRound(dir, round) {
     const read = async (name) => clip(await readFile(join(dir, name), 'utf8').catch(() => ''));
     const names = (await readdir(dir).catch(() => [])).sort();
     if (names.includes('00-brief.md'))
-        entries.push({ kind: 'sent', iteration: 0, label: 'brief', text: await read('00-brief.md') });
+        entries.push({ kind: 'sent', iteration: 0, label: 'brief', text: await read('00-brief.md'), at: await createdAt(join(dir, '00-brief.md')) });
     const steps = await stepsIn(join(dir, 'steps'));
-    const replies = names.filter((n) => /^\d+-review\.md$/.test(n)).sort();
-    for (const [i, name] of replies.entries()) {
-        const text = await read(name);
-        const parsed = parseReply(text);
-        entries.push({ kind: 'reply', iteration: i + 1, label: `review ${round}, reply ${i + 1}`, text, ...parsed });
-        for (const step of steps.get(i + 1) ?? [])
+    /*
+     * The replies, by what they answer. `00-opening.md` is the answer to the brief — the one that
+     * proposes the first steps — and `NN-review.md` the answer to the results of iteration NN (the
+     * review saves it after sending them). So after reply k come the steps of iteration k + 1 and
+     * their results, then reply k + 1. The story used to read only the `NN-review` files and put each
+     * before the steps it came after; the times on the entries are what showed it.
+     */
+    const replyFor = new Map();
+    if (names.includes('00-opening.md'))
+        replyFor.set(0, '00-opening.md');
+    for (const n of names) {
+        const m = n.match(/^(\d+)-review\.md$/);
+        if (m)
+            replyFor.set(Number(m[1]), n);
+    }
+    const last = Math.max(0, ...replyFor.keys(), ...steps.keys());
+    for (let k = 0; k <= last; k += 1) {
+        const name = replyFor.get(k);
+        if (name) {
+            const text = await read(name);
+            entries.push({ kind: 'reply', iteration: k, label: `review ${round}, reply ${k + 1}`, text, ...parseReply(text), at: await createdAt(join(dir, name)) });
+        }
+        for (const step of steps.get(k + 1) ?? [])
             entries.push(step);
-        if (names.includes(`iteration-${i + 1}.txt`))
-            entries.push({ kind: 'sent', iteration: i + 1, label: `results ${i + 1}`, text: await read(`iteration-${i + 1}.txt`) });
+        if (names.includes(`iteration-${k + 1}.txt`)) {
+            entries.push({ kind: 'sent', iteration: k + 1, label: `results ${k + 1}`, text: await read(`iteration-${k + 1}.txt`), at: await createdAt(join(dir, `iteration-${k + 1}.txt`)) });
+        }
+    }
+    const replies = [...replyFor.values()];
+    if (names.includes('findings-sent.md')) {
+        entries.push({ kind: 'sent', iteration: replies.length, label: 'findings sent to the implementer', text: await read('findings-sent.md'), at: await createdAt(join(dir, 'findings-sent.md')) });
     }
-    if (names.includes('findings-sent.md'))
-        entries.push({ kind: 'sent', iteration: replies.length, label: 'findings sent to the implementer', text: await read('findings-sent.md') });
-    return { kind: 'review', round, entries };
+    return { kind: 'review', round, entries, at: entries.find((e) => e.at)?.at };
 }
 export async function buildStory(runsDir, runId, task, live) {
     const dir = join(runsDir, runId);
@@ -126,7 +180,9 @@ export async function buildStory(runsDir, runId, task, live) {
     const entries = [];
     const opening = sections.find((s) => s.name === 'OPENING MESSAGE');
     if (opening)
-        entries.push({ kind: 'sent', iteration: 0, label: 'opening message', text: clip(opening.text) });
+        entries.push({ kind: 'sent', iteration: 0, label: 'opening message', text: clip(opening.text), at: (await firstSentAt(dir)) ?? task.startedAt });
+    /** The results file of iteration k, as the report writer names it by default; its creation is when it was sent. */
+    const resultsAt = async (k) => await createdAt(join(dir, 'reports', `iteration-${k}.txt`));
     const steps = await stepsIn(join(dir, 'steps'));
     const reports = new Map();
     for (const s of sections) {
@@ -161,7 +217,7 @@ export async function buildStory(runsDir, runId, task, live) {
             for (const step of steps.get(k) ?? [])
                 entries.push(step);
             if (reports.has(k))
-                entries.push({ kind: 'sent', iteration: k, label: `results ${k}`, text: clip(reports.get(k)) });
+                entries.push({ kind: 'sent', iteration: k, label: `results ${k}`, text: clip(reports.get(k)), at: await resultsAt(k) });
             lastIteration = k;
         }
         else if (rv) {
@@ -170,14 +226,14 @@ export async function buildStory(runsDir, runId, task, live) {
             for (const step of steps.get(lastIteration + 1) ?? [])
                 entries.push(step);
             if (reports.has(lastIteration + 1))
-                entries.push({ kind: 'sent', iteration: lastIteration + 1, label: `results ${lastIteration + 1}`, text: clip(reports.get(lastIteration + 1)) });
+                entries.push({ kind: 'sent', iteration: lastIteration + 1, label: `results ${lastIteration + 1}`, text: clip(reports.get(lastIteration + 1)), at: await resultsAt(lastIteration + 1) });
             lastIteration += reports.has(lastIteration + 1) ? 1 : 0;
             if (!placedReviews.has(round)) {
                 entries.push(await reviewRound(join(dir, 'review', String(round)), round));
                 placedReviews.add(round);
             }
         }
-        entries.push({ kind: 'reply', iteration: it ? Number(it[1]) : 0, label, text, ...parsed });
+        entries.push({ kind: 'reply', iteration: it ? Number(it[1]) : 0, label, text, ...parsed, at: await createdAt(join(dir, 'replies', name)) });
     }
     // Steps and results after the last reply (a task that ended without another reply), and
     // review rounds nobody replied to yet (one still going, or the last one that passed).
@@ -186,7 +242,7 @@ export async function buildStory(runsDir, runId, task, live) {
             for (const step of list)
                 entries.push(step);
             if (reports.has(k))
-                entries.push({ kind: 'sent', iteration: k, label: `results ${k}`, text: clip(reports.get(k)) });
+                entries.push({ kind: 'sent', iteration: k, label: `results ${k}`, text: clip(reports.get(k)), at: await resultsAt(k) });
         }
     }
     for (const round of reviewDirs) {

package/dist/src/transport/chatTransport.js

@@ -20,6 +20,7 @@
  * running in this process — a check script — can call `setTransportFactory`.
  */
 import { CopilotTransport } from './copilotTransport.js';
+export { ReplyTimeoutError, isReplyTimeout } from './copilotTransport.js';
 const realChat = (opts) => new CopilotTransport(opts);
 let factory = realChat;
 /** A chat for these options: the real Copilot window, unless a check has put a scripted one in. */

package/dist/src/transport/copilotTransport.js

@@ -18,6 +18,25 @@ import { landed } from './acceptance.js';
 import { Blocker, Css, Label, Model, Rename, Sidebar, Signal, Surface, TestId, Upload, Url } from './locators.js';
 import { acquireProfileLock } from './profileLock.js';
 import { parseChatId } from './chatSession.js';
+/**
+ * The chat did not finish a reply within `copilot.replyTimeoutSec`.
+ *
+ * Its own class because it is a limit from the settings, not a fault: the runner ends the task
+ * `limit-reached` on it, so "Continue" carries the task on in the same chat, where the reply may
+ * well have finished by then. Any other error from the transport still fails the task.
+ */
+export class ReplyTimeoutError extends Error {
+    seconds;
+    constructor(seconds, message) {
+        super(message);
+        this.seconds = seconds;
+        this.name = 'ReplyTimeoutError';
+    }
+}
+/** Recognised by name as well: a copy of this module loaded twice makes `instanceof` miss its own class. */
+export function isReplyTimeout(e) {
+    return e instanceof ReplyTimeoutError || (e instanceof Error && e.name === 'ReplyTimeoutError' && typeof e.seconds === 'number');
+}
 const ORIGIN = 'https://m365.cloud.microsoft';
 /** Escapes a model name so it can be matched literally inside a regular expression. */
 function escapeForRegExp(text) {
@@ -57,65 +76,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 +290,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}`);
     }
     /**
@@ -1119,7 +1138,7 @@ Current URL: ${url}`);
         }
         if (!sawNewTurn || !last.finished) {
             await this.dumpFailure(join(this.opts.transportDir, '..', 'failures'), 'reply-timeout').catch(() => undefined);
-            throw new Error(`Copilot did not finish a reply within ${Math.round(this.opts.replyTimeoutMs / 1000)}s ` +
+            throw new ReplyTimeoutError(Math.round(this.opts.replyTimeoutMs / 1000), `Copilot did not finish a reply within ${Math.round(this.opts.replyTimeoutMs / 1000)}s ` +
                 `(new turn seen: ${sawNewTurn}, still streaming: ${last.streaming}). ` +
                 'A screenshot and an HTML dump are in the run folder.');
         }

package/dist/src/vcs/git.js

@@ -44,9 +44,9 @@ 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) {
+export function git(cwd, args, timeoutMs = 60_000, env) {
     return new Promise((resolve) => {
-        execFile('git', [...SAFE_GIT, ...args], { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 8 * 1024 * 1024 }, (error, stdout, stderr) => {
+        execFile('git', [...SAFE_GIT, ...args], { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 8 * 1024 * 1024, ...(env ? { env } : {}) }, (error, stdout, stderr) => {
             const code = error?.code;
             resolve({
                 ok: !error,
@@ -155,6 +155,21 @@ export function branchNameFrom(parts, prefix = 'cop/') {
  */
 export function plannedBranchName(raw, prefix = 'cop/', attempt = 1) {
     const trimmed = raw.trim();
+    /*
+     * A name with its own namespace — `recovery/apz-migration`, `feature/JIRA-123-schemas` — is the
+     * team's convention, and it is used as written: the prefix is only for names that have none.
+     * Flattening it to `cop/recovery-apz-migration` made a different branch from the one asked for,
+     * so a plan continuing a recovery branch worked beside it instead of on it (2026-09-30). Each
+     * segment is still made safe, keeping its case; git itself has the last word in `switchTo`.
+     */
+    if (trimmed.includes('/')) {
+        const segments = trimmed
+            .split('/')
+            .map((seg) => seg.replace(/[^\p{L}\p{N}._-]+/gu, '-').replace(/^[-.]+|[-.]+$/g, ''))
+            .filter(Boolean);
+        if (segments.length > 1)
+            return `${segments.join('/')}${attempt > 1 ? `-a${attempt}` : ''}`.replace(/\.\.+/g, '.').slice(0, 200);
+    }
     const p = prefix.trim();
     const body = p && trimmed.toLowerCase().startsWith(p.toLowerCase()) ? trimmed.slice(p.length) : trimmed;
     return branchNameFrom([body, attempt > 1 ? `a${attempt}` : undefined], prefix);
@@ -163,6 +178,81 @@ export async function isValidBranchName(dir, name) {
     const r = await git(dir, ['check-ref-format', '--branch', name]);
     return r.ok;
 }
+/**
+ * Brings a local branch up to date with its remote: `git fetch`, then a fast-forward and nothing else.
+ *
+ * Asked for on 2026-09-30, so a session's branch is cut from the code as it is on the server and not
+ * from whatever this checkout last pulled. Never a reset, a merge commit or a rewrite: a branch with
+ * commits of its own (ahead) or one that has gone its own way (diverged) is left as it is, and the
+ * outcome says so. The remote is the branch's upstream, or `origin` when it has none; a repository
+ * with neither is left alone. git is not allowed to ask for credentials — a prompt would hang the run,
+ * and a sign-in window on a machine nobody is watching is worse — so a remote that needs a password
+ * git does not already have fails the fetch, which is reported, not fatal.
+ */
+export async function updateFromRemote(dir, branch) {
+    const local = await git(dir, ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}^{commit}`]);
+    if (!local.ok || !local.stdout)
+        return { branch, outcome: 'failed', detail: `there is no local branch ${branch}` };
+    const upstream = await git(dir, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', `${branch}@{upstream}`]);
+    let remote = '';
+    let remoteBranch = branch;
+    if (upstream.ok && upstream.stdout.includes('/')) {
+        remote = upstream.stdout.slice(0, upstream.stdout.indexOf('/'));
+        remoteBranch = upstream.stdout.slice(remote.length + 1);
+    }
+    else {
+        const remotes = await git(dir, ['remote']);
+        const names = remotes.ok ? remotes.stdout.split(/\r?\n/).map((r) => r.trim()).filter(Boolean) : [];
+        if (names.includes('origin'))
+            remote = 'origin';
+    }
+    if (!remote)
+        return { branch, outcome: 'no-remote', detail: 'the repository has no remote to update from' };
+    const tracking = `${remote}/${remoteBranch}`;
+    const quiet = { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never', GIT_ASKPASS: '', SSH_ASKPASS: '' };
+    const fetched = await git(dir, ['-c', 'credential.interactive=false', 'fetch', '--quiet', '--no-tags', remote, `+refs/heads/${remoteBranch}:refs/remotes/${tracking}`], 90_000, quiet);
+    if (!fetched.ok) {
+        return { branch, remote: tracking, outcome: 'fetch-failed', detail: (fetched.stderr || fetched.stdout || 'git fetch failed').split(/\r?\n/)[0] };
+    }
+    const theirs = await git(dir, ['rev-parse', '--verify', '--quiet', `refs/remotes/${tracking}^{commit}`]);
+    if (!theirs.ok || !theirs.stdout)
+        return { branch, remote: tracking, outcome: 'no-remote', detail: `${tracking} does not exist on the remote` };
+    const from = local.stdout;
+    const to = theirs.stdout;
+    if (from === to)
+        return { branch, remote: tracking, outcome: 'up-to-date', from, to };
+    if (await isAncestor(dir, to, from))
+        return { branch, remote: tracking, outcome: 'ahead', from, to, detail: `${branch} has commits ${tracking} does not; it was left as it is` };
+    if (!(await isAncestor(dir, from, to))) {
+        return { branch, remote: tracking, outcome: 'diverged', from, to, detail: `${branch} and ${tracking} have each gone their own way; ${branch} was left as it is` };
+    }
+    // Forward only. A branch that is checked out moves with its tree (clean, or the caller would not be
+    // here); one that is not is moved by its ref, and only if it still is where it was read.
+    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]);
+    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 };
+}
+/** One line for the log and the session page. */
+export function describeUpdate(u) {
+    const short = (c) => (c ? c.slice(0, 8) : '?');
+    switch (u.outcome) {
+        case 'updated':
+            return `${u.branch} brought up to date with ${u.remote}: ${short(u.from)} → ${short(u.to)}`;
+        case 'up-to-date':
+            return `${u.branch} was already up to date with ${u.remote}`;
+        default:
+            return `${u.branch} not updated from the remote: ${u.detail ?? u.outcome}`;
+    }
+}
+/** The local branches of a repository, by name; empty when it cannot be read. */
+export async function localBranches(dir) {
+    const r = await git(dir, ['for-each-ref', '--format=%(refname:short)', 'refs/heads']);
+    return r.ok ? r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean) : [];
+}
 export async function branchExists(dir, name) {
     const r = await git(dir, ['rev-parse', '--verify', '--quiet', `refs/heads/${name}`]);
     return r.ok && r.stdout.length > 0;