fix(workbench,ui): follow the host default after a submit, freeze only parked reads, and continue from the last completed turn

Author: Zerlight

packages/client/core/AGENTS.md

@@ -44,9 +44,10 @@ Rules the projection store enforces — keep them when touching it:
 - **A parked view is frozen at its read.** Browsing an earlier version reads toward that
   `leafTurnId` (`ConversationSeedSource.leafTurnId`) with `followLive: false`: the live stream
   belongs to the active lineage's run and must not fold into another version, and a graph change
-  is the owner's business (the "continued elsewhere" chip), not a re-read. Only the view of a
-  leaf that is itself in flight (the client's own edit or continue, before the daemon moves the
-  default) follows live.
+  is the owner's business (the "continued elsewhere" chip), not a re-read. The caller decides
+  `followLive` from the read the store holds — a leaf on, behind, or ahead of the host default
+  follows; another version is frozen — never from view state, which runs ahead of the read by a
+  round trip on every switch.
 - **Edits and continues are explicit-parent submits** (`submitTurn(…, target)`): the daemon
   validates the parent and `expectedGraphRevision` and answers typed `conflict`/`busy`; the
   client never calls `history.branch` on a host that serves the graph and can fork.

packages/client/workbench/AGENTS.md

@@ -40,9 +40,14 @@ app-specific entries (`apps/desktop`, `apps/webview`) and pure presentation (`pa
   remembered descent per parent) + the pure helpers in `lineage.ts` + `use-conversation-graph.ts`
   (the turn tree, revalidated on `conversation.graph.changed`). The seed hook keeps a stable SWR
   key and reads the parked leaf at fetch time — a version switch revalidates in place instead of
-  flashing an empty timeline — and freezes the store (`followLive: false`) while parked; a parked
-  view's sends, edits, and `/`/`$` inputs are explicit-parent `turn.submit`s, and the store
-  releases the view once the host default runs through the parked leaf.
+  flashing an empty timeline — and freezes the store (`followLive: false`) while the read it holds
+  was made toward a parked version the active lineage does not run through (`onActiveLineage`); a
+  read of the host default keeps following, and the next graph snapshot re-reads it once the tree
+  has moved past it (an edit from any device). A parked view's sends and `/`/`$` inputs are
+  explicit-parent `turn.submit`s under the version's last completed turn, an edit is a sibling
+  under the edited turn's parent, and a successful submit follows the host default again (the
+  daemon moved it before replying); the store also releases a parked view once the default runs
+  through its leaf.
 - `terminal/` — the daemon-backed interactive terminal: the panel container, the key-scoped
   session registry that retains/detaches (rather than kills) a PTY across remounts, viewer
   attachment containers, and the transport-backed `TerminalSession`. Only the current controller

packages/client/workbench/src/surface/__tests__/lineage-store.test.ts

@@ -27,23 +27,23 @@ beforeEach(() => {
 });
 
 describe('lineage store', () => {
-  it('parks, dismisses the elsewhere chip for one revision, and follows again', () => {
+  it('parks against the host default, dismisses the elsewhere chip per default, and follows again', () => {
     const store = useLineageStore.getState();
-    store.park(sessionId, 'B1' as TurnId, 3);
+    store.park(sessionId, 'B1' as TurnId, 'B2' as TurnId);
     expect(useLineageStore.getState().parkedBySession[sessionId]).toEqual({
       leafTurnId: 'B1',
-      atRevision: 3,
-      dismissedRevision: null,
+      sinceLeafTurnId: 'B2',
+      dismissedLeafTurnId: undefined,
     });
-    store.dismissElsewhere(sessionId, 4);
-    expect(useLineageStore.getState().parkedBySession[sessionId]?.dismissedRevision).toBe(4);
+    store.dismissElsewhere(sessionId, 'C2' as TurnId);
+    expect(useLineageStore.getState().parkedBySession[sessionId]?.dismissedLeafTurnId).toBe('C2');
     store.follow(sessionId);
     expect(useLineageStore.getState().parkedBySession[sessionId]).toBeUndefined();
   });
 
   it('releases a parked view once the host default runs through its leaf', () => {
     const store = useLineageStore.getState();
-    store.park(sessionId, 'B1' as TurnId, 3);
+    store.park(sessionId, 'B1' as TurnId, 'B2' as TurnId);
     // The active lineage moved to a sibling: still parked.
     store.noteGraph(snapshot('B2', [turn('A', null), turn('B1', 'A'), turn('B2', 'A')]));
     expect(useLineageStore.getState().parkedBySession[sessionId]?.leafTurnId).toBe('B1');

packages/client/workbench/src/surface/__tests__/lineage.test.ts

@@ -1,13 +1,17 @@
+import type { ConversationGraphSnapshot } from '@linkcode/client-core';
 import type { ConversationGraphTurn, SessionId, TurnId } from '@linkcode/schema';
 import { userRowMessageId } from '@linkcode/schema';
 import { describe, expect, it } from 'vitest';
 import {
+  continuationParent,
   descendToLeaf,
   lineageIncludes,
   lineageParentKey,
   lineagePath,
   lineageVersions,
+  onActiveLineage,
   siblingsOf,
+  timelineLeftActiveLineage,
   turnsById,
 } from '../lineage';
 
@@ -88,4 +92,49 @@ describe('lineage helpers', () => {
     // A remembered child that no longer exists falls back to the newest.
     expect(descendToLeaf(TURNS, 'B2' as TurnId, { B2: 'gone' as TurnId })).toBe('C3');
   });
+
+  it('continues from a version’s last completed turn, never from a failed tip', () => {
+    const byId = turnsById(TURNS);
+    expect(continuationParent(byId, 'C3' as TurnId)).toBe('B2');
+    expect(continuationParent(byId, 'C1' as TurnId)).toBe('C1');
+    const failedRoot = turnsById([turn('F', null, 1, 1, 'failed')]);
+    expect(continuationParent(failedRoot, 'F' as TurnId)).toBeNull();
+  });
+
+  it('places a read on the active lineage unless it is of another version', () => {
+    const graph = (activeLeaf: string): ConversationGraphSnapshot => ({
+      sessionId,
+      graphRevision: 1,
+      activeLeafTurnId: activeLeaf as TurnId,
+      turns: TURNS,
+    });
+    expect(onActiveLineage('C2' as TurnId, graph('C2'))).toBe(true);
+    // Behind the default on its own lineage: a continuation folds onto it.
+    expect(onActiveLineage('B2' as TurnId, graph('C2'))).toBe(true);
+    // Another version.
+    expect(onActiveLineage('C1' as TurnId, graph('C2'))).toBe(false);
+    // Ahead of a stale snapshot, or not placed by it yet.
+    expect(onActiveLineage('C2' as TurnId, graph('B2'))).toBe(true);
+    expect(onActiveLineage('new' as TurnId, graph('C2'))).toBe(true);
+    // Nothing to judge against without a leaf or a tree.
+    expect(onActiveLineage(undefined, graph('C2'))).toBe(true);
+    expect(onActiveLineage('C1' as TurnId, undefined)).toBe(true);
+  });
+
+  it('notices a timeline showing a turn off the active lineage', () => {
+    const graph = (activeLeaf: string): ConversationGraphSnapshot => ({
+      sessionId,
+      graphRevision: 1,
+      activeLeafTurnId: activeLeaf as TurnId,
+      turns: TURNS,
+    });
+    const rows = (...ids: string[]) => ids.map((id) => userRowMessageId(id as TurnId));
+    // Following B1's lineage when the default moved to B2's: B1 and C1 are off it.
+    expect(timelineLeftActiveLineage(rows('A', 'B1', 'C1'), graph('C2'))).toBe(true);
+    // The edit's own echo folded onto the old lineage, then the tree caught up.
+    expect(timelineLeftActiveLineage(rows('A', 'B1', 'B2'), graph('B2'))).toBe(true);
+    expect(timelineLeftActiveLineage(rows('A', 'B2', 'C2'), graph('C2'))).toBe(false);
+    // A row the tree does not know yet is a fresher echo, not a foreign version.
+    expect(timelineLeftActiveLineage(rows('A', 'B2', 'C2', 'new'), graph('C2'))).toBe(false);
+  });
 });

packages/client/workbench/src/surface/lineage-store.ts

@@ -7,22 +7,23 @@ import { lineageIncludes, turnsById } from './lineage';
 export interface ParkedLineage {
   /** The leaf the timeline reads toward. */
   leafTurnId: TurnId;
-  /** The graph revision when the viewer parked; a later one means the conversation moved on
-   * elsewhere while this viewer stayed. */
-  atRevision: number;
-  /** The revision whose "continued elsewhere" chip the viewer dismissed. */
-  dismissedRevision: number | null;
+  /** The host default when the viewer parked; a different one means the conversation moved on
+   * elsewhere while this viewer stayed — a failed attempt or a settle, which only bump the
+   * revision, is nobody's news. */
+  sinceLeafTurnId: TurnId | undefined;
+  /** The host default whose "continued elsewhere" chip the viewer dismissed. */
+  dismissedLeafTurnId: TurnId | undefined;
 }
 
 interface LineageState {
   parkedBySession: Record<string, ParkedLineage>;
   /** Remembered descent per parent (`lineageParentKey`): `‹ ›` returns to the version last viewed. */
   preferredChildBySession: Record<string, Record<string, TurnId>>;
-  park: (sessionId: SessionId, leafTurnId: TurnId, atRevision: number) => void;
+  park: (sessionId: SessionId, leafTurnId: TurnId, activeLeafTurnId: TurnId | undefined) => void;
   /** Back to the host default: the active lineage, following it live. */
   follow: (sessionId: SessionId) => void;
   rememberChild: (sessionId: SessionId, parentKey: string, childTurnId: TurnId) => void;
-  dismissElsewhere: (sessionId: SessionId, revision: number) => void;
+  dismissElsewhere: (sessionId: SessionId, activeLeafTurnId: TurnId | undefined) => void;
   /** A fresh graph snapshot: once the host default runs through the parked leaf — the viewer's
    * own edit or continue landed, or a plain send extended the version it was on — the view is at
    * that lineage's tip again and follows. */
@@ -43,11 +44,15 @@ function without<T>(record: Record<string, T>, key: string): Record<string, T> {
 export const useLineageStore = create<LineageState>()((set) => ({
   parkedBySession: {},
   preferredChildBySession: {},
-  park: (sessionId, leafTurnId, atRevision) =>
+  park: (sessionId, leafTurnId, activeLeafTurnId) =>
     set((state) => ({
       parkedBySession: {
         ...state.parkedBySession,
-        [sessionId]: { leafTurnId, atRevision, dismissedRevision: null },
+        [sessionId]: {
+          leafTurnId,
+          sinceLeafTurnId: activeLeafTurnId,
+          dismissedLeafTurnId: undefined,
+        },
       },
     })),
   follow: (sessionId) =>
@@ -63,14 +68,14 @@ export const useLineageStore = create<LineageState>()((set) => ({
         [sessionId]: { ...state.preferredChildBySession[sessionId], [parentKey]: childTurnId },
       },
     })),
-  dismissElsewhere: (sessionId, revision) =>
+  dismissElsewhere: (sessionId, activeLeafTurnId) =>
     set((state) => {
       const parked = state.parkedBySession[sessionId];
       if (parked === undefined) return state;
       return {
         parkedBySession: {
           ...state.parkedBySession,
-          [sessionId]: { ...parked, dismissedRevision: revision },
+          [sessionId]: { ...parked, dismissedLeafTurnId: activeLeafTurnId },
         },
       };
     }),

packages/client/workbench/src/surface/lineage.ts

@@ -1,3 +1,4 @@
+import type { ConversationGraphSnapshot } from '@linkcode/client-core';
 import type { ConversationGraphTurn, TurnId } from '@linkcode/schema';
 import { userRowMessageId } from '@linkcode/schema';
 import type { TurnVersion } from '@linkcode/ui';
@@ -40,6 +41,57 @@ export function lineageIncludes(
   return lineagePath(byId, leafTurnId).some((turn) => turn.turnId === turnId);
 }
 
+/** Where a send from a view of `leafTurnId` lands: the lineage's last completed turn — a failed or
+ * cancelled tip ran nothing to continue from, so the send is a sibling of it — else a new root. */
+export function continuationParent(
+  byId: ReadonlyMap<TurnId, ConversationGraphTurn>,
+  leafTurnId: TurnId,
+): TurnId | null {
+  const path = lineagePath(byId, leafTurnId);
+  for (let i = path.length - 1; i >= 0; i--) {
+    if (path[i].state === 'completed') return path[i].turnId;
+  }
+  return null;
+}
+
+/** Whether a read toward `leafTurnId` is on the active lineage as far as `graph` knows: on or
+ * behind the host default, ahead of a stale snapshot, or not placed by it yet. Only a read of
+ * another version is not — the live stream, which belongs to the active lineage's run, must not
+ * fold into it. */
+export function onActiveLineage(
+  leafTurnId: TurnId | undefined,
+  graph: ConversationGraphSnapshot | undefined,
+): boolean {
+  if (leafTurnId === undefined || graph?.activeLeafTurnId === undefined) return true;
+  const byId = turnsById(graph.turns);
+  if (!byId.has(leafTurnId)) return true;
+  return (
+    lineageIncludes(byId, graph.activeLeafTurnId, leafTurnId) ||
+    lineageIncludes(byId, leafTurnId, graph.activeLeafTurnId)
+  );
+}
+
+/** Whether a timeline shows a user row of a turn the active lineage does not run through: the host
+ * default moved to another version while this view followed it (an edit from any device), so the
+ * view must read toward the default. Rows the tree does not know yet — an echo fresher than the
+ * snapshot — do not count. */
+export function timelineLeftActiveLineage(
+  userRowIds: readonly string[],
+  graph: ConversationGraphSnapshot,
+): boolean {
+  const known = new Set<string>(graph.turns.map((turn) => userRowMessageId(turn.turnId)));
+  const onPath = new Set<string>(
+    lineagePath(turnsById(graph.turns), graph.activeLeafTurnId).map((turn) =>
+      userRowMessageId(turn.turnId),
+    ),
+  );
+  for (let i = 0, len = userRowIds.length; i < len; i++) {
+    const id = userRowIds[i];
+    if (known.has(id) && !onPath.has(id)) return true;
+  }
+  return false;
+}
+
 /** A turn's siblings in ordinal order, itself included. */
 export function siblingsOf(
   turns: readonly ConversationGraphTurn[],

packages/client/workbench/src/surface/use-conversation-graph.ts

@@ -6,7 +6,6 @@ import { noop } from 'foxact/noop';
 import { useEffect } from 'react';
 import { useWorkbenchSdkClient } from '../runtime/provider';
 import { useData } from '../runtime/tayori';
-import { useLineageStore } from './lineage-store';
 
 async function fetchConversationGraph(
   options: Options<{ sessionId: SessionId }>,
@@ -16,9 +15,10 @@ async function fetchConversationGraph(
 
 /**
  * The session's turn tree — ids, parents, ordinals, states — revalidated on every
- * `conversation.graph.changed`. Undefined before the first read and on hosts without a graph.
- * `onSnapshot` runs per fresh snapshot for event-time bookkeeping (a parked view that the host
- * default caught up with), never during render.
+ * `conversation.graph.changed` (a settle re-announces at the same revision, so the badges follow).
+ * Undefined before the first read and on hosts without a graph. `onSnapshot` runs per fresh
+ * snapshot for event-time bookkeeping (a parked view that the host default caught up with), never
+ * during render.
  */
 export function useConversationGraph(
   sessionId: SessionId | null,
@@ -31,19 +31,9 @@ export function useConversationGraph(
   });
   useEffect(() => {
     if (!enabled) return;
-    const revalidate = (): void => {
+    return client.subscribeGraphChanges(sessionId, () => {
       void mutate().catch(noop);
-    };
-    const unsubscribeChanges = client.subscribeGraphChanges(sessionId, revalidate);
-    // Parking at a just-submitted turn must see it in the tree before any `graph.changed` lands:
-    // its state decides whether the view follows the live stream.
-    const unsubscribeParked = useLineageStore.subscribe((state, previous) => {
-      if (state.parkedBySession[sessionId] !== previous.parkedBySession[sessionId]) revalidate();
     });
-    return () => {
-      unsubscribeChanges();
-      unsubscribeParked();
-    };
   }, [client, enabled, sessionId, mutate]);
   return data;
 }