letagents 0.12.35 → 0.12.36

package/shared/ui/room-message-motion.ts

@@ -0,0 +1,143 @@
+/** Geometry and WAAPI effects shared by the real desktop and web timelines. */
+export interface MessageMotionIdentity { session?: string | null; key?: string | null }
+export interface MotionMessage extends MessageMotionIdentity {
+  id: string; stableId: string; text: string; outgoing?: boolean;
+}
+export function sameMotionAgent(a: MessageMotionIdentity, b: MessageMotionIdentity): boolean {
+  if (a.session && b.session) return a.session === b.session;
+  return Boolean(a.key && b.key && a.key.trim().toLowerCase() === b.key.trim().toLowerCase());
+}
+export function appendedMotionMessages(previous: readonly string[], messages: readonly MotionMessage[]): MotionMessage[] {
+  if (!previous.length) return [];
+  const last = messages.findIndex(message => message.stableId === previous.at(-1));
+  if (last < 0) return [];
+  const seen = new Set(previous);
+  return messages.slice(last + 1).filter(message => !seen.has(message.stableId));
+}
+const bubbleSelector = '.room-message-bubble, .message-bubble';
+const metaSelector = '.room-message-meta, .message-meta';
+const avatarSelector = '.room-chat-avatar, .message-avatar';
+const ease = 'cubic-bezier(.22,1,.36,1)';
+export interface WorkGeometry {
+  bounds: DOMRect; pulse: DOMRect; name: DOMRect; summary: DOMRect;
+  clone: HTMLElement; dots: Keyframe[];
+}
+export function captureWork(element: HTMLElement): WorkGeometry | null {
+  const pulse = element.querySelector<HTMLElement>('.room-local-agent-work-pulse');
+  const name = element.querySelector<HTMLElement>('strong');
+  const summary = element.querySelector<HTMLElement>('.room-local-agent-work-copy > span');
+  if (!pulse || !name || !summary) return null;
+  return {
+    bounds: element.getBoundingClientRect(), pulse: pulse.getBoundingClientRect(),
+    name: name.getBoundingClientRect(), summary: summary.getBoundingClientRect(),
+    clone: element.cloneNode(true) as HTMLElement,
+    dots: [...element.querySelectorAll('i')].map(dot => {
+      const style = getComputedStyle(dot); return { opacity: style.opacity, transform: style.transform };
+    }),
+  };
+}
+/** `work` is where work rows live when they are pinned outside the scrolling `viewport`. */
+export function createRoomMessageAnimator(viewport: () => HTMLElement | null, work: () => HTMLElement | null = () => null) {
+  const animations = new Set<Animation>();
+  const cleanups = new Set<() => void>();
+  function animate(element: Element | null, frames: Keyframe[], options: KeyframeAnimationOptions) {
+    if (!element || typeof element.animate !== 'function') return null;
+    const animation = element.animate(frames, options);
+    animations.add(animation);
+    animation.finished.then(() => animations.delete(animation), () => animations.delete(animation));
+    return animation;
+  }
+  function cancel() {
+    animations.forEach(animation => animation.cancel()); animations.clear();
+    cleanups.forEach(cleanup => cleanup()); cleanups.clear();
+  }
+  function layer() {
+    const element = document.createElement('div');
+    element.className = 'room-message-motion-layer';
+    element.setAttribute('aria-hidden', 'true'); element.inert = true;
+    Object.assign(element.style, { position: 'fixed', inset: '0', pointerEvents: 'none', zIndex: '50', overflow: 'hidden' });
+    document.body.append(element);
+    const cleanup = () => { element.remove(); cleanups.delete(cleanup); };
+    cleanups.add(cleanup);
+    return { element, cleanup };
+  }
+  function reveal(row: HTMLElement) {
+    animate(row, [{ opacity: 0, transform: 'translateY(6px)' }, { opacity: 1, transform: 'none' }], { duration: 200, easing: ease });
+  }
+  function move(positions: Map<HTMLElement, DOMRect>) {
+    positions.forEach((before, element) => {
+      if (!element.isConnected) return;
+      const delta = before.top - element.getBoundingClientRect().top;
+      if (Math.abs(delta) > 1) animate(element, [{ transform: `translateY(${delta}px)` }, { transform: 'none' }], { duration: 260, easing: ease });
+    });
+  }
+  function send(row: HTMLElement, source: DOMRect, keyboard: boolean) {
+    const bubble = row.querySelector<HTMLElement>(bubbleSelector), stream = viewport();
+    if (!bubble || !stream) return;
+    const target = bubble.getBoundingClientRect();
+    if (target.height > stream.clientHeight * .65) { reveal(row); return; }
+    const duration = keyboard ? 280 : 360;
+    const overlay = layer();
+    const clone = bubble.cloneNode(true) as HTMLElement;
+    // Copy inherited typography/tokens too: the flight lives outside the room's theme scope.
+    const style = getComputedStyle(bubble);
+    for (const property of style) clone.style.setProperty(property, style.getPropertyValue(property));
+    clone.removeAttribute('id'); clone.querySelectorAll('[id]').forEach(node => node.removeAttribute('id'));
+    Object.assign(clone.style, { position: 'absolute', left: `${target.left}px`, top: `${target.top}px`, width: `${target.width}px`, height: `${target.height}px`, maxWidth: 'none', margin: '0', transformOrigin: '0 0', pointerEvents: 'none' });
+    overlay.element.append(clone);
+    const opacity = bubble.style.opacity; bubble.style.opacity = '0';
+    const restore = () => { bubble.style.opacity = opacity; overlay.cleanup(); cleanups.delete(restore); };
+    cleanups.add(restore);
+    const dx = source.left - target.left - parseFloat(style.paddingLeft);
+    const dy = source.top - target.top - parseFloat(style.paddingTop);
+    const flight = animate(clone, [
+      { transform: `translate(${dx}px,${dy}px) scale(.98)`, opacity: .8, easing: ease },
+      { transform: 'none', opacity: 1 },
+    ], { duration });
+    if (flight) flight.finished.then(restore, restore); else restore();
+    for (const selector of [metaSelector, avatarSelector]) animate(row.querySelector(selector), [
+      { opacity: 0, transform: 'translateY(5px)' }, { opacity: 1, transform: 'none' },
+    ], { duration: duration * .45, delay: duration * .35, fill: 'backwards', easing: ease });
+  }
+  function reply(row: HTMLElement, source: WorkGeometry) {
+    const bubble = row.querySelector<HTMLElement>(bubbleSelector), stream = viewport();
+    if (!bubble || !stream) return;
+    const target = bubble.getBoundingClientRect(), list = stream.getBoundingClientRect();
+    // The flight starts in the pinned work rows and lands in the list, so it is clipped to both.
+    const pinned = work()?.getBoundingClientRect();
+    const left = Math.min(list.left, pinned?.left ?? list.left), top = Math.min(list.top, pinned?.top ?? list.top);
+    const bottom = Math.max(list.bottom, pinned?.bottom ?? list.bottom);
+    const bounds = { left, top, bottom, width: Math.max(list.right, pinned?.right ?? list.right) - left, height: bottom - top };
+    if (source.bounds.bottom < bounds.top || source.bounds.top > bounds.bottom || target.height > list.height * .8) { reveal(row); return; }
+    const duration = 440, style = getComputedStyle(bubble);
+    const overlay = layer();
+    Object.assign(overlay.element.style, { inset: 'auto', left: `${bounds.left}px`, top: `${bounds.top}px`, width: `${bounds.width}px`, height: `${bounds.height}px` });
+    const shell = document.createElement('div');
+    Object.assign(shell.style, { position: 'absolute', boxSizing: 'border-box', background: style.background, border: style.border, borderRadius: style.borderRadius, boxShadow: style.boxShadow });
+    const ghost = source.clone;
+    Object.assign(ghost.style, { position: 'absolute', left: `${source.bounds.left - bounds.left}px`, top: `${source.bounds.top - bounds.top}px`, width: `${source.bounds.width}px`, height: `${source.bounds.height}px`, margin: '0' });
+    ghost.querySelectorAll<HTMLElement>('.room-local-agent-work-pulse, strong').forEach(element => { element.style.visibility = 'hidden'; });
+    overlay.element.append(shell, ghost);
+    const seed = source.summary;
+    Object.assign(shell.style, { left: `${target.left - bounds.left}px`, top: `${target.top - bounds.top}px`, width: `${target.width}px`, height: `${target.height}px`, transformOrigin: '0 0' });
+    const start = `translate(${seed.left - target.left - 9}px,${seed.top - target.top - 5}px) scale(${(source.bounds.right - seed.left + 9) / target.width},${(seed.height + 10) / target.height})`;
+    const surface = animate(shell, [{ transform: start, opacity: .8, easing: ease }, { transform: 'none', opacity: 1, offset: .7 }, { transform: 'none', opacity: 0 }], { duration });
+    surface?.finished.then(overlay.cleanup, overlay.cleanup);
+    for (const [selector, before] of [[avatarSelector, source.pulse], [`${metaSelector.split(',')[0]} strong, .room-message-author-button, .message-sender strong`, source.name]] as const) {
+      const element = row.querySelector(selector);
+      if (!element) continue;
+      const after = element.getBoundingClientRect();
+      animate(element, [{ transform: `translate(${before.left - after.left}px,${before.top - after.top}px)` }, { transform: 'none' }], { duration: duration * .7, easing: ease });
+    }
+    animate(ghost.querySelector('.room-local-agent-work-copy > span'), [{ opacity: 1 }, { opacity: 0, transform: 'translateX(-8px)' }], { duration: duration * .28, easing: ease, fill: 'forwards' });
+    ghost.querySelectorAll<HTMLElement>('i').forEach((dot, index) => {
+      dot.style.animation = 'none';
+      animate(dot, [source.dots[index] || { opacity: 1 }, { opacity: 1, transform: `translateX(${-index * 6}px) scale(1.3)`, offset: .6 }, { opacity: 0, transform: `translateX(${-index * 6}px) scale(.8)` }], { duration: duration * .38, easing: ease, fill: 'forwards' });
+    });
+    animate(bubble, [{ opacity: 0 }, { opacity: 0, offset: .2 }, { opacity: 1 }], { duration });
+    animate(bubble.querySelector('.desktop-long-message, .long-message-content, .md-content') || bubble.firstElementChild,
+      [{ opacity: 0, transform: 'translateY(6px)' }, { opacity: 1, transform: 'none' }],
+      { duration: duration * .5, delay: duration * .2, fill: 'backwards', easing: ease });
+  }
+  return { cancel, move, send, reply, reveal };
+}

package/shared/ui/usePinnedMessageVisibility.ts

@@ -0,0 +1,20 @@
+import { readonly, ref } from "vue";
+
+const storageKey = "letagents:hide-pinned-messages";
+
+export function readPinnedMessagesHidden(): boolean {
+  try { return window.localStorage.getItem(storageKey) === "true"; }
+  catch { return false; }
+}
+
+const hidden = ref(readPinnedMessagesHidden());
+
+/** A personal display preference; pin membership remains in the room store. */
+export function usePinnedMessageVisibility() {
+  function togglePinnedMessages(): void {
+    hidden.value = !hidden.value;
+    try { window.localStorage.setItem(storageKey, String(hidden.value)); }
+    catch { /* Keep the current view usable when local storage is unavailable. */ }
+  }
+  return { pinnedMessagesHidden: readonly(hidden), togglePinnedMessages };
+}

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;