@dxos/plugin-assistant 0.8.4-main.abd8ff62ef → 0.8.4-main.bc2380dfbc

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

@@ -3,10 +3,10 @@
 //
 
 import * as Array from 'effect/Array';
+import * as Either from 'effect/Either';
 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 Schema from 'effect/Schema';
 import * as Struct from 'effect/Struct';
 
 import { AgentRequestBegin, AgentRequestEnd, CompleteBlock } from '@dxos/assistant';
@@ -15,6 +15,8 @@ import { AGENT_PROCESS_KEY, Process } from '@dxos/functions-runtime';
 import { LogLevel, log } from '@dxos/log';
 import { type Commit } from '@dxos/react-ui-components';
 
+import { ROOT_SPAN_ID, type Span, buildSpanTree, isSpanBeginEvent, isSpanEndEvent, walkSpanTree } from './span-tree';
+
 /**
  * Branch name for top-level operation invocations.
  */
@@ -33,39 +35,15 @@ const ICONS = {
     icon: 'ph--user--regular',
     level: LogLevel.VERBOSE,
   },
-  assistantMessage: {
-    icon: 'ph--drone--regular',
-    level: LogLevel.VERBOSE,
-  },
   statusMessage: {
     icon: 'ph--info--regular',
     level: LogLevel.VERBOSE,
   },
-  toolCall: {
-    icon: 'ph--wrench--regular',
-    level: LogLevel.VERBOSE,
-  },
-  toolResult: {
-    icon: 'ph--wrench--regular',
-    level: LogLevel.INFO,
-  },
-  toolResultError: {
-    icon: 'ph--wrench--regular',
-    level: LogLevel.ERROR,
-  },
-  toolResultSuccess: {
-    icon: 'ph--wrench--regular',
-    level: LogLevel.INFO,
-  },
-  runningAgent: {
-    icon: 'ph--spinner-gap--regular',
-    level: LogLevel.INFO,
-  },
   operationStart: {
     icon: 'ph--function--regular',
     level: LogLevel.VERBOSE,
   },
-  operationEnd: {
+  operationEndSuccess: {
     icon: 'ph--function--regular',
     level: LogLevel.INFO,
   },
@@ -73,10 +51,6 @@ const ICONS = {
     icon: 'ph--function--regular',
     level: LogLevel.ERROR,
   },
-  operationEndSuccess: {
-    icon: 'ph--function--regular',
-    level: LogLevel.INFO,
-  },
   agentRequestRunning: {
     icon: 'ph--spinner-gap--regular',
     level: LogLevel.VERBOSE,
@@ -87,26 +61,6 @@ const ICONS = {
   },
 } as const;
 
-const tagPid = (pid: string) => `pid:${pid}`;
-const tagParentPid = (parentPid: string) => `parent-pid:${parentPid}`;
-const tagConversation = (conversationId: string) => `conversation:${conversationId}`;
-const tagOperationBegin = (pid: string) => `operation-begin:${pid}`;
-const tagStartMarker = (pid: string) => `start-marker:${pid}`;
-
-const getTags = (meta: Trace.Meta) => {
-  const tags: string[] = [];
-  if (meta.pid) {
-    tags.push(tagPid(meta.pid));
-  }
-  if (meta.parentPid) {
-    tags.push(tagParentPid(meta.parentPid));
-  }
-  if (meta.conversationId) {
-    tags.push(tagConversation(meta.conversationId));
-  }
-  return tags;
-};
-
 export interface BuildExecutionGraphParams {
   traceMessages: Trace.Message[];
   activeProcesses?: readonly Process.Info[];
@@ -115,190 +69,326 @@ export interface BuildExecutionGraphParams {
 
 /**
  * Builds a Timeline-compatible execution graph from trace messages and active processes.
+ *
+ * The conversion runs in two stages:
+ *   1. `buildSpanTree` converts the flat list of trace messages into a hierarchical
+ *      tree of spans grouped by process id (pid). See `./span-tree.ts`.
+ *   2. `spanTreeToCommits` walks the tree and emits one commit per event, using the
+ *      tree structure to decide which branch each commit belongs to and how to wire parents.
+ *
  * Pure function — no signals or atoms.
  */
+export type ExecutionGraph = {
+  branches: string[];
+  commits: Commit[];
+  spanTree: Span;
+};
+
 export const buildExecutionGraph = ({
   traceMessages,
   activeProcesses = [],
   eventLimit = 500,
-}: BuildExecutionGraphParams): { branches: string[]; commits: Commit[] } => {
-  const builder = new GraphBuilder();
-
-  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);
+}: BuildExecutionGraphParams): ExecutionGraph => {
+  const spanTree = buildSpanTree(traceMessages, { eventLimit });
+  const built = spanTreeToCommits(spanTree, activeProcesses);
+  log('trace execution graph', {
+    traceMessages: traceMessages.length,
+    commits: built.commits.length,
+    branches: built.branches.length,
+    activeProcesses: activeProcesses.length,
+  });
+  return { ...built, spanTree };
+};
 
-  builder.addBranch(MAIN_BRANCH);
+/**
+ * Visual representation of a single trace event — icon, log level, message string.
+ * `undefined` indicates that the event should not produce a commit.
+ */
+interface EventPresentation {
+  icon: string;
+  level: LogLevel;
+  message: string;
+  idSuffix?: string;
+}
 
-  for (const event of events) {
-    if (Trace.isOfType(AgentRequestBegin, event)) {
-      builder.addCommit({
-        id: event.id,
-        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,
-        ),
-        timestamp: new Date(event.timestamp),
-        icon: ICONS.agentRequestBegin.icon,
-        level: ICONS.agentRequestBegin.level,
-        message: 'Agent processing request...',
-      });
-    } else if (Trace.isOfType(AgentRequestEnd, event)) {
-      builder.addCommit({
-        id: event.id,
-        branch: event.meta.parentPid ?? MAIN_BRANCH,
-        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,
-        level: ICONS.agentRequestEnd.level,
-        message: 'Agent completed request',
-      });
-    } else if (Trace.isOfType(CompleteBlock, event)) {
-      switch (event.data.block._tag) {
-        case 'text': {
-          if (event.data.role === 'user') {
-            builder.addCommit({
-              id: event.id,
-              branch: event.meta.pid ?? MAIN_BRANCH,
-              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),
+const presentEvent = (event: Trace.FlatEvent): EventPresentation | undefined => {
+  if (Trace.isOfType(AgentRequestBegin, event)) {
+    if (Either.isLeft(Schema.validateEither(AgentRequestBegin.schema)(event.data))) {
+      log('invalid trace event', { type: event.type });
+      return undefined;
+    }
+    return {
+      icon: ICONS.agentRequestBegin.icon,
+      level: ICONS.agentRequestBegin.level,
+      message: 'Agent processing request...',
+    };
+  }
+  if (Trace.isOfType(AgentRequestEnd, event)) {
+    if (Either.isLeft(Schema.validateEither(AgentRequestEnd.schema)(event.data))) {
+      log('invalid trace event', { type: event.type });
+      return undefined;
+    }
+    return {
+      icon: ICONS.agentRequestEnd.icon,
+      level: ICONS.agentRequestEnd.level,
+      message: 'Agent completed request',
+    };
+  }
+  if (Trace.isOfType(CompleteBlock, event)) {
+    if (Either.isLeft(Schema.validateEither(CompleteBlock.schema)(event.data))) {
+      log('invalid trace event', { type: event.type });
+      return undefined;
+    }
+    switch (event.data.block._tag) {
+      case 'text':
+        return event.data.role === 'user'
+          ? {
               icon: ICONS.userMessage.icon,
               level: ICONS.userMessage.level,
               message: trimText(event.data.block.text),
-            });
-          }
-          break;
-        }
-        case 'status': {
-          builder.addCommit({
-            id: event.id,
-            branch: event.meta.pid ?? MAIN_BRANCH,
-            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,
-            level: ICONS.statusMessage.level,
-            message: trimText(event.data.block.statusText),
-          });
-          break;
-        }
+            }
+          : undefined;
+      case 'status':
+        return {
+          icon: ICONS.statusMessage.icon,
+          level: ICONS.statusMessage.level,
+          message: trimText(event.data.block.statusText),
+        };
+      default:
+        return undefined;
+    }
+  }
+  if (Trace.isOfType(Trace.OperationStart, event)) {
+    if (Either.isLeft(Schema.validateEither(Trace.OperationStart.schema)(event.data))) {
+      log('invalid trace event', { type: event.type });
+      return undefined;
+    }
+    return {
+      icon: ICONS.operationStart.icon,
+      level: ICONS.operationStart.level,
+      message: event.data.name ?? event.data.key,
+      idSuffix: `${event.data.key}:start`,
+    };
+  }
+  if (Trace.isOfType(Trace.OperationEnd, event)) {
+    if (Either.isLeft(Schema.validateEither(Trace.OperationEnd.schema)(event.data))) {
+      log('invalid trace event', { type: event.type });
+      return undefined;
+    }
+    const success = event.data.outcome === 'success';
+    return {
+      icon: success ? ICONS.operationEndSuccess.icon : ICONS.operationEndError.icon,
+      level: success ? ICONS.operationEndSuccess.level : ICONS.operationEndError.level,
+      message: `${event.data.name ?? event.data.key} - ${success ? 'Success' : 'Error'}`,
+      idSuffix: `${event.data.key}:end`,
+    };
+  }
+  return undefined;
+};
+
+/**
+ * A span is "collapsible" when it would otherwise render as an empty fork-and-merge:
+ * exactly two events that form a begin/end pair and no child sub-spans. In that case
+ * we emit a single commit for the end event on the parent branch.
+ *
+ * A *pending* span (one whose end event has not yet been recorded) is never collapsed:
+ * its trailing events should keep rendering as middle commits on the span's own branch
+ * — never as a fake "end" commit on the parent branch.
+ *
+ * Both nested spans and top-level spans (whose parent is the synthetic root) are eligible
+ * once they have completed: a span with no inner activity is collapsed regardless of where
+ * it sits in the tree.
+ */
+const isCollapsibleSpan = (span: Span, parent: Span | null): boolean => {
+  if (span.id === ROOT_SPAN_ID) {
+    return false;
+  }
+  if (span.events.length !== 2) {
+    return false;
+  }
+  if (span.children.length > 0) {
+    return false;
+  }
+  const firstEvent = span.events[0];
+  const lastEvent = span.events[span.events.length - 1];
+  if (!isSpanBeginEvent(firstEvent) || !isSpanEndEvent(lastEvent)) {
+    return false;
+  }
+  return parent !== null;
+};
+
+/**
+ * Converts a span tree into a flat list of commits + branches suitable for `Timeline` rendering.
+ *
+ * For every span the algorithm:
+ *  - emits the **first** event as a "begin" commit on the parent span's branch (fork);
+ *  - emits **middle** events as commits on the span's own branch;
+ *  - emits the **last** event as an "end" commit on the parent span's branch with two parents
+ *    (the begin commit and the last commit on the span's own branch — a merge).
+ *
+ * Collapsible spans (`isCollapsibleSpan`) emit only the end commit on the parent branch with
+ * a single parent — a tidier rendering for sub-operations that have no inner detail.
+ *
+ * Events are processed in global chronological order so that sub-operations of a span interleave
+ * naturally with the span's own middle events.
+ */
+const spanTreeToCommits = (
+  root: Span,
+  activeProcesses: readonly Process.Info[],
+): { branches: string[]; commits: Commit[] } => {
+  const builder = new GraphBuilder();
+  builder.addBranch(MAIN_BRANCH);
+
+  // Build a child → parent lookup using the tree's own structure (already correctly parented
+  // when the tree was constructed, including sequential spans of the same process).
+  const parentBySpan = new Map<Span, Span | null>();
+  parentBySpan.set(root, null);
+  const indexParents = (span: Span): void => {
+    for (const child of span.children) {
+      parentBySpan.set(child, span);
+      indexParents(child);
+    }
+  };
+  indexParents(root);
+
+  const findParentSpan = (span: Span): Span | null => parentBySpan.get(span) ?? null;
+
+  // The branch name for a span is its pid — multiple sequential spans of the same process
+  // (e.g. successive agent requests in one session) share a branch so they reuse a single lane.
+  const branchOf = (span: Span | null): string => {
+    if (!span || span.id === ROOT_SPAN_ID) {
+      return MAIN_BRANCH;
+    }
+    return span.meta.pid ?? span.id;
+  };
+
+  // Selector that returns the most recent commit walking up the ancestor chain of `span`,
+  // starting from `span`'s own branch and falling back through parent branches up to main.
+  // Used when a commit emitted on a parent/ancestor branch needs to attach to something
+  // that hasn't been written to yet (e.g. the first child sub-span begins before any
+  // middle event has landed on the parent branch).
+  const lastInAncestorChain = (span: Span | null): CommitSelector => {
+    const branches: string[] = [];
+    const seen = new Set<string>();
+    let current = span;
+    while (current) {
+      const branch = branchOf(current);
+      if (!seen.has(branch)) {
+        seen.add(branch);
+        branches.push(branch);
       }
-    } else if (Trace.isOfType(Trace.OperationStart, event)) {
-      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()),
-          ),
+      current = findParentSpan(current);
+    }
+    if (!seen.has(MAIN_BRANCH)) {
+      branches.push(MAIN_BRANCH);
+    }
+    return CommitSelector.firstOf(
+      ...branches.map((branch) => CommitSelector.branch(branch).pipe(CommitSelector.compose(CommitSelector.last()))),
+    );
+  };
+
+  // Flatten the tree into a chronological stream, recording each event's position within its span
+  // so we can detect begin/end events.
+  interface EventCursor {
+    span: Span;
+    event: Trace.FlatEvent;
+    eventIndex: number;
+    globalIndex: number;
+  }
+  const stream: EventCursor[] = [];
+  walkSpanTree(root, (span) => {
+    span.events.forEach((event, eventIndex) => {
+      stream.push({ span, event, eventIndex, globalIndex: stream.length });
+    });
+  });
+  stream.sort((a, b) => a.event.timestamp - b.event.timestamp || a.globalIndex - b.globalIndex);
+
+  // Track the id of the begin commit for each non-collapsible span so the end commit can merge into it.
+  const beginCommitIdBySpan = new Map<string, string>();
+
+  for (const { span, event, globalIndex } of stream) {
+    const presentation = presentEvent(event);
+    if (!presentation) {
+      continue;
+    }
+
+    // Classify based on event TYPE, not array index. A pending span's trailing
+    // middle event (e.g. a user message awaiting an agent response) must not be
+    // mistaken for the span's end event — otherwise it would render on the
+    // parent branch instead of the span's own branch.
+    const isBeginEvent = isSpanBeginEvent(event);
+    const isEndEvent = isSpanEndEvent(event);
+    const parentSpan = findParentSpan(span);
+    const collapsible = isCollapsibleSpan(span, parentSpan);
+
+    // Collapsed spans: skip the begin event entirely; only the end event renders.
+    if (collapsible && isBeginEvent) {
+      continue;
+    }
+
+    const parentBranch = branchOf(parentSpan);
+    const ownBranch = branchOf(span);
+
+    let branch: string;
+    let parents: string[];
+
+    if (span.id === ROOT_SPAN_ID) {
+      // Root-level events (no pid) attach sequentially to main.
+      branch = MAIN_BRANCH;
+      parents = builder.computeParents(
+        CommitSelector.branch(MAIN_BRANCH).pipe(CommitSelector.compose(CommitSelector.last())),
+      );
+    } else if (collapsible) {
+      // Only the end event reaches here for collapsible spans.
+      // Walk the ancestor chain so the commit attaches to the most recent ancestor
+      // even when the immediate parent branch has not received a commit yet.
+      branch = parentBranch;
+      parents = builder.computeParents(lastInAncestorChain(parentSpan));
+    } else if (isBeginEvent) {
+      // Begin commit: fork off the parent branch.
+      // Walk the ancestor chain to find the most recent ancestor commit to fork from.
+      branch = parentBranch;
+      parents = builder.computeParents(lastInAncestorChain(parentSpan));
+    } else if (isEndEvent) {
+      // End commit: merge from the span's own branch back into the parent branch.
+      branch = parentBranch;
+      const beginId = beginCommitIdBySpan.get(span.id);
+      parents = builder.computeParents(
+        CommitSelector.unionAll(
+          beginId ? CommitSelector.id(beginId) : lastInAncestorChain(parentSpan),
+          CommitSelector.branch(ownBranch).pipe(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(
-            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: 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}`)),
-        },
+    } else {
+      // Middle event: continue the span's own branch.
+      branch = ownBranch;
+      parents = builder.computeParents(
+        CommitSelector.branch(ownBranch).pipe(
+          CommitSelector.compose(CommitSelector.last()),
+          CommitSelector.orElse(lastInAncestorChain(parentSpan)),
+        ),
       );
     }
+
+    const commitId = formatCommitId(span, globalIndex, presentation.idSuffix);
+    const commit: Commit = {
+      id: commitId,
+      branch,
+      parents,
+      timestamp: new Date(event.timestamp),
+      icon: presentation.icon,
+      level: presentation.level,
+      message: presentation.message,
+    };
+    builder.addCommit(commit);
+
+    // Record begin commit so a later end event can merge into it.
+    if (isBeginEvent && !collapsible && span.id !== ROOT_SPAN_ID) {
+      beginCommitIdBySpan.set(span.id, commitId);
+    }
   }
 
+  // Append "running" indicators for processes that are still active.
   for (const process of activeProcesses) {
     if (
       process.key === AGENT_PROCESS_KEY &&
@@ -331,17 +421,16 @@ export const buildExecutionGraph = ({
     }
   }
 
-  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;
+  return builder.build();
 };
 
+const formatCommitId = (span: Span, globalIndex: number, suffix?: string): string => {
+  const base = `${span.id}:${globalIndex}`;
+  return suffix ? `${base}:${suffix}` : base;
+};
+
+const trimText = (text: string) => text.slice(0, 100).trim().split('\n')[0];
+
 type Falsy = false | null | undefined;
 
 export interface CommitSelector extends Pipeable.Pipeable {
@@ -479,9 +568,6 @@ export const CommitSelector = {
       }
       return [];
     }),
-
-  orderByTimestamp: (): CommitSelector =>
-    CommitSelector.make(Array.sortWith((a) => a.timestamp?.getTime() ?? 0, Order.number)),
 };
 
 class GraphBuilder {
@@ -496,50 +582,11 @@ class GraphBuilder {
     return this.#branches.has(branch);
   }
 
-  addCommit(
-    commit: Commit,
-    opts?: {
-      ifMissing?: CommitSelector;
-      /**
-       * Replace in-place the last commit that matches the selector.
-       */
-      replace?: CommitSelector;
-    },
-  ) {
-    if (opts?.ifMissing) {
-      if (this.findCommits(opts.ifMissing).length > 0) {
-        return;
-      }
-    }
+  addCommit(commit: Commit) {
     this.addBranch(commit.branch);
-    if (opts?.replace) {
-      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;
-      }
-    }
     this.#commits.push(commit);
   }
 
-  removeCommit(selector: CommitSelector) {
-    for (const commit of this.findCommits(selector)) {
-      this.#commits.splice(this.#commits.indexOf(commit), 1);
-    }
-  }
-
   /**
    * Computes parents — picks first matching commit's id.
    */
@@ -575,5 +622,3 @@ class GraphBuilder {
     };
   }
 }
-
-const trimText = (text: string) => text.slice(0, 100).trim().split('\n')[0];