@dxos/react-ui-trace 0.11.1 → 0.13.0

package/src/session-timeline/session-timeline.test.ts

@@ -10,12 +10,14 @@ import { describe, test } from 'vitest';
 import * as Process from '@dxos/compute/Process';
 import { TestTraceService } from '@dxos/compute/testing';
 import * as Trace from '@dxos/compute/Trace';
-import { Annotation, Feed, Obj, Ref } from '@dxos/echo';
+import { Annotation, Database, Feed, Obj, Ref } from '@dxos/echo';
+import { TestDatabaseLayer } from '@dxos/echo-client/testing';
 import { EID, EntityId, URI } from '@dxos/keys';
-import { Task } from '@dxos/types';
+import { Milestone, Task } from '@dxos/types';
+import { getHashHue } from '@dxos/ui-theme';
 
 import subAgentFixture from '../execution-graph/testing/sub-agent-delegation.json';
-import { buildSessionTimeline } from './session-timeline.ts';
+import { buildSessionTimeline, readTaskStatusChanges } from './session-timeline.ts';
 import { type Session } from './types.ts';
 
 /** The plain-JSON shape the fixture was captured in, before being replayed as real trace messages. */
@@ -257,7 +259,11 @@ describe('buildSessionTimeline', () => {
       );
 
       const messages = yield* TestTraceService.messages;
-      const timeline = buildSessionTimeline({ traceMessages: messages, sessions: [chat.session], tasks: [first, second] });
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [first, second],
+      });
       const firstLane = timeline.lanes.find((lane) => lane.id === `task:${first.id}`);
       const secondLane = timeline.lanes.find((lane) => lane.id === `task:${second.id}`);
       expect(firstLane).toMatchObject({ start: 1, end: 3 });
@@ -295,7 +301,11 @@ describe('buildSessionTimeline', () => {
       );
 
       const messages = yield* TestTraceService.messages;
-      const timeline = buildSessionTimeline({ traceMessages: messages, sessions: [chat.session], tasks: [mine, other, later] });
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [mine, other, later],
+      });
       const laneId = `task:${mine.id}`;
       expect(timeline.lanes.find((lane) => lane.id === laneId)).toMatchObject({ start: 2, end: 6 });
       const lanesByLabel = new Map(timeline.markers.map((marker) => [marker.label, marker.laneId]));
@@ -305,7 +315,7 @@ describe('buildSessionTimeline', () => {
   );
 
   it.effect(
-    "a task started over an open one closes it at the boundary, which is the newcomer's",
+    'a task started over an open one runs alongside it, and work while both are open stays with the session',
     Effect.fnUntraced(function* ({ expect }) {
       const first = Task.make({ title: 'First', status: 'started' });
       const second = Task.make({ title: 'Second', status: 'started' });
@@ -316,25 +326,35 @@ describe('buildSessionTimeline', () => {
           yield* Trace.write(Trace.AgentRequestBegin, {}); // 1.
           yield* Trace.write(Trace.TaskStatusChanged, { taskId: first.id, title: 'First', status: 'started' }); // 2.
           yield* toolCall('Read file'); // 3.
-          // No close for the first: starting the second is what ends it.
+          // No close for the first: the agent holds both.
           yield* Trace.write(Trace.TaskStatusChanged, { taskId: second.id, title: 'Second', status: 'started' }); // 4.
           yield* toolCall('Write file'); // 5.
         }),
       );
 
       const messages = yield* TestTraceService.messages;
-      const timeline = buildSessionTimeline({ traceMessages: messages, sessions: [chat.session], tasks: [first, second] });
-      expect(timeline.lanes.find((lane) => lane.id === `task:${first.id}`)).toMatchObject({ start: 2, end: 4 });
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [first, second],
+      });
+      expect(timeline.lanes.find((lane) => lane.id === `task:${first.id}`)).toMatchObject({
+        start: 2,
+        end: undefined,
+      });
       expect(timeline.lanes.find((lane) => lane.id === `task:${second.id}`)).toMatchObject({
         start: 4,
         end: undefined,
       });
-      // The two segments share the boundary at 4; the second task's own start node sits on its lane.
       const taskMarkers = timeline.markers.filter((marker) => marker.kind === 'task');
       expect(taskMarkers.map(({ laneId, timestamp }) => ({ laneId, timestamp }))).toEqual([
         { laneId: `task:${first.id}`, timestamp: 2 },
         { laneId: `task:${second.id}`, timestamp: 4 },
       ]);
+      // One task open: its work. Two open: the session's, since it cannot be told which it was for.
+      const lanesByLabel = new Map(timeline.markers.map((marker) => [marker.label, marker.laneId]));
+      expect(lanesByLabel.get('Read file')).toBe(`task:${first.id}`);
+      expect(lanesByLabel.get('Write file')).toBe(`session:${chat.session.id}`);
     }, Effect.provide(TestTraceService.layer)),
   );
 
@@ -361,6 +381,109 @@ describe('buildSessionTimeline', () => {
     }, Effect.provide(TestTraceService.layer)),
   );
 
+  it.effect(
+    'a folded lane begins no later than its task, and a traced move takes the trace instant over the history second',
+    Effect.fnUntraced(function* ({ expect }) {
+      const task = Task.make({ title: 'Only', status: 'started' });
+      const chat = makeChat('Only', [task]);
+      yield* TestTraceService.withMeta(
+        { pid: 'agent', conversation: chat.feed },
+        Effect.gen(function* () {
+          yield* Trace.write(Trace.AgentRequestBegin, {}); // 1.
+          yield* Trace.write(Trace.TaskStatusChanged, { taskId: task.id, title: 'Only', status: 'started' }); // 2.
+        }),
+      );
+
+      const messages = yield* TestTraceService.messages;
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [task],
+        // Delegation started the task before the first request, recorded at whole-second precision.
+        taskStatusChanges: new Map([[task.id, [{ timestamp: 0, status: 'started', previousStatus: 'todo' }]]]),
+      });
+      expect(timeline.lanes).toHaveLength(1);
+      // The history's rounded-down second is replaced by the traced instant, so the lane begins at the
+      // session's first request (1) rather than before any node.
+      expect(timeline.lanes[0]).toMatchObject({ kind: 'session', taskId: task.id, start: 1 });
+      const started = timeline.markers.find((marker) => marker.label === 'Task started');
+      expect(started?.timestamp).toBe(2);
+    }, Effect.provide(TestTraceService.layer)),
+  );
+
+  it.effect(
+    'a task lane starts at its first node, not at the rounded-down second its history records',
+    Effect.fnUntraced(function* ({ expect }) {
+      const first = Task.make({ title: 'First', status: 'started' });
+      const second = Task.make({ title: 'Second', status: 'todo' });
+      const chat = makeChat('Precise', [first, second]);
+      yield* TestTraceService.withMeta(
+        { pid: 'agent', conversation: chat.feed },
+        Effect.gen(function* () {
+          yield* Trace.write(Trace.AgentRequestBegin, {}); // 1.
+          yield* Trace.write(Trace.TaskStatusChanged, { taskId: first.id, title: 'First', status: 'started' }); // 2.
+        }),
+      );
+
+      const messages = yield* TestTraceService.messages;
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [first, second],
+        taskStatusChanges: new Map([[first.id, [{ timestamp: 0, status: 'started', previousStatus: 'todo' }]]]),
+      });
+      const lane = timeline.lanes.find((lane) => lane.id === `task:${first.id}`);
+      const node = timeline.markers.find((marker) => marker.laneId === lane?.id);
+      expect(lane?.start).toBe(2);
+      expect(node?.timestamp).toBe(lane?.start);
+    }, Effect.provide(TestTraceService.layer)),
+  );
+
+  it.effect(
+    "a parent task's lane carries each sub-task's start and finish",
+    Effect.fnUntraced(function* ({ expect }) {
+      const parent = Task.make({ title: 'Parent', status: 'started' });
+      const child = Task.make({ [Obj.Parent]: parent, title: 'Child', status: 'done' });
+      const chat = makeChat('Tree', [parent, child]);
+      yield* TestTraceService.withMeta(
+        { pid: 'agent', conversation: chat.feed },
+        Effect.gen(function* () {
+          yield* Trace.write(Trace.AgentRequestBegin, {}); // 1.
+          yield* Trace.write(Trace.TaskStatusChanged, { taskId: child.id, title: 'Child', status: 'started' }); // 2.
+          yield* Trace.write(Trace.TaskStatusChanged, {
+            taskId: child.id,
+            title: 'Child',
+            status: 'done',
+            previousStatus: 'started',
+          }); // 3.
+        }),
+      );
+
+      const messages = yield* TestTraceService.messages;
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [parent, child],
+        taskStatusChanges: new Map([
+          [
+            child.id,
+            [
+              { timestamp: 0, status: 'started', previousStatus: 'todo' },
+              { timestamp: 0, status: 'done', previousStatus: 'started' },
+            ],
+          ],
+        ]),
+      });
+      const onParent = timeline.markers
+        .filter((marker) => marker.laneId === `task:${parent.id}`)
+        .map(({ label, timestamp }) => ({ label, timestamp }));
+      expect(onParent).toEqual([
+        { label: 'Child: started', timestamp: 2 },
+        { label: 'Child: done', timestamp: 3 },
+      ]);
+    }, Effect.provide(TestTraceService.layer)),
+  );
+
   it.effect(
     'a run whose process ended without a request end closes at its last event, and the axis stops following now',
     Effect.fnUntraced(function* ({ expect }) {
@@ -419,7 +542,11 @@ describe('buildSessionTimeline', () => {
       );
 
       const messages = yield* TestTraceService.messages;
-      const timeline = buildSessionTimeline({ traceMessages: messages, sessions: [chat.session], tasks: [task, later] });
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [task, later],
+      });
       expect(timeline.lanes.find((lane) => lane.id === `task:${task.id}`)).toMatchObject({ start: 2, end: 4 });
       const lanesByLabel = new Map(timeline.markers.map((marker) => [marker.label, marker.laneId]));
       expect(lanesByLabel.get('Read file')).toBe(`task:${task.id}`);
@@ -464,7 +591,11 @@ describe('buildSessionTimeline', () => {
       );
 
       const messages = yield* TestTraceService.messages;
-      const timeline = buildSessionTimeline({ traceMessages: messages, sessions: [chat.session], tasks: [dismissed, worked] });
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [dismissed, worked],
+      });
       expect(timeline.lanes.find((lane) => lane.id === `task:${worked.id}`)).toMatchObject({ start: 3, end: 4 });
       expect(timeline.lanes.find((lane) => lane.id === `task:${dismissed.id}`)).toMatchObject({
         start: 5,
@@ -476,7 +607,7 @@ describe('buildSessionTimeline', () => {
   );
 
   it.effect(
-    'a close arriving after the next task started leaves that task the stretch',
+    'a close arriving after the next task started ends the first where it was closed',
     Effect.fnUntraced(function* ({ expect }) {
       const first = Task.make({ title: 'First', status: 'done' });
       const second = Task.make({ title: 'Second', status: 'started' });
@@ -488,8 +619,8 @@ describe('buildSessionTimeline', () => {
           yield* Trace.write(Trace.TaskStatusChanged, { taskId: first.id, title: 'First', status: 'started' }); // 2.
           yield* Trace.write(Trace.TaskStatusChanged, { taskId: second.id, title: 'Second', status: 'started' }); // 3.
           yield* toolCall('Write file'); // 4.
-          // The first task's close lands after the second one is under way; the stretch is the
-          // second task's, so nothing may be minted over it.
+          // The first task's close lands after the second one is under way: both were in progress
+          // until then.
           yield* Trace.write(Trace.TaskStatusChanged, {
             taskId: first.id,
             title: 'First',
@@ -501,14 +632,18 @@ describe('buildSessionTimeline', () => {
       );
 
       const messages = yield* TestTraceService.messages;
-      const timeline = buildSessionTimeline({ traceMessages: messages, sessions: [chat.session], tasks: [first, second] });
-      expect(timeline.lanes.find((lane) => lane.id === `task:${first.id}`)).toMatchObject({ start: 2, end: 3 });
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [first, second],
+      });
+      expect(timeline.lanes.find((lane) => lane.id === `task:${first.id}`)).toMatchObject({ start: 2, end: 5 });
       expect(timeline.lanes.find((lane) => lane.id === `task:${second.id}`)).toMatchObject({
         start: 3,
         end: undefined,
       });
       const lanesByLabel = new Map(timeline.markers.map((marker) => [marker.label, marker.laneId]));
-      expect(lanesByLabel.get('Write file')).toBe(`task:${second.id}`);
+      expect(lanesByLabel.get('Write file')).toBe(`session:${chat.session.id}`);
       expect(lanesByLabel.get('Read file')).toBe(`task:${second.id}`);
     }, Effect.provide(TestTraceService.layer)),
   );
@@ -603,9 +738,419 @@ describe('buildSessionTimeline', () => {
       expect(subSession?.delegatedFrom).toEqual({ laneId: session?.id, markerId: spawn?.id });
     }, Effect.provide(TestTraceService.layer)),
   );
+  it.effect(
+    'pairs a sub-agent with the node its result returned into',
+    Effect.fnUntraced(function* ({ expect }) {
+      const task = Task.make({ title: 'Compute', status: 'done' });
+      const chat = makeChat('Return', [task]);
+      yield* TestTraceService.withMeta(
+        { pid: 'agent', conversation: chat.feed },
+        Effect.gen(function* () {
+          yield* Trace.write(Trace.AgentRequestBegin, {});
+          yield* Trace.write(Trace.DelegationSpawned, { taskId: task.id, pid: 'sub' });
+          yield* TestTraceService.withMeta(
+            { pid: 'sub', parentPid: 'agent' },
+            Effect.gen(function* () {
+              yield* Trace.write(Trace.OperationStart, { key: 'run', name: 'Run Instructions' });
+              yield* Trace.write(Trace.OperationEnd, { key: 'run', outcome: 'success' });
+            }),
+          );
+          yield* Trace.write(Trace.DelegationCompleted, {
+            taskId: task.id,
+            pid: 'sub',
+            status: 'success',
+            result: '3628800',
+          });
+          yield* Trace.write(Trace.AgentRequestEnd, { status: 'success' });
+        }),
+      );
+
+      const messages = yield* TestTraceService.messages;
+      const timeline = buildSessionTimeline({ traceMessages: messages, sessions: [chat.session], tasks: [task] });
+      const session = timeline.lanes.find((lane) => lane.id === `session:${chat.id}`);
+      const subSession = timeline.lanes.find((lane) => lane.id === 'session:sub');
+
+      // Both edges land on the supervisor's lane, on different nodes: handing the work over and
+      // hearing back are separate moments, and the chart draws them as separate connectors.
+      const [spawn, returned] = timeline.markers.filter((marker) => marker.kind === 'delegation');
+      expect(returned?.laneId).toBe(session?.id);
+      expect(returned?.label).toBe('Returned: 3628800');
+      expect(subSession?.delegatedFrom).toEqual({ laneId: session?.id, markerId: spawn?.id });
+      expect(subSession?.returnedTo).toEqual({ laneId: session?.id, markerId: returned?.id });
+    }, Effect.provide(TestTraceService.layer)),
+  );
+
+  it.effect(
+    'leaves a sub-agent that never reported back with no return edge',
+    Effect.fnUntraced(function* ({ expect }) {
+      // Deliberately not inferred from the supervisor's next node: a child can end without ever
+      // answering, and guessing would draw a causal edge that does not exist.
+      const task = Task.make({ title: 'Compute', status: 'done' });
+      const chat = makeChat('No return', [task]);
+      yield* TestTraceService.withMeta(
+        { pid: 'agent', conversation: chat.feed },
+        Effect.gen(function* () {
+          yield* Trace.write(Trace.AgentRequestBegin, {});
+          yield* Trace.write(Trace.DelegationSpawned, { taskId: task.id, pid: 'sub' });
+          yield* TestTraceService.withMeta(
+            { pid: 'sub', parentPid: 'agent' },
+            Effect.gen(function* () {
+              yield* Trace.write(Trace.OperationStart, { key: 'run', name: 'Run Instructions' });
+              yield* Trace.write(Trace.OperationEnd, { key: 'run', outcome: 'success' });
+            }),
+          );
+          yield* Trace.write(Trace.AgentRequestEnd, { status: 'success' });
+        }),
+      );
+
+      const messages = yield* TestTraceService.messages;
+      const timeline = buildSessionTimeline({ traceMessages: messages, sessions: [chat.session], tasks: [task] });
+      const subSession = timeline.lanes.find((lane) => lane.id === 'session:sub');
+      expect(subSession?.delegatedFrom).toBeDefined();
+      expect(subSession?.returnedTo).toBeUndefined();
+    }, Effect.provide(TestTraceService.layer)),
+  );
+
+  test('bounds task lanes and threads their nodes from the edit history alone', ({ expect }) => {
+    const first = Task.make({ title: 'First', status: 'done' });
+    const second = Task.make({ title: 'Second', status: 'started' });
+    Task.ask(first, { text: 'Which schema?', date: at(1_500) });
+    const chat = makeChat('History', [first, second]);
+
+    const timeline = buildSessionTimeline({
+      traceMessages: [],
+      sessions: [chat.session],
+      tasks: [first, second],
+      taskStatusChanges: new Map([
+        [
+          first.id,
+          [
+            { timestamp: 1_000, status: 'started', previousStatus: 'todo' },
+            { timestamp: 2_000, status: 'done', previousStatus: 'started' },
+          ],
+        ],
+        [second.id, [{ timestamp: 3_000, status: 'started', previousStatus: 'todo' }]],
+      ]),
+    });
+
+    const firstLane = timeline.lanes.find((lane) => lane.id === `task:${first.id}`);
+    const secondLane = timeline.lanes.find((lane) => lane.id === `task:${second.id}`);
+    expect(firstLane).toMatchObject({ status: 'done', start: 1_000, end: 2_000 });
+    expect(secondLane).toMatchObject({ status: 'running', start: 3_000, end: undefined });
+    expect(
+      timeline.markers
+        .filter((marker) => marker.laneId === firstLane?.id)
+        .toSorted((a, b) => a.timestamp - b.timestamp)
+        .map(({ label, timestamp, level }) => ({ label, timestamp, level })),
+    ).toEqual([
+      { label: 'Task started', timestamp: 1_000, level: undefined },
+      { label: 'Which schema?', timestamp: 1_500, level: 'warn' },
+      { label: 'Task done', timestamp: 2_000, level: undefined },
+    ]);
+    expect(timeline.range).toEqual({ start: 1_000, end: 3_000 });
+  });
+
+  test('draws no node for the wait before a task was first picked up', ({ expect }) => {
+    const task = Task.make({ title: 'Queued', status: 'todo' });
+    const chat = makeChat('Queue', [task]);
+    const timeline = buildSessionTimeline({
+      traceMessages: [],
+      sessions: [chat.session],
+      tasks: [task],
+      taskStatusChanges: new Map([
+        [
+          task.id,
+          [
+            { timestamp: 1_000, status: 'todo' },
+            { timestamp: 2_000, status: 'started', previousStatus: 'todo' },
+            // Put back: a move of its own, unlike the wait before the first pick-up.
+            { timestamp: 3_000, status: 'todo', previousStatus: 'started' },
+          ],
+        ],
+      ]),
+    });
+
+    expect(
+      timeline.markers.filter((marker) => marker.kind === 'task').map(({ label, timestamp }) => ({ label, timestamp })),
+    ).toEqual([
+      { label: 'Task started', timestamp: 2_000 },
+      { label: 'Task todo', timestamp: 3_000 },
+    ]);
+    expect(timeline.range.start).toBe(2_000);
+  });
+
+  test('nests a sub-task under its parent task when both are on the checklist', ({ expect }) => {
+    const parent = Task.make({ title: 'Parent', status: 'started' });
+    const child = Task.make({ [Obj.Parent]: parent, title: 'Child', status: 'todo' });
+    const chat = makeChat('Tree', [parent, child]);
+    const timeline = buildSessionTimeline({ traceMessages: [], sessions: [chat.session], tasks: [parent, child] });
+
+    expect(timeline.lanes.find((lane) => lane.id === `task:${parent.id}`)?.parentId).toBe(`session:${chat.session.id}`);
+    expect(timeline.lanes.find((lane) => lane.id === `task:${child.id}`)?.parentId).toBe(`task:${parent.id}`);
+  });
+
+  test("a parent task's lane begins no later than its sub-tasks', even when they are not on one checklist", ({
+    expect,
+  }) => {
+    const parent = Task.make({ title: 'Parent', status: 'started' });
+    const child = Task.make({ [Obj.Parent]: parent, title: 'Child', status: 'done' });
+    const grandchild = Task.make({ [Obj.Parent]: child, title: 'Grandchild', status: 'done' });
+    // The parent is not on the checklist, so it is drawn from its edit history alone, unnested.
+    const chat = makeChat('Run', [child, grandchild]);
+    const timeline = buildSessionTimeline({
+      traceMessages: [],
+      sessions: [chat.session],
+      tasks: [parent, child, grandchild],
+      taskStatusChanges: new Map([
+        [parent.id, [{ timestamp: 3_000, status: 'started', previousStatus: 'todo' }]],
+        [
+          child.id,
+          [
+            { timestamp: 2_000, status: 'started', previousStatus: 'todo' },
+            { timestamp: 4_000, status: 'done', previousStatus: 'started' },
+          ],
+        ],
+        [
+          grandchild.id,
+          [
+            { timestamp: 1_000, status: 'started', previousStatus: 'todo' },
+            { timestamp: 2_500, status: 'done', previousStatus: 'started' },
+          ],
+        ],
+      ]),
+    });
+
+    const laneOf = (task: Task.Task) => timeline.lanes.find((lane) => lane.taskId === task.id);
+    expect(laneOf(parent)?.parentId).toBeUndefined();
+    expect(laneOf(parent)?.start).toBe(1_000);
+    expect(laneOf(child)?.start).toBe(1_000);
+    expect(laneOf(grandchild)?.start).toBe(1_000);
+    // It carries every descendant's start and finish beside its own move, so its first node is where the work began.
+    const nodesOf = (task: Task.Task) =>
+      timeline.markers
+        .filter((marker) => marker.laneId === laneOf(task)?.id)
+        .map(({ timestamp }) => timestamp)
+        .sort((left, right) => left - right);
+    expect(nodesOf(parent)).toEqual([1_000, 2_000, 2_500, 3_000, 4_000]);
+    expect(nodesOf(child)).toEqual([1_000, 2_000, 2_500, 4_000]);
+  });
+
+  it.effect(
+    'draws a status move once when both the trace and the edit history record it',
+    Effect.fnUntraced(function* ({ expect }) {
+      const first = Task.make({ title: 'First', status: 'started' });
+      const second = Task.make({ title: 'Second', status: 'todo' });
+      const chat = makeChat('Both', [first, second]);
+      yield* TestTraceService.withMeta(
+        { pid: 'agent', conversation: chat.feed },
+        Effect.gen(function* () {
+          yield* Trace.write(Trace.AgentRequestBegin, {}); // 1.
+          yield* Trace.write(Trace.TaskStatusChanged, { taskId: first.id, title: 'First', status: 'started' }); // 2.
+        }),
+      );
+
+      const messages = yield* TestTraceService.messages;
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [first, second],
+        taskStatusChanges: new Map([[first.id, [{ timestamp: 2, status: 'started', previousStatus: 'todo' }]]]),
+      });
+
+      const markers = timeline.markers.filter((marker) => marker.kind === 'task');
+      // The trace event is drawn through the history, which takes its pid.
+      expect(markers.map(({ laneId, label, pid }) => ({ laneId, label, pid }))).toEqual([
+        { laneId: `task:${first.id}`, label: 'Task started', pid: 'agent' },
+      ]);
+    }, Effect.provide(TestTraceService.layer)),
+  );
+
+  test('closes a finished task whose history is missing its closing move', ({ expect }) => {
+    const first = Task.make({ title: 'First', status: 'done' });
+    const second = Task.make({ title: 'Second', status: 'todo' });
+    const chat = makeChat('Unrecorded', [first, second]);
+
+    const timeline = buildSessionTimeline({
+      traceMessages: [],
+      sessions: [chat.session],
+      tasks: [first, second],
+      taskStatusChanges: new Map([[first.id, [{ timestamp: 1_000, status: 'started', previousStatus: 'todo' }]]]),
+    });
+
+    expect(timeline.lanes.find((lane) => lane.id === `task:${first.id}`)).toMatchObject({ start: 1_000, end: 1_000 });
+  });
+
+  it.effect(
+    'draws a recorded status move the trace recorded off the chart',
+    Effect.fnUntraced(function* ({ expect }) {
+      const first = Task.make({ title: 'First', status: 'started' });
+      const second = Task.make({ title: 'Second', status: 'todo' });
+      const chat = makeChat('Elsewhere', [first, second]);
+      // A process belonging to no session on this chart moved the task.
+      yield* TestTraceService.withMeta(
+        { pid: 'stranger' },
+        Trace.write(Trace.TaskStatusChanged, { taskId: first.id, title: 'First', status: 'started' }), // 1.
+      );
+
+      const messages = yield* TestTraceService.messages;
+      const timeline = buildSessionTimeline({
+        traceMessages: messages,
+        sessions: [chat.session],
+        tasks: [first, second],
+        taskStatusChanges: new Map([[first.id, [{ timestamp: 1, status: 'started', previousStatus: 'todo' }]]]),
+      });
+
+      expect(
+        timeline.markers
+          .filter((marker) => marker.laneId === `task:${first.id}`)
+          .map(({ label, pid }) => ({ label, pid })),
+      ).toEqual([{ label: 'Task started', pid: undefined }]);
+    }, Effect.provide(TestTraceService.layer)),
+  );
+
+  test('records the stretch a task was put down between two runs as a gap', ({ expect }) => {
+    const task = Task.make({ title: 'Cup the samples', status: 'done' });
+    const timeline = buildSessionTimeline({
+      traceMessages: [],
+      sessions: [],
+      tasks: [task],
+      taskStatusChanges: new Map([
+        [
+          task.id,
+          [
+            { timestamp: 1_000, status: 'started', previousStatus: 'todo' },
+            { timestamp: 2_000, status: 'blocked', previousStatus: 'started' },
+            { timestamp: 5_000, status: 'started', previousStatus: 'blocked' },
+            { timestamp: 6_000, status: 'done', previousStatus: 'started' },
+          ],
+        ],
+      ]),
+    });
+
+    expect(timeline.lanes).toMatchObject([{ start: 1_000, end: 6_000, gaps: [{ start: 2_000, end: 5_000 }] }]);
+  });
+
+  test('a task still blocked has no gap: its lane ends where it was put down', ({ expect }) => {
+    const task = Task.make({ title: 'Cup the samples', status: 'blocked' });
+    const timeline = buildSessionTimeline({
+      traceMessages: [],
+      sessions: [],
+      tasks: [task],
+      taskStatusChanges: new Map([
+        [
+          task.id,
+          [
+            { timestamp: 1_000, status: 'started', previousStatus: 'todo' },
+            { timestamp: 2_000, status: 'blocked', previousStatus: 'started' },
+          ],
+        ],
+      ]),
+    });
+
+    expect(timeline.lanes[0]).toMatchObject({ start: 1_000, end: 2_000 });
+    expect(timeline.lanes[0].gaps).toBeUndefined();
+  });
+
+  test('draws a task no session works as a lane of its own, from its edit history', ({ expect }) => {
+    const done = Task.make({ title: 'Done elsewhere', status: 'done' });
+    const running = Task.make({ title: 'Running elsewhere', status: 'started', dependsOn: [Ref.make(done)] });
+    const untouched = Task.make({ title: 'Never started', status: 'todo' });
+
+    const timeline = buildSessionTimeline({
+      traceMessages: [],
+      sessions: [],
+      tasks: [done, running, untouched],
+      taskStatusChanges: new Map([
+        [
+          done.id,
+          [
+            { timestamp: 1_000, status: 'started', previousStatus: 'todo' },
+            { timestamp: 2_000, status: 'done', previousStatus: 'started' },
+          ],
+        ],
+        [running.id, [{ timestamp: 3_000, status: 'started', previousStatus: 'todo' }]],
+      ]),
+    });
+
+    expect(timeline.lanes).toEqual([
+      {
+        id: `task:${done.id}`,
+        kind: 'task',
+        label: 'Done elsewhere',
+        status: 'done',
+        start: 1_000,
+        end: 2_000,
+        taskId: done.id,
+        hue: getHashHue(Obj.getMnemonic(done)),
+      },
+      {
+        id: `task:${running.id}`,
+        kind: 'task',
+        label: 'Running elsewhere',
+        status: 'running',
+        start: 3_000,
+        end: undefined,
+        taskId: running.id,
+        hue: getHashHue(Obj.getMnemonic(running)),
+        blockedOn: [`task:${done.id}`],
+      },
+    ]);
+    expect(timeline.markers.filter((marker) => marker.laneId === `task:${done.id}`).map(({ label }) => label)).toEqual([
+      'Task started',
+      'Task done',
+    ]);
+  });
+
+  test('reads no status moves for a task outside a database, which keeps no history', ({ expect }) => {
+    expect(readTaskStatusChanges(Task.make({ title: 'Loose', status: 'done' }))).toEqual([]);
+  });
 });
 
-const agentProcess = (pid: string, chat: TestChat, state: Process.State): Process.Info => ({
+describe('readTaskStatusChanges', () => {
+  it.effect(
+    "reads the status moves a stored task's edit history records, and the chart bounds its lane by them",
+    Effect.fnUntraced(
+      function* ({ expect }) {
+        const first = yield* Database.add(Task.make({ title: 'First', status: 'todo' }));
+        const second = yield* Database.add(Task.make({ title: 'Second', status: 'todo' }));
+        yield* Database.flush();
+        Task.setStatus(first, 'started');
+        // An edit to another field is no status move.
+        Task.update(first, { priority: 'high' });
+        Task.setStatus(first, 'done');
+        yield* Database.flush();
+
+        const changes = readTaskStatusChanges(first);
+        expect(changes.map(({ status, previousStatus }) => ({ status, previousStatus }))).toEqual([
+          { status: 'todo', previousStatus: undefined },
+          { status: 'started', previousStatus: 'todo' },
+          { status: 'done', previousStatus: 'started' },
+        ]);
+        expect(readTaskStatusChanges(second).map(({ status }) => status)).toEqual(['todo']);
+
+        const chat = makeChat('Stored', [first, second]);
+        const timeline = buildSessionTimeline({
+          traceMessages: [],
+          sessions: [chat.session],
+          tasks: [first, second],
+          taskStatusChanges: new Map([
+            [first.id, changes],
+            [second.id, readTaskStatusChanges(second)],
+          ]),
+        });
+        expect(timeline.lanes.find((lane) => lane.id === `task:${first.id}`)).toMatchObject({
+          status: 'done',
+          start: changes[1]?.timestamp,
+          end: changes[2]?.timestamp,
+        });
+        expect(timeline.lanes.find((lane) => lane.id === `task:${second.id}`)?.start).toBeUndefined();
+      },
+      Effect.provide(TestDatabaseLayer({ types: [Milestone.Milestone, Task.Task] })),
+    ),
+  );
+});
+
+const agentProcess = (pid: string, chat: TestChat, state: Process.State): Process.Process => ({
   pid: Process.ID.make(pid),
   parentPid: null,
   key: 'agent',
@@ -643,6 +1188,9 @@ const makeChat = (name: string, tasks: readonly Task.Task[]): TestChat => {
   };
 };
 
+/** An ISO date `ms` after the epoch, for history entries set against the trace's clock. */
+const at = (ms: number): string => new Date(ms).toISOString();
+
 const toolCall = (name: string) =>
   Trace.write(Trace.CompleteBlock, {
     messageId: MESSAGE_ID,