@dxos/plugin-assistant 0.8.4-main.422d1c7879 → 0.8.4-main.51f1e5ca51

package/src/containers/TracePanel/execution-graph.ts

@@ -2,12 +2,17 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Array from 'effect/Array';
+import { pipe } from 'effect/Function';
+import * as Order from 'effect/Order';
+import * as Pipeable from 'effect/Pipeable';
 import * as Predicate from 'effect/Predicate';
+import * as Struct from 'effect/Struct';
 
-import { AGENT_PROCESS_KEY, AgentRequestBegin, AgentRequestEnd, CompleteBlock } from '@dxos/assistant';
-import { Trace } from '@dxos/functions';
-import { Process } from '@dxos/functions-runtime';
-import { LogLevel } from '@dxos/log';
+import { AgentRequestBegin, AgentRequestEnd, CompleteBlock } from '@dxos/assistant';
+import { Trace } from '@dxos/compute';
+import { AGENT_PROCESS_KEY, Process } from '@dxos/functions-runtime';
+import { LogLevel, log } from '@dxos/log';
 import { type Commit } from '@dxos/react-ui-components';
 
 /**
@@ -21,7 +26,7 @@ const ICONS = {
     level: LogLevel.VERBOSE,
   },
   agentRequestEnd: {
-    icon: 'ph--check-circle--regular',
+    icon: 'ph--atom--regular',
     level: LogLevel.INFO,
   },
   userMessage: {
@@ -33,7 +38,7 @@ const ICONS = {
     level: LogLevel.VERBOSE,
   },
   statusMessage: {
-    icon: 'ph--dot-outline--regular',
+    icon: 'ph--info--regular',
     level: LogLevel.VERBOSE,
   },
   toolCall: {
@@ -49,7 +54,7 @@ const ICONS = {
     level: LogLevel.ERROR,
   },
   toolResultSuccess: {
-    icon: 'ph--check-circle--regular',
+    icon: 'ph--wrench--regular',
     level: LogLevel.INFO,
   },
   runningAgent: {
@@ -57,24 +62,28 @@ const ICONS = {
     level: LogLevel.INFO,
   },
   operationStart: {
-    icon: 'ph--play--regular',
+    icon: 'ph--function--regular',
     level: LogLevel.VERBOSE,
   },
   operationEnd: {
-    icon: 'ph--check-circle--regular',
+    icon: 'ph--function--regular',
     level: LogLevel.INFO,
   },
   operationEndError: {
-    icon: 'ph--x-circle--regular',
+    icon: 'ph--function--regular',
     level: LogLevel.ERROR,
   },
   operationEndSuccess: {
-    icon: 'ph--check-circle--regular',
+    icon: 'ph--function--regular',
     level: LogLevel.INFO,
   },
   agentRequestRunning: {
     icon: 'ph--spinner-gap--regular',
-    level: LogLevel.INFO,
+    level: LogLevel.VERBOSE,
+  },
+  processRunning: {
+    icon: 'ph--spinner-gap--regular',
+    level: LogLevel.VERBOSE,
   },
 } as const;
 
@@ -115,13 +124,15 @@ export const buildExecutionGraph = ({
 }: BuildExecutionGraphParams): { branches: string[]; commits: Commit[] } => {
   const builder = new GraphBuilder();
 
-  const events = traceMessages.slice(-eventLimit).flatMap((message) =>
-    message.events.map((event: Trace.Event) => ({
-      id: message.id,
-      meta: message.meta,
-      ...event,
-    })),
-  );
+  const events = traceMessages
+    .flatMap((message) =>
+      message.events.map((event: Trace.Event, index) => ({
+        ...event,
+        meta: message.meta,
+        id: 'id' in event ? (event as any).id : `${message.id}:${index}`,
+      })),
+    )
+    .slice(-eventLimit);
 
   builder.addBranch(MAIN_BRANCH);
 
@@ -130,7 +141,11 @@ export const buildExecutionGraph = ({
       builder.addCommit({
         id: event.id,
         branch: event.meta.parentPid ?? MAIN_BRANCH,
-        parents: builder.computeParents([{ branch: event.meta.parentPid ?? MAIN_BRANCH }]),
+        parents: builder.computeParents(
+          CommitSelector.branch(event.meta.parentPid ?? MAIN_BRANCH).pipe(
+            CommitSelector.compose(CommitSelector.last()),
+          ),
+        ),
         tags: [...getTags(event.meta), event.meta.pid && tagStartMarker(event.meta.pid)].filter(
           Predicate.isNotNullable,
         ),
@@ -143,10 +158,17 @@ export const buildExecutionGraph = ({
       builder.addCommit({
         id: event.id,
         branch: event.meta.parentPid ?? MAIN_BRANCH,
-        parents: builder.computeParents([
-          { branch: event.meta.parentPid ?? MAIN_BRANCH },
-          { commit: { tags: [event.meta.pid && tagPid(event.meta.pid)] } },
-        ]),
+        parents: builder.computeParents(
+          CommitSelector.unionAll(
+            CommitSelector.branch(event.meta.parentPid ?? MAIN_BRANCH).pipe(
+              CommitSelector.orElse(CommitSelector.tag(event.meta.pid && tagPid(event.meta.pid))),
+              CommitSelector.compose(CommitSelector.last()),
+            ),
+            CommitSelector.tag(event.meta.pid && tagPid(event.meta.pid)).pipe(
+              CommitSelector.compose(CommitSelector.last()),
+            ),
+          ),
+        ),
         tags: getTags(event.meta),
         timestamp: new Date(event.timestamp),
         icon: ICONS.agentRequestEnd.icon,
@@ -160,19 +182,16 @@ export const buildExecutionGraph = ({
             builder.addCommit({
               id: event.id,
               branch: event.meta.pid ?? MAIN_BRANCH,
-              parents: builder.computeParents([
-                {
-                  branch: event.meta.pid ?? MAIN_BRANCH,
-                  fallback: { tags: [event.meta.pid && tagPid(event.meta.pid)] },
-                },
-                {
-                  commit: {
-                    tags: [event.meta.parentPid && tagStartMarker(event.meta.parentPid)].filter(
-                      Predicate.isNotNullable,
+              parents: builder.computeParents(
+                CommitSelector.branch(event.meta.pid ?? MAIN_BRANCH).pipe(
+                  CommitSelector.compose(CommitSelector.last()),
+                  CommitSelector.orElse(
+                    CommitSelector.tag(event.meta.pid && tagStartMarker(event.meta.pid)).pipe(
+                      CommitSelector.compose(CommitSelector.last()),
                     ),
-                  },
-                },
-              ]),
+                  ),
+                ),
+              ),
               tags: getTags(event.meta),
               timestamp: new Date(event.timestamp),
               icon: ICONS.userMessage.icon,
@@ -186,12 +205,16 @@ export const buildExecutionGraph = ({
           builder.addCommit({
             id: event.id,
             branch: event.meta.pid ?? MAIN_BRANCH,
-            parents: builder.computeParents([
-              {
-                branch: event.meta.pid ?? MAIN_BRANCH,
-                fallback: { tags: [event.meta.pid && tagPid(event.meta.pid)] },
-              },
-            ]),
+            parents: builder.computeParents(
+              CommitSelector.branch(event.meta.pid ?? MAIN_BRANCH).pipe(
+                CommitSelector.compose(CommitSelector.last()),
+                CommitSelector.orElse(
+                  CommitSelector.tag(event.meta.pid && tagPid(event.meta.pid)).pipe(
+                    CommitSelector.compose(CommitSelector.last()),
+                  ),
+                ),
+              ),
+            ),
             tags: getTags(event.meta),
             timestamp: new Date(event.timestamp),
             icon: ICONS.statusMessage.icon,
@@ -200,117 +223,79 @@ export const buildExecutionGraph = ({
           });
           break;
         }
-        case 'toolCall': {
-          builder.addCommit({
-            id: `${event.data.block.toolCallId}:call`,
-            branch: event.meta.pid ?? MAIN_BRANCH,
-            parents: builder.computeParents([
-              {
-                branch: event.meta.pid ?? MAIN_BRANCH,
-                fallback: { tags: [event.meta.pid && tagPid(event.meta.pid)] },
-              },
-            ]),
-            tags: getTags(event.meta),
-            timestamp: new Date(event.timestamp),
-            icon: ICONS.toolCall.icon,
-            level: ICONS.toolCall.level,
-            message: event.data.block.name,
-          });
-          break;
-        }
-        case 'toolResult': {
-          builder.addCommit(
-            {
-              id: `${event.data.block.toolCallId}:result`,
-              branch: event.meta.pid ?? MAIN_BRANCH,
-              parents: builder.computeParents([
-                {
-                  branch: event.meta.pid ?? MAIN_BRANCH,
-                  fallback: { tags: [event.meta.pid && tagPid(event.meta.pid)] },
-                },
-              ]),
-              tags: getTags(event.meta),
-              timestamp: new Date(event.timestamp),
-              icon: event.data.block.error ? ICONS.toolResultError.icon : ICONS.toolResultSuccess.icon,
-              level: event.data.block.error ? ICONS.toolResultError.level : ICONS.toolResultSuccess.level,
-              message: event.data.block.error
-                ? `${event.data.block.name} - Error: ${trimText(event.data.block.error)}`
-                : `${event.data.block.name} - Success`,
-            },
-            {
-              replace: {
-                id: [`${event.data.block.toolCallId}:call`],
-              },
-            },
-          );
-          break;
-        }
       }
     } else if (Trace.isOfType(Trace.OperationStart, event)) {
-      if (!event.meta.conversationId) {
-        // Ignoring tool calls.
-        builder.addCommit({
-          id: `${event.id}:${event.data.key}:start`,
+      builder.addCommit({
+        id: `${event.id}:${event.data.key}:start`,
+        branch: event.meta.parentPid ?? MAIN_BRANCH,
+        parents: builder.computeParents(
+          CommitSelector.branch(event.meta.parentPid ?? MAIN_BRANCH).pipe(
+            CommitSelector.andAlso(CommitSelector.tag(event.meta.parentPid && tagStartMarker(event.meta.parentPid))),
+            CommitSelector.compose(CommitSelector.orderByTimestamp()),
+            CommitSelector.compose(CommitSelector.last()),
+            CommitSelector.orElse(CommitSelector.branch(event.meta.parentPid)),
+            CommitSelector.compose(CommitSelector.last()),
+          ),
+        ),
+        tags: [
+          ...getTags(event.meta),
+          tagOperationBegin(`${event.meta.pid ?? 'unknown'}:${event.data.key}`),
+          event.meta.pid && tagStartMarker(event.meta.pid),
+        ].filter(Predicate.isNotNullable),
+        timestamp: new Date(event.timestamp),
+        icon: ICONS.operationStart.icon,
+        level: ICONS.operationStart.level,
+        message: event.data.name ?? event.data.key,
+      });
+    } else if (Trace.isOfType(Trace.OperationEnd, event)) {
+      const children = builder.findCommits(
+        CommitSelector.anyTags([
+          event.meta.pid && tagPid(event.meta.pid),
+          event.meta.pid && tagParentPid(event.meta.pid),
+        ]),
+      );
+      builder.addCommit(
+        {
+          id: `${event.id}:${event.data.key}:end`,
           branch: event.meta.parentPid ?? MAIN_BRANCH,
-          parents: builder.computeParents([
-            {
-              branch: event.meta.parentPid ?? MAIN_BRANCH,
-              fallback: { tags: [event.meta.parentPid && tagPid(event.meta.parentPid)] },
-            },
-            {
-              commit: {
-                tags: [event.meta.parentPid && tagStartMarker(event.meta.parentPid)].filter(Predicate.isNotNullable),
-              },
-            },
-          ]),
-          tags: [
-            ...getTags(event.meta),
-            tagOperationBegin(event.meta.pid ?? 'unknown'),
-            event.meta.pid && tagStartMarker(event.meta.pid),
-          ].filter(Predicate.isNotNullable),
+          parents: builder.computeParents(
+            CommitSelector.branch(event.meta.parentPid ?? MAIN_BRANCH).pipe(
+              CommitSelector.compose(
+                CommitSelector.not(
+                  CommitSelector.tag(tagOperationBegin(`${event.meta.pid ?? 'unknown'}:${event.data.key}`)),
+                ),
+              ),
+              CommitSelector.orElse(CommitSelector.tag(event.meta.parentPid && tagStartMarker(event.meta.parentPid))),
+              CommitSelector.compose(CommitSelector.last()),
+              CommitSelector.andAlso(
+                CommitSelector.anyTags([
+                  event.meta.pid && tagPid(event.meta.pid),
+                  event.meta.pid && tagParentPid(event.meta.pid),
+                ]).pipe(
+                  CommitSelector.compose(
+                    CommitSelector.not(
+                      CommitSelector.tag(tagOperationBegin(`${event.meta.pid ?? 'unknown'}:${event.data.key}`)),
+                    ),
+                  ),
+                  CommitSelector.compose(CommitSelector.last()),
+                ),
+              ),
+            ),
+          ),
+          tags: getTags(event.meta),
           timestamp: new Date(event.timestamp),
-          icon: ICONS.operationStart.icon,
-          level: ICONS.operationStart.level,
-          message: event.data.name ?? event.data.key,
-        });
-      }
-    } else if (Trace.isOfType(Trace.OperationEnd, event)) {
-      if (!event.meta.conversationId) {
-        // Ignoring tool calls.
-        const children = builder.findCommits({ tags: [event.meta.pid && tagPid(event.meta.pid)] });
-        builder.addCommit(
-          {
-            id: `${event.id}:${event.data.key}:end`,
-            branch: event.meta.parentPid ?? MAIN_BRANCH,
-            parents: builder.computeParents([
-              {
-                branch: event.meta.parentPid ?? MAIN_BRANCH,
-                fallback: { tags: [event.meta.parentPid && tagPid(event.meta.parentPid)] },
-              },
-              { commit: { tags: [event.meta.pid && tagPid(event.meta.pid)] } },
-              {
-                commit: {
-                  tags: [event.meta.parentPid && tagStartMarker(event.meta.parentPid)].filter(Predicate.isNotNullable),
-                },
-              },
-            ]),
-            tags: getTags(event.meta),
-            timestamp: new Date(event.timestamp),
-            icon: event.data.outcome === 'success' ? ICONS.operationEndSuccess.icon : ICONS.operationEndError.icon,
-            level: event.data.outcome === 'success' ? ICONS.operationEndSuccess.level : ICONS.operationEndError.level,
-            message: event.data.name ?? event.data.key,
-          },
-          {
-            replace:
-              // TODO(dmaretskyi): Deduping events in subbranches brekas graph.
-              !event.meta.parentPid && children.length > 1 // 1 is the operation begin commit.
-                ? undefined
-                : {
-                    tags: [tagOperationBegin(event.meta.pid ?? 'unknown')],
-                  },
-          },
-        );
-      }
+          icon: event.data.outcome === 'success' ? ICONS.operationEndSuccess.icon : ICONS.operationEndError.icon,
+          level: event.data.outcome === 'success' ? ICONS.operationEndSuccess.level : ICONS.operationEndError.level,
+          message: `${event.data.name ?? event.data.key} - ${event.data.outcome === 'success' ? 'Success' : 'Error'}`,
+        },
+        {
+          replace:
+            // TODO(dmaretskyi): Deduping events in subbranches brekas graph.
+            !event.meta.parentPid || children.length > 1 // 1 is the operation begin commit.
+              ? undefined
+              : CommitSelector.tag(tagOperationBegin(`${event.meta.pid ?? 'unknown'}:${event.data.key}`)),
+        },
+      );
     }
   }
 
@@ -323,38 +308,192 @@ export const buildExecutionGraph = ({
       builder.addCommit({
         id: `running:${process.pid}`,
         branch: process.pid,
-        parents: builder.computeParents([{ branch: process.pid }]),
+        parents: builder.computeParents(
+          CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last())),
+        ),
         icon: ICONS.agentRequestRunning.icon,
         level: ICONS.agentRequestRunning.level,
         message: 'Generating...',
         timestamp: new Date(),
       });
+    } else if (process.state === Process.State.RUNNING && builder.hasBranch(process.pid)) {
+      builder.addCommit({
+        id: `running:${process.pid}`,
+        branch: process.pid,
+        parents: builder.computeParents(
+          CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last())),
+        ),
+        icon: ICONS.processRunning.icon,
+        level: ICONS.processRunning.level,
+        message: 'Running...',
+        timestamp: new Date(),
+      });
     }
   }
 
-  return builder.build();
+  const built = builder.build();
+  log('trace execution graph', {
+    traceMessages: traceMessages.length,
+    flatEvents: events.length,
+    commits: built.commits.length,
+    branches: built.branches.length,
+    activeProcesses: activeProcesses.length,
+  });
+  return built;
 };
 
 type Falsy = false | null | undefined;
-type MaybeFalsy<T> = T | Falsy;
 
-// TODO(dmaretskyi): Replace this with simple composition of predicates.
-type CommitSelector = { id?: MaybeFalsy<string>[]; tags?: MaybeFalsy<string>[] };
+export interface CommitSelector extends Pipeable.Pipeable {
+  select: (commits: Commit[]) => Commit[];
+}
+
+export const CommitSelector = {
+  make: (select: CommitSelector['select']): CommitSelector => ({
+    select,
+    pipe(...args: any) {
+      return Pipeable.pipeArguments(this, args);
+    },
+  }),
+
+  identity: (): CommitSelector => CommitSelector.make((commits) => commits),
+
+  /**
+   * Selects commits that match the given predicate.
+   */
+  filter: (predicate: (commit: Commit) => unknown): CommitSelector =>
+    CommitSelector.make((commits) => commits.filter(predicate)),
+
+  /**
+   * Selects commits by id.
+   */
+  id: (id: string): CommitSelector => CommitSelector.filter((commit) => commit.id === id),
+  /**
+   * Selects commits by tag.
+   */
+  tag: (tag: string | Falsy): CommitSelector => CommitSelector.filter((commit) => tag && commit.tags?.includes(tag)),
+  /**
+   * Selects commits by if any of the given tags are present.
+   */
+  anyTags: (tags: (string | Falsy)[]): CommitSelector =>
+    CommitSelector.filter((commit) => tags.some((tag) => tag && commit.tags?.includes(tag))),
+  /**
+   * Selects commits by branch.
+   */
+  branch: (branch: string | Falsy): CommitSelector =>
+    CommitSelector.filter((commit) => branch && commit.branch === branch),
+
+  /**
+   * Chains two selectors together, applying the second selector to the result of the first.
+   *
+   * Example:
+   *
+   * ```
+   * CommitSelector.tag('tag').pipe(CommitSelector.compose(CommitSelector.branch('main')));
+   * ```
+   */
+  compose:
+    (next: CommitSelector) =>
+    (prev: CommitSelector): CommitSelector =>
+      CommitSelector.make((commits) => next.select(prev.select(commits))),
+
+  /**
+   * If `prev` selector matches no commits, return `next` selector, otherwise return `prev` selector.
+   * Same as `CommitSelector.firstOf(prev, next)`.
+   *
+   * Example:
+   *
+   * ```
+   * CommitSelector.tag('tag').pipe(CommitSelector.orElse(CommitSelector.branch('main')));
+   * ```
+   */
+  orElse:
+    (next: CommitSelector) =>
+    (prev: CommitSelector): CommitSelector =>
+      CommitSelector.make((commits) => {
+        const selected = prev.select(commits);
+        if (selected.length > 0) {
+          return selected;
+        }
+        return next.select(commits);
+      }),
+
+  /**
+   * Selects commits that match either of the given selectors.
+   */
+  andAlso:
+    (next: CommitSelector) =>
+    (prev: CommitSelector): CommitSelector =>
+      CommitSelector.unionAll(prev, next),
+
+  /**
+   * Selects the first n commits.
+   */
+  first: (n: number = 1): CommitSelector => CommitSelector.make((commits) => commits.slice(0, n)),
+  /**
+   * Selects the last n commits (reverses the order of the commits).
+   */
+  last: (n: number = 1): CommitSelector => CommitSelector.make((commits) => commits.toReversed().slice(0, n)),
+  /**
+   * Selects commits that do not match the given selector.
+   */
+  not: (selector: CommitSelector): CommitSelector =>
+    CommitSelector.make((commits) => {
+      const selected = selector.select(commits);
+      return commits.filter((commit) => !selected.includes(commit));
+    }),
+
+  /**
+   * Selects commits that match any of the given selectors.
+   */
+  unionAll: (...selectors: CommitSelector[]): CommitSelector =>
+    CommitSelector.make((commits) => {
+      return Array.dedupeWith(
+        selectors.flatMap((selector) => selector.select(commits)),
+        (a, b) => a.id === b.id,
+      );
+    }),
+
+  /**
+   * Selects commits that match all of the given selectors.
+   */
+  intersectAll: (...selectors: CommitSelector[]): CommitSelector =>
+    CommitSelector.make((commits) => {
+      const selected = selectors.map((selector) => selector.select(commits));
+      if (selected.length === 0) {
+        return [];
+      }
+      return selected[0].filter((commit) => selected.every((selected) => selected.some((c) => c.id === commit.id)));
+    }),
+
+  /**
+   * Returns the result of the first selector that matches any commits.
+   */
+  firstOf: (...selectors: CommitSelector[]): CommitSelector =>
+    CommitSelector.make((commits) => {
+      for (const selector of selectors) {
+        const selected = selector.select(commits);
+        if (selected.length > 0) {
+          return selected;
+        }
+      }
+      return [];
+    }),
+
+  orderByTimestamp: (): CommitSelector =>
+    CommitSelector.make(Array.sortWith((a) => a.timestamp?.getTime() ?? 0, Order.number)),
+};
 
 class GraphBuilder {
   #commits: Commit[] = [];
   #branches = new Set<string>();
 
-  findCommits(selector: CommitSelector) {
-    return this.#commits.filter((commit) => {
-      if (selector.id && selector.id.includes(commit.id)) {
-        return true;
-      }
-      if (selector.tags && selector.tags.some((tag) => tag && commit.tags?.includes(tag))) {
-        return true;
-      }
-      return false;
-    });
+  findCommits(selector: CommitSelector): Commit[] {
+    return selector.select(this.#commits);
+  }
+
+  hasBranch(branch: string): boolean {
+    return this.#branches.has(branch);
   }
 
   addCommit(
@@ -368,16 +507,27 @@ class GraphBuilder {
     },
   ) {
     if (opts?.ifMissing) {
-      const commits = this.findCommits(opts.ifMissing);
-      if (commits.length > 0) {
+      if (this.findCommits(opts.ifMissing).length > 0) {
         return;
       }
     }
     this.addBranch(commit.branch);
     if (opts?.replace) {
-      const commits = this.findCommits(opts.replace);
-      if (commits.length > 0) {
-        this.#commits[this.#commits.indexOf(commits.at(-1)!)] = commit;
+      const matches = this.findCommits(opts.replace);
+      if (matches.length > 0) {
+        const replaced = matches.at(-1)!;
+        this.#commits.splice(this.#commits.indexOf(replaced), 1);
+        // Update parents to point to the new commit.
+        for (const existingCommit of this.#commits) {
+          if (existingCommit.parents) {
+            for (let i = 0; i < existingCommit.parents.length; i++) {
+              if (existingCommit.parents[i] === replaced.id) {
+                existingCommit.parents[i] = commit.id;
+              }
+            }
+          }
+        }
+        this.#commits.push(commit);
         return;
       }
     }
@@ -385,63 +535,40 @@ class GraphBuilder {
   }
 
   removeCommit(selector: CommitSelector) {
-    const commits = this.findCommits(selector);
-    for (const commit of commits) {
+    for (const commit of this.findCommits(selector)) {
       this.#commits.splice(this.#commits.indexOf(commit), 1);
     }
   }
 
   /**
-   * Computes parents based on a list of specs.
+   * Computes parents — picks first matching commit's id.
    */
-  computeParents(
-    specs: (
-      | {
-          /**
-           * Parent commits selector.
-           */
-          commit?: CommitSelector;
-        }
-      | {
-          /**
-           * Last commit on this branch as parent.
-           */
-          branch?: string;
-
-          /**
-           * Fallback if branch has no commits.
-           */
-          fallback?: CommitSelector;
-        }
-    )[],
-  ): string[] {
-    return specs.flatMap((spec) => {
-      if ('commit' in spec && spec.commit) {
-        return this.findCommits(spec.commit)
-          .slice(-1)
-          .map((commit) => commit.id);
-      }
-      if ('branch' in spec && spec.branch) {
-        const lastCommit = this.#commits.findLast((commit) => commit.branch === spec.branch);
-        if (lastCommit) {
-          return [lastCommit.id];
-        } else if (spec.fallback) {
-          return this.findCommits(spec.fallback)
-            .slice(-1)
-            .map((commit) => commit.id);
-        } else {
-          return [];
-        }
-      }
-      return [];
-    });
+  computeParents(selector: CommitSelector): string[] {
+    return Array.dedupe(selector.select(this.#commits).map((commit) => commit.id));
   }
 
   addBranch(branch: string) {
     this.#branches.add(branch);
   }
 
+  /**
+   * Removes duplicate commits and dangling parents.
+   */
+  doctor() {
+    this.#commits = pipe(
+      this.#commits,
+      Array.dedupeWith((a, b) => a.id === b.id),
+      Array.map(
+        Struct.evolve({
+          parents: (parents) =>
+            parents ? Array.filter(parents, (id) => this.#commits.some((commit) => commit.id === id)) : undefined,
+        }),
+      ),
+    );
+  }
+
   build() {
+    this.doctor();
     return {
       commits: this.#commits,
       branches: [...this.#branches],