letagents 0.12.34 → 0.12.36

package/shared/ui/useRoomMessageMotion.ts

@@ -0,0 +1,195 @@
+import { inject, nextTick, onBeforeUnmount, onDeactivated, onMounted, onScopeDispose, provide, ref, shallowRef, watch, type InjectionKey, type Ref } from 'vue';
+import { appendedMotionMessages, captureWork, createRoomMessageAnimator, sameMotionAgent, type MotionMessage, type MessageMotionIdentity, type WorkGeometry } from './room-message-motion';
+
+interface SendOrigin {
+  text: string; bounds: DOMRect; keyboard: boolean; messageId?: string;
+}
+function createSendContext() {
+  const revision = ref(0);
+  let pending: SendOrigin | null = null;
+  return {
+    revision,
+    capture(text: string, input: HTMLTextAreaElement | null) {
+      if (!input) return () => {};
+      const origin = { text, bounds: input.getBoundingClientRect(), keyboard: document.activeElement === input };
+      pending = origin;
+      return () => { if (pending === origin) pending = null; };
+    },
+    confirmation(text: string) {
+      const origin = pending?.text === text ? pending : null;
+      return (messageId: string) => {
+        if (origin && pending === origin) { origin.messageId = messageId; revision.value++; }
+      };
+    },
+    consume(message: MotionMessage) {
+      if (!pending || !(pending.messageId ? pending.messageId === message.id : message.outgoing && pending.text === message.text)) return null;
+      const result = pending; pending = null; return result;
+    },
+    peekId() { return pending?.messageId; },
+    clear() { pending = null; },
+  };
+}
+const sendKey: InjectionKey<ReturnType<typeof createSendContext>> = Symbol('room-message-send-motion');
+export function provideRoomMessageMotion(scope: () => string | null | undefined) {
+  const context = createSendContext();
+  provide(sendKey, context);
+  watch(scope, context.clear, { flush: 'sync' });
+  onBeforeUnmount(context.clear);
+  onDeactivated(context.clear);
+  return context;
+}
+export function injectRoomMessageMotion() { return inject(sendKey, null); }
+
+/** Keep the visible origin across independently delivered work/message updates.
+ * One second covers a brief stream handoff, without leaving no-reply turns working.
+ * This is presentation only: it never changes agent state or room messages.
+ */
+export function useRoomWorkHandoff<T>(options: {
+  work: () => readonly T[];
+  identity: (work: T) => MessageMotionIdentity;
+  after: (work: T) => string | null | undefined;
+  messages: () => readonly MotionMessage[];
+  scope: () => string | null | undefined;
+  enabled: () => boolean;
+}) {
+  const work = shallowRef<readonly T[]>([]);
+  let pending: { value: T; expires: number }[] = [];
+  let previous: readonly T[] = [];
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const clear = () => {
+    clearTimeout(timer); timer = undefined; pending = [];
+    work.value = previous = options.work();
+  };
+  const sameTurn = (a: T, b: T) => sameMotionAgent(options.identity(a), options.identity(b)) && options.after(a) === options.after(b);
+  function update() {
+    clearTimeout(timer); timer = undefined;
+    const current = options.work(), messages = options.messages(), now = Date.now();
+    if (!options.enabled() || (typeof document !== 'undefined' && document.visibilityState === 'hidden')
+      || (typeof window !== 'undefined' && window.matchMedia?.('(prefers-reduced-motion: reduce)').matches)) { clear(); return; }
+    const eligible = (value: T) => {
+      const after = options.after(value), start = messages.findIndex(message => message.id === after);
+      if (!after || start < 0) return false;
+      // A matching reply consumes this turn. A new source from the same
+      // agent must not inherit a previous turn's presentation.
+      return !messages.slice(start + 1).some(message => sameMotionAgent(options.identity(value), message))
+        && !current.some(item => sameMotionAgent(options.identity(item), options.identity(value)) && !sameTurn(item, value));
+    };
+    pending = pending.filter(item => item.expires > now && eligible(item.value) && !current.some(value => sameTurn(value, item.value)));
+    for (const value of previous) {
+      if (!current.some(item => sameTurn(item, value)) && !pending.some(item => sameTurn(item.value, value)) && eligible(value)) {
+        pending.push({ value, expires: now + 1000 });
+      }
+    }
+    previous = current;
+    work.value = [...current, ...pending.map(item => item.value)];
+    if (pending.length) timer = setTimeout(update, Math.max(0, Math.min(...pending.map(item => item.expires)) - now));
+  }
+  watch([options.work, options.messages], update, { immediate: true, deep: true });
+  watch(options.scope, () => { clear(); work.value = previous = []; }, { flush: 'sync' });
+  watch(options.enabled, enabled => { if (!enabled) clear(); }, { flush: 'sync' });
+  onScopeDispose(() => { clearTimeout(timer); });
+  return { work, clear };
+}
+
+/** Lists own scrolling/history; an own send requests latest before measuring its landing. */
+export function useRoomMessageMotion(options: {
+  element: Ref<HTMLElement | null>;
+  /** Work rows pinned outside the scrolling list. A reply still grows from its row there. */
+  work?: Ref<HTMLElement | null>;
+  messages: () => MotionMessage[];
+  scope: () => string | null | undefined;
+  ready: () => boolean;
+  following: () => boolean;
+  scrollToLatest: () => void;
+  onInterrupt?: () => void;
+}) {
+  const send = injectRoomMessageMotion();
+  const animator = createRoomMessageAnimator(() => options.element.value, () => options.work?.value ?? null);
+  let previous = options.messages().map(message => message.stableId);
+  let revision = 0;
+  let media: MediaQueryList | null = null;
+  const cancel = () => { revision++; animator.cancel(); };
+  const interrupt = () => { cancel(); options.onInterrupt?.(); };
+  watch(options.scope, () => { interrupt(); previous = options.messages().map(message => message.stableId); }, { flush: 'sync' });
+  watch(options.ready, ready => { if (!ready) interrupt(); });
+  watch([options.messages, () => send?.revision.value], async ([messages]) => {
+    const seen = new Set(previous);
+    const appended = appendedMotionMessages(previous, messages);
+    previous = messages.map(message => message.stableId);
+    // A first message in an empty room is allowed only when this composer sent it.
+    // A late acknowledgement consumes the origin without replaying an earlier echo.
+    const outgoing = messages.find(message => message.id === send?.peekId() || message.outgoing);
+    const candidates = [...appended];
+    if (outgoing && !candidates.includes(outgoing)) candidates.push(outgoing);
+    const sends = new Map<string, SendOrigin>();
+    for (const message of candidates) {
+      const source = send?.consume(message);
+      if (source) sends.set(message.id, source);
+    }
+    if (!appended.length && !sends.size) return;
+    const element = options.element.value;
+    const following = options.following();
+    // Capture the current presentation before cancelling a previous flight, so
+    // rapid arrivals continue from where the visible rows actually are.
+    const viewport = element?.getBoundingClientRect();
+    const positions = new Map<HTMLElement, DOMRect>();
+    if (element && viewport && following && options.ready()) {
+      for (const row of element.querySelectorAll<HTMLElement>('[data-message-id], [data-msg-id]')) {
+        const bounds = row.getBoundingClientRect();
+        if (bounds.bottom > viewport.top && bounds.top < viewport.bottom) positions.set(row, bounds);
+      }
+    }
+    cancel();
+    const currentRevision = revision;
+    if (!element || !options.ready() || (!following && !sends.size)) return;
+    const sources = new Map<string, WorkGeometry>();
+    const used = new Set<HTMLElement>();
+    const workRows = [...(options.work?.value ?? element).querySelectorAll<HTMLElement>('[data-motion-work]')];
+    for (const message of appended) {
+      const matches = workRows.filter(work => !used.has(work) && sameMotionAgent(message, { session: work.dataset.motionSession, key: work.dataset.motionAgent })
+        && (!work.dataset.motionAfter || (messages.findIndex(item => item.id === work.dataset.motionAfter) >= 0 && messages.findIndex(item => item.id === work.dataset.motionAfter) < messages.indexOf(message))));
+      if (matches.length !== 1) continue;
+      const source = captureWork(matches[0]);
+      if (source) { sources.set(message.id, source); used.add(matches[0]); }
+    }
+    await nextTick();
+    // Scroll followers may themselves be queued by this render (e.g. an API acknowledgement).
+    await nextTick();
+    if (currentRevision !== revision || !options.ready() || element !== options.element.value) return;
+    // This is navigation requested by the sender, including reduced motion and
+    // a late web acknowledgement after its stream echo. Never replay that echo.
+    if (sends.size) options.scrollToLatest();
+    if (media?.matches || document.visibilityState === 'hidden') return;
+    animator.move(positions);
+    const rows = [...element.querySelectorAll<HTMLElement>('[data-message-id], [data-msg-id]')];
+    for (const message of candidates) {
+      const row = rows.find(row => (row.dataset.messageId || row.dataset.msgId) === message.id);
+      if (!row) continue;
+      const bounds = row.getBoundingClientRect(), viewport = element.getBoundingClientRect();
+      if (bounds.bottom < viewport.top || bounds.top > viewport.bottom) continue;
+      const origin = sends.get(message.id), work = sources.get(message.id);
+      if (origin && !seen.has(message.stableId)) animator.send(row, origin.bounds, origin.keyboard);
+      else if (work) animator.reply(row, work);
+      else if (appended.includes(message)) animator.reveal(row);
+    }
+  });
+  const onKey = (event: KeyboardEvent) => { if (['PageUp', 'PageDown', 'Home', 'End', 'ArrowUp', 'ArrowDown'].includes(event.key)) interrupt(); };
+  onMounted(() => {
+    media = typeof window.matchMedia === 'function' ? window.matchMedia('(prefers-reduced-motion: reduce)') : null;
+    media?.addEventListener('change', interrupt);
+    window.addEventListener('resize', interrupt);
+    options.element.value?.addEventListener('wheel', interrupt, { passive: true });
+    options.element.value?.addEventListener('touchstart', interrupt, { passive: true });
+    options.element.value?.addEventListener('pointerdown', interrupt, { passive: true });
+    options.element.value?.addEventListener('keydown', onKey);
+  });
+  onDeactivated(interrupt);
+  onBeforeUnmount(() => {
+    interrupt(); media?.removeEventListener('change', interrupt); window.removeEventListener('resize', interrupt);
+    options.element.value?.removeEventListener('wheel', interrupt);
+    options.element.value?.removeEventListener('touchstart', interrupt);
+    options.element.value?.removeEventListener('pointerdown', interrupt);
+    options.element.value?.removeEventListener('keydown', onKey);
+  });
+  return { cancel: interrupt };
+}

package/shared/ui/useSlidingTabIndicator.ts

@@ -0,0 +1,72 @@
+import { onBeforeUnmount, onMounted, onUpdated, ref, watch } from "vue";
+
+/** One underline, shared by the desktop and web room headers. */
+export function useSlidingTabIndicator(activeTab: () => string) {
+  const tabsElement = ref<HTMLElement | null>(null);
+  const indicatorElement = ref<HTMLElement | null>(null);
+  let animation: Animation | null = null;
+  let motion: MediaQueryList | undefined;
+  let resizeObserver: ResizeObserver | undefined;
+  let animateNextChange = false;
+  let placed = false;
+
+  function position(animate = false): void {
+    const tabs = tabsElement.value;
+    const indicator = indicatorElement.value;
+    const selected = tabs?.querySelector<HTMLElement>('[aria-current="page"]');
+    if (!tabs || !indicator || !selected) {
+      animation?.cancel();
+      if (indicator) indicator.style.visibility = "hidden";
+      placed = false;
+      return;
+    }
+    const width = selected.offsetWidth;
+    if (!width) return;
+    const target = `translate(${selected.offsetLeft}px, ${selected.offsetTop + selected.offsetHeight - 2}px)`;
+    // Content updates and ResizeObserver notifications must not restart a running move.
+    if (placed && indicator.style.transform === target && indicator.style.width === `${width}px`) return;
+    const previous = indicator.getBoundingClientRect();
+    const origin = tabs.getBoundingClientRect();
+    animation?.cancel();
+    animation = null;
+    indicator.style.width = `${width}px`;
+    indicator.style.transform = target;
+    indicator.style.visibility = "visible";
+    if (animate && placed && !motion?.matches && indicator.animate) {
+      animation = indicator.animate([
+        { transform: `translate(${previous.left - origin.left + tabs.scrollLeft}px, ${previous.top - origin.top + tabs.scrollTop}px) scaleX(${previous.width / width})` },
+        { transform: `${target} scaleX(1)` },
+      ], { duration: 240, easing: "cubic-bezier(.22, 1, .36, 1)" });
+    }
+    placed = true;
+  }
+
+  function prepareTabChange(event: MouseEvent, tab: string): void {
+    animateNextChange = event.detail > 0 && tab !== activeTab();
+  }
+
+  function syncLayout(): void { position(); }
+  function syncMotion(): void { animation?.cancel(); animation = null; position(); }
+
+  watch(activeTab, () => {
+    position(animateNextChange);
+    animateNextChange = false;
+  }, { flush: "post" });
+  onUpdated(syncLayout);
+  onMounted(() => {
+    motion = window.matchMedia?.("(prefers-reduced-motion: reduce)");
+    motion?.addEventListener("change", syncMotion);
+    if (typeof ResizeObserver !== "undefined" && tabsElement.value) {
+      resizeObserver = new ResizeObserver(syncLayout);
+      resizeObserver.observe(tabsElement.value);
+    }
+    syncLayout();
+  });
+  onBeforeUnmount(() => {
+    animation?.cancel();
+    resizeObserver?.disconnect();
+    motion?.removeEventListener("change", syncMotion);
+  });
+
+  return { tabsElement, indicatorElement, prepareTabChange };
+}

package/shared/workspace-change-capture.mjs

@@ -5,10 +5,12 @@ import { join } from 'node:path';
 import { promisify } from 'node:util';
 import { WORKSPACE_FILE_LIMIT, WORKSPACE_PATCH_LIMIT, parseWorkspaceChangeSummary } from './workspace-change-summary.mjs';
 const execute = promisify(execFile);
+// Replace refs are off: with them the workspace could put another tree in the place of the
+// one a comparison starts from, and the comparison would show nothing.
 async function git(cwd, args, limit = 4 * 1024 * 1024) {
     const result = await execute('git', ['--no-optional-locks', ...args], {
         cwd, encoding: 'utf8', timeout: 5_000, maxBuffer: limit,
-        env: { ...Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_'))), GIT_TERMINAL_PROMPT: '0' },
+        env: { ...Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_'))), GIT_TERMINAL_PROMPT: '0', GIT_NO_REPLACE_OBJECTS: '1' },
     });
     return result.stdout;
 }

package/shared/workspace-turn-capture.d.mts

@@ -3,7 +3,10 @@ import type { WorkspaceReview } from './workspace-review.mjs';
 export function unavailableWorkspace(): WorkspaceChangeSummary;
 export function captureWorkspaceTree(workspace: string, identity: string): Promise<string | null>;
 export function releaseWorkspaceTree(workspace: string, identity: string): Promise<void>;
-export function captureWorkspacePair(workspace: string, startingRevision: string | null, baseline: string | null, identity: string): Promise<{
+export function captureWorkspaceHead(workspace: string): Promise<string | null>;
+export function captureRemoteTips(workspace: string): Promise<string[] | null>;
+export function captureRecordedRemoteTips(url: string | null | undefined, directory?: string): Promise<string[] | null>;
+export function captureWorkspacePair(workspace: string, startingRevision: string | null, baseline: string | null, identity: string, startingHead?: string | null, remoteTips?: readonly string[] | null | Promise<readonly string[] | null>): Promise<{
   workspace: WorkspaceChangeSummary;
   contribution: { changes: WorkspaceChangeSummary; summary: string | null };
   review: WorkspaceReview;

package/shared/workspace-turn-capture.mjs

@@ -1,21 +1,49 @@
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { constants } from 'node:fs';
 import { lstat, mkdtemp, open, readlink, realpath, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { devNull, tmpdir } from 'node:os';
 import { dirname, join, relative } from 'node:path';
 import { createHash } from 'node:crypto';
 import { captureWorkspaceChanges } from './workspace-change-capture.mjs';
 const environment = () => Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_')));
-function git(cwd, args, signal, index, input) {
+// Replace refs are off: with them the workspace could put any object in the place of
+// the one a capture reads (a base's tree, the start snapshot itself).
+function git(cwd, args, signal, index, input, extra) {
     return new Promise((resolve, reject) => {
         const child = execFile('git', ['-c', 'core.hooksPath=/dev/null', '--no-optional-locks', ...args], {
             cwd, signal, timeout: 5_000, maxBuffer: 4 * 8 * 1024 * 1024, encoding: 'utf8',
-            env: { ...environment(), GIT_TERMINAL_PROMPT: '0', ...(index ? { GIT_INDEX_FILE: index } : {}) },
+            env: { ...environment(), GIT_TERMINAL_PROMPT: '0', GIT_NO_REPLACE_OBJECTS: '1', ...(index ? { GIT_INDEX_FILE: index } : {}), ...extra },
         }, (error, stdout) => error ? reject(error) : resolve(stdout));
         child.stdin?.on('error', () => { });
         child.stdin?.end(input);
     });
 }
+/**
+ * A Git command that starts a transport of its own (ssh, a credential or remote
+ * helper). Killing Git alone leaves a stalled transport running. So the command
+ * has its own process group, and when the time is up the whole group is killed
+ * and the answer does not wait for anything.
+ */
+function remoteGit(cwd, args, signal, extra) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', ['-c', 'core.hooksPath=/dev/null', '--no-optional-locks', ...args], {
+            cwd, detached: process.platform !== 'win32', stdio: ['ignore', 'pipe', 'ignore'],
+            env: { ...environment(), GIT_TERMINAL_PROMPT: '0', GIT_NO_REPLACE_OBJECTS: '1', ...extra },
+        });
+        let output = '';
+        const stop = () => {
+            try { process.kill(-child.pid, 'SIGKILL'); }
+            catch { child.kill('SIGKILL'); } // No process group on this platform, or it is gone.
+            child.stdout.destroy();
+            reject(new Error('The remote did not answer in time.'));
+        };
+        if (signal.aborted) stop();
+        else signal.addEventListener('abort', stop, { once: true });
+        child.stdout.setEncoding('utf8').on('data', (chunk) => { if ((output += chunk).length > 4 * 8 * 1024 * 1024) stop(); });
+        child.once('error', reject);
+        child.once('close', (code) => { signal.removeEventListener('abort', stop); code === 0 ? resolve(output) : reject(new Error('Git could not ask the remote.')); });
+    });
+}
 export const unavailableWorkspace = () => ({ captured_at: new Date().toISOString(), branch: null,
     base_revision: null, state: 'unavailable', files: [], additions: 0, deletions: 0, hidden_files: 0, patch: '', patch_truncated: false });
 const reviewRef = (identity) => `refs/letagents/workspace-review/${createHash('sha256').update(identity).digest('hex')}`;
@@ -101,11 +129,180 @@ export async function releaseWorkspaceTree(workspace, identity) {
     }
     catch { /* Retain on failure, never jeopardize provider work. */ }
 }
-export async function captureWorkspacePair(workspace, startingRevision, baseline, identity) {
+/** The commit a piece of work starts on. With it and the remotes' tips, the settled capture can tell a base update from the work. */
+export async function captureWorkspaceHead(workspace) {
+    return git(workspace, ['rev-parse', '--verify', 'HEAD^{commit}'], AbortSignal.timeout(5_000)).then(value => value.trim(), () => null);
+}
+const objectId = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+const noPrompt = (ssh) => ({ GIT_SSH_COMMAND: `${ssh} -o BatchMode=yes -o ConnectTimeout=5`, GIT_ASKPASS: '', SSH_ASKPASS: '', SSH_ASKPASS_REQUIRE: 'never', GCM_INTERACTIVE: 'never' });
+const branchTips = (listed) => [...new Set(listed.flatMap(lines => lines.split('\n').map(line => line.split('\t')[0])))].filter(tip => objectId.test(tip));
+/**
+ * The commit of every branch on every configured remote, asked from the remotes
+ * themselves before a piece of work starts. It is the only evidence of "upstream"
+ * the capture accepts: remote-tracking branches and reflogs are local files that
+ * the work can move or clear. Resolves to null when there is no remote or when a
+ * remote does not answer; all of them together get five seconds, and then Git is
+ * killed. It never rejects and never asks for a password, a passphrase or a host
+ * key. Start it without waiting, so that a slow remote cannot delay the work, and
+ * await it when the work has settled.
+ *
+ * The repository's own configuration names the remotes here, and whoever can
+ * write that configuration can name another repository. That is acceptable only
+ * for a worker that reports its own work from its own clone (the MCP capture
+ * tools). A supervisor that must not take the workspace's word asks the remote it
+ * recorded itself: captureRecordedRemoteTips.
+ */
+export async function captureRemoteTips(workspace) {
+    const signal = AbortSignal.timeout(5_000);
+    try {
+        const remotes = (await git(workspace, ['remote'], signal)).split('\n').filter(Boolean);
+        if (!remotes.length)
+            return null;
+        const ssh = process.env.GIT_SSH_COMMAND || (await git(workspace, ['config', '--get', 'core.sshCommand'], signal).catch(() => '')).trim() || 'ssh';
+        return branchTips(await Promise.all(remotes.map(remote => remoteGit(workspace, ['-c', 'credential.interactive=false', 'ls-remote', '--heads', '--', remote], signal, noPrompt(ssh)))));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The same question for one remote that the caller recorded itself, with the same
+ * bound and the same silence. The remote is asked by URL, and Git runs with no
+ * repository (GIT_DIR names nothing). So nothing that the work can write in the
+ * workspace or in the repository it shares applies: not a remote's url, not a
+ * url.<base>.insteadOf rewrite, not a worktree or included configuration file.
+ * The owner's own Git configuration (global and system) still applies, because a
+ * private remote needs the owner's stored credentials, SSH command and proxy. If
+ * that configuration sends this URL somewhere else, there is no answer. Which
+ * recorded remotes are worth asking is the caller's decision. Git starts in
+ * `directory`, which is not the workspace; with no repository it does not matter
+ * where.
+ */
+export async function captureRecordedRemoteTips(url, directory = tmpdir()) {
+    const signal = AbortSignal.timeout(5_000);
+    try {
+        if (typeof url !== 'string' || !url)
+            return null;
+        const outside = { GIT_DIR: devNull };
+        const ssh = process.env.GIT_SSH_COMMAND || (await git(directory, ['config', '--get', 'core.sshCommand'], signal, undefined, undefined, outside).catch(() => '')).trim() || 'ssh';
+        const quiet = { ...outside, ...noPrompt(ssh) };
+        // An insteadOf rewrite, or a remote that is named like the URL, shows in the address Git would use.
+        if ((await git(directory, ['ls-remote', '--get-url', '--', url], signal, undefined, undefined, quiet)).trim() !== url)
+            return null;
+        return branchTips([await remoteGit(directory, ['-c', 'credential.interactive=false', 'ls-remote', '--heads', '--', url], signal, quiet)]);
+    }
+    catch {
+        return null;
+    }
+}
+async function changedEntries(root, from, to, signal) {
+    const parts = (await git(root, ['diff-tree', '-r', '-z', '--no-renames', '--no-abbrev', from, to], signal)).split('\0');
+    const entries = new Map();
+    for (let i = 0; i + 1 < parts.length; i += 2) {
+        const [oldMode, newMode, oldId, newId] = parts[i].slice(1).split(' ');
+        entries.set(parts[i + 1], [`${oldMode} ${oldId}`, `${newMode} ${newId}`]);
+    }
+    return entries;
+}
+const parents = (path) => path.split('/').slice(0, -1).map((_, index, parts) => parts.slice(0, index + 1).join('/'));
+/**
+ * The tree to compare a settled turn against so that the result is the agent's
+ * own changes. A fetch followed by a checkout, merge, rebase or pull brings
+ * upstream commits into the workspace; compared tree to tree, all of them look
+ * like work done in the turn.
+ *
+ * `remoteTips` is what the remotes held before the turn (captureRemoteTips or
+ * captureRecordedRemoteTips). The
+ * new base N is the one tip among them that HEAD gained during the turn: an
+ * ancestor of HEAD now, not an ancestor of `startingHead`. The old base B is the
+ * merge base of `startingHead` and N. Then, for each path that differs between B
+ * and N, with S the start tree and E the settled tree:
+ *  - S has B's content and E has N's content: the path changed only because the
+ *    base moved. It is not in the comparison.
+ *  - S has B's content and E differs from N: the turn changed the path, and it is
+ *    measured against N. This includes a path that was put back to its old
+ *    content, where S equals E: the turn dropped an upstream change.
+ *  - S differs from B: the path was changed here before the base moved. It is
+ *    measured from S as before; a resolved merge conflict shows here.
+ * Every other path is measured from S as before.
+ *
+ * So a path leaves the comparison only when its settled content is, byte for
+ * byte, content that a remote already held before the turn started. Nothing made
+ * during the turn can be hidden, whatever happens to local refs afterwards.
+ * Without that certainty the result is `start`, the plain comparison: no answer
+ * from the remotes, an unknown starting commit, no tip or more than one
+ * independent tip gained, or any Git failure.
+ */
+async function ownStartingTree(workspace, start, startingHead, remoteTips) {
+    if (!objectId.test(start ?? '') || !objectId.test(startingHead ?? '') || !Array.isArray(remoteTips))
+        return start;
+    const signal = AbortSignal.timeout(20_000);
+    let scratch;
+    try {
+        const root = await realpath(workspace);
+        const gained = new Set((await git(root, ['rev-list', 'HEAD', `^${startingHead}`], signal)).split('\n'));
+        const candidates = [...new Set(remoteTips)].filter(tip => objectId.test(tip) && gained.has(tip));
+        if (!candidates.length || candidates.length > 256)
+            return start;
+        // A tip that another gained tip already contains is not a second base.
+        const newest = candidates.length > 1 ? (await git(root, ['merge-base', '--independent', ...candidates], signal)).split('\n').filter(Boolean) : candidates;
+        if (newest.length !== 1)
+            return start;
+        const [base] = newest;
+        const old = (await git(root, ['merge-base', startingHead, base], signal)).trim();
+        // The trees hold the files as they are on disk. With core.autocrlf those are not the
+        // committed bytes, and a sparse checkout leaves files out: an untouched file would
+        // look changed against the new base. Neither can make a changed file look untouched.
+        if (/ (?:true|yes|on|1)$/im.test(await git(root, ['config', '--get-regexp', '^core\\.(autocrlf|sparsecheckout)$'], signal).catch(() => '')))
+            return start;
+        const incoming = await changedEntries(root, `${old}^{tree}`, `${base}^{tree}`, signal);
+        const touched = await changedEntries(root, `${old}^{tree}`, `${start}^{tree}`, signal);
+        const absent = `000000 ${'0'.repeat(base.length)}`;
+        const kept = [...touched].filter(([, [, entry]]) => entry !== absent).map(([path]) => path);
+        const keptFiles = new Set(kept);
+        const keptDirectories = new Set(kept.flatMap(parents));
+        const entries = [];
+        for (const [path, [, entry]] of incoming) {
+            // A file cannot take the place of a directory that holds an earlier change, or the reverse. The earlier change stays.
+            if (touched.has(path) || (entry !== absent && (keptDirectories.has(path) || parents(path).some(parent => keptFiles.has(parent)))))
+                continue;
+            entries.push(`${entry}\t${path}\0`);
+        }
+        if (!entries.length)
+            return start;
+        scratch = await mkdtemp(join(tmpdir(), 'letagents-workspace-'));
+        const index = join(scratch, 'index');
+        await git(root, ['read-tree', `${start}^{tree}`], signal, index);
+        await git(root, ['update-index', '-z', '--index-info'], signal, index, entries.join(''));
+        return (await git(root, ['write-tree'], signal, index)).trim();
+    }
+    catch {
+        return start;
+    }
+    finally {
+        if (scratch)
+            await rm(scratch, { recursive: true, force: true });
+    }
+}
+/**
+ * `startingHead` and `remoteTips` describe the moment `baseline` was captured:
+ * the commit HEAD was on, and what the remotes held (the answer, or the pending
+ * question). Without both, the turn's changes are the plain difference between
+ * the two trees. The changes since the workspace started are always the plain
+ * difference.
+ */
+export async function captureWorkspacePair(workspace, startingRevision, baseline, identity, startingHead = null, remoteTips = null) {
     const tree = await captureWorkspaceTree(workspace, `${identity}:settled`);
     try {
         const full = tree ? await captureWorkspaceChanges(workspace, startingRevision, tree, true) : unavailableWorkspace();
-        const changes = tree && baseline ? await captureWorkspaceChanges(workspace, baseline, tree, true) : unavailableWorkspace();
+        const turn = async () => {
+            // The settled files are already captured: a remote that is still silent delays only this
+            // comparison, and a question that failed in any way leaves the plain one.
+            const from = await ownStartingTree(workspace, baseline, startingHead, await Promise.resolve(remoteTips).catch(() => null));
+            const own = from === baseline ? null : await captureWorkspaceChanges(workspace, from, tree, true);
+            return own?.state === 'ready' ? { ...own, base_revision: baseline } : captureWorkspaceChanges(workspace, baseline, tree, true);
+        };
+        const changes = tree && baseline ? await turn() : unavailableWorkspace();
         const preview = (snapshot) => ({ ...snapshot,
             files: snapshot.files.slice(0, 200), hidden_files: snapshot.hidden_files + Math.max(0, snapshot.files.length - 200),
             patch: snapshot.patch.slice(0, 48 * 1024), patch_truncated: snapshot.patch_truncated || snapshot.patch.length > 48 * 1024 });