@dxos/plugin-assistant 0.8.4-main.c1de068 → 0.8.4-main.c351d160a8

package/src/containers/ChatDialog/ChatDialog.tsx

@@ -0,0 +1,72 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback, useState } from 'react';
+
+import { useAtomCapability } from '@dxos/app-framework/ui';
+import { type Chat as ChatTypes } from '@dxos/assistant-toolkit';
+import { Obj } from '@dxos/echo';
+import { useTranslation } from '@dxos/react-ui';
+import { ChatDialog as NaturalChatDialog } from '@dxos/react-ui-chat';
+
+import { Chat, type ChatRootProps } from '../../components';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../../hooks';
+import { meta } from '../../meta';
+import { AssistantCapabilities } from '../../types';
+
+export type ChatDialogProps = {
+  chat?: ChatTypes.Chat;
+};
+
+export const ChatDialog = ({ chat }: ChatDialogProps) => {
+  const { t } = useTranslation(meta.id);
+
+  const db = chat && Obj.getDatabase(chat);
+  const settings = useAtomCapability(AssistantCapabilities.Settings);
+  const services = useChatServices({ id: db?.spaceId, chat });
+  const [online, setOnline] = useOnline();
+  const { preset, ...chatProps } = usePresets(online);
+  const blueprintRegistry = useBlueprintRegistry();
+  const processor = useChatProcessor({
+    chat,
+    preset,
+    services,
+    blueprintRegistry,
+    settings,
+  });
+
+  // TODO(burdon): Refocus when open.
+  const [open, setOpen] = useState(true);
+  const [expanded, setExpanded] = useState(false);
+  const handleEvent = useCallback<NonNullable<ChatRootProps['onEvent']>>((event) => {
+    switch (event.type) {
+      case 'submit':
+      case 'thread-open':
+        setOpen(true);
+        setExpanded(true);
+        break;
+      case 'thread-close':
+        setOpen(false);
+        break;
+    }
+  }, []);
+
+  if (!chat || !processor) {
+    return null;
+  }
+
+  return (
+    <Chat.Root chat={chat} processor={processor} onEvent={handleEvent}>
+      <NaturalChatDialog.Root open={open} expanded={expanded} onOpenChange={setOpen}>
+        <NaturalChatDialog.Header title={t('assistant dialog title')} />
+        <NaturalChatDialog.Content>
+          <Chat.Thread />
+        </NaturalChatDialog.Content>
+        <NaturalChatDialog.Footer classNames='p-1.5'>
+          <Chat.Prompt {...chatProps} preset={preset?.id} online={online} onOnlineChange={setOnline} expandable />
+        </NaturalChatDialog.Footer>
+      </NaturalChatDialog.Root>
+    </Chat.Root>
+  );
+};

package/src/containers/ChatDialog/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ChatDialog } from './ChatDialog';
+
+export default ChatDialog;

package/src/containers/Project/ProjectArticle.tsx

@@ -0,0 +1,124 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import React, { forwardRef, useMemo, useState } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps, useObjectMenuItems } from '@dxos/app-toolkit/ui';
+import { type Project } from '@dxos/assistant-toolkit';
+import { Annotation, Filter, Obj, Query } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { useQuery } from '@dxos/react-client/echo';
+import { Card, Panel, ScrollArea, Toolbar } from '@dxos/react-ui';
+import { Menu } from '@dxos/react-ui-menu';
+import { Focus, Mosaic, type MosaicTileProps } from '@dxos/react-ui-mosaic';
+import { isNonNullable } from '@dxos/util';
+
+export type ProjectArticleProps = SurfaceComponentProps<Project.Project>;
+
+export const ProjectArticle = ({ subject: project }: ProjectArticleProps) => {
+  const inputQueue = useAtomValue(
+    AtomObj.make(project).pipe((_) =>
+      Atom.make((get) =>
+        Option.fromNullable(get(_).queue).pipe(Option.map(AtomRef.make), Option.map(get), Option.getOrUndefined),
+      ),
+    ),
+  );
+
+  const inputQueueItems: Obj.Unknown[] = useQuery(inputQueue, Query.select(Filter.everything()));
+
+  const artifacts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(project).pipe((project) =>
+          Atom.make((get) => {
+            return get(project).artifacts.map((artifact) => get(AtomRef.make(artifact.data)) as Obj.Unknown);
+          }),
+        ),
+      [project],
+    ),
+  );
+
+  const [viewport, setViewport] = useState<HTMLElement | null>(null);
+
+  const stackObjects = [...artifacts, ...inputQueueItems].filter(isNonNullable);
+
+  return (
+    <Panel.Root className='dx-document'>
+      <Panel.Content>
+        {/* TODO(burdon): Factor out. */}
+        {stackObjects.length === 0 && (
+          <div className='text-subdued'>
+            Project has no objects associated with it.
+            <br />
+            <br />
+            To get started:
+            <br />- Write the initative spec: what is the goal of the project?
+            <br />- subscribe project to your email.
+            <br />- Chat with the agent.
+          </div>
+        )}
+
+        {stackObjects.length > 0 && (
+          <Focus.Group asChild>
+            <Mosaic.Container asChild withFocus autoScroll={viewport}>
+              <ScrollArea.Root orientation='vertical'>
+                <ScrollArea.Viewport classNames='p-2' ref={setViewport}>
+                  <Mosaic.Stack items={stackObjects} getId={(item) => item.id} draggable={false} Tile={StackTile} />
+                </ScrollArea.Viewport>
+              </ScrollArea.Root>
+            </Mosaic.Container>
+          </Focus.Group>
+        )}
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const StackTile = forwardRef<HTMLDivElement, MosaicTileProps<Obj.Unknown>>(
+  ({ data, location, debug }, forwardedRef) => {
+    const objectMenuItems = useObjectMenuItems(data);
+    const icon = Function.pipe(
+      Obj.getSchema(data),
+      Option.fromNullable,
+      Option.flatMap(Annotation.IconAnnotation.get),
+      Option.map(({ icon }) => icon),
+      Option.getOrElse(() => 'ph--placeholder--regular'),
+    );
+
+    return (
+      <Mosaic.Tile asChild id={data.id} data={data} location={location} debug={debug}>
+        <Focus.Group asChild>
+          <Menu.Root>
+            <Card.Root ref={forwardedRef} data-testid='board-item'>
+              <Card.Toolbar>
+                <Card.Icon icon={icon} />
+                <Card.Title>{Obj.getLabel(data)}</Card.Title>
+                {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
+                <Menu.Trigger asChild disabled={!objectMenuItems?.length}>
+                  <Toolbar.IconButton
+                    iconOnly
+                    variant='ghost'
+                    icon='ph--dots-three-vertical--regular'
+                    label='Actions'
+                  />
+                </Menu.Trigger>
+                <Menu.Content items={objectMenuItems} />
+              </Card.Toolbar>
+              <Card.Content>
+                <Surface.Surface role='card--content' limit={1} data={{ subject: data }} />
+              </Card.Content>
+            </Card.Root>
+          </Menu.Root>
+        </Focus.Group>
+      </Mosaic.Tile>
+    );
+  },
+);
+StackTile.displayName = 'StackTile';
+
+export default ProjectArticle;

package/src/containers/Project/ProjectSettings.tsx

@@ -0,0 +1,135 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom';
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import React, { useCallback, useEffect, useMemo } from 'react';
+
+import { useCapability } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { Project, syncProjectTriggers } from '@dxos/assistant-toolkit';
+import { DXN, Obj, Ref } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { QueueService } from '@dxos/functions';
+import { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { MarkdownEditor } from '@dxos/plugin-markdown';
+import { Filter, useQuery } from '@dxos/react-client/echo';
+import { useObject } from '@dxos/react-client/echo';
+import { Button } from '@dxos/react-ui';
+import { ButtonGroup, Input } from '@dxos/react-ui';
+import { FeedAnnotation } from '@dxos/schema';
+
+export const ProjectSettings = ({ subject: project }: SurfaceComponentProps<Project.Project>) => {
+  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+
+  const handleResetHistory = useCallback(async () => {
+    const runtime = computeRuntime.getRuntime(Obj.getDatabase(project)!.spaceId);
+
+    await runtime.runPromise(Project.resetChatHistory(project));
+
+    if (!project.queue) {
+      await runtime.runPromise(
+        Effect.gen(function* () {
+          const queue = yield* QueueService.createQueue();
+          Obj.change(project, (project) => {
+            project.queue = Ref.fromDXN(queue.dxn);
+          });
+        }),
+      );
+    }
+  }, [project, computeRuntime]);
+
+  const spec = useAtomValue(AtomRef.make(project.spec));
+  const [specInitialValue] = useObject(spec, 'content');
+
+  useEffect(() => {
+    const db = Obj.getDatabase(project);
+    if (!db) return;
+    const runtime = computeRuntime.getRuntime(db.spaceId);
+    return Obj.subscribe(project, () => {
+      queueMicrotask(() => runtime.runPromise(syncProjectTriggers(project)));
+    });
+  }, [project, computeRuntime]);
+
+  const db = Obj.getDatabase(project);
+  const feedFilter = useMemo(() => {
+    if (!db) {
+      return Filter.nothing();
+    }
+    const schemas = db.schemaRegistry.query({ location: ['database', 'runtime'] }).runSync();
+    const feedSchemas = schemas.filter((schema) => {
+      const annotation = FeedAnnotation.get(schema);
+      return Option.isSome(annotation) && annotation.value === true;
+    });
+    if (feedSchemas.length === 0) {
+      return Filter.nothing();
+    }
+    return Filter.or(...feedSchemas.map((schema) => Filter.type(schema)));
+  }, [db]);
+  const subscribableObjects = useQuery(db, feedFilter);
+
+  const existingSubscripts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(project).pipe((_) =>
+          Atom.make((get) => {
+            const project = get(_);
+            const selectedSubscriptions: Obj.Unknown[] = subscribableObjects.filter((object) =>
+              project.subscriptions.some((subscription) => DXN.equals(subscription.dxn, Obj.getDXN(object))),
+            );
+
+            return selectedSubscriptions;
+          }),
+        ),
+      [project, subscribableObjects],
+    ),
+  );
+
+  return (
+    <div className='flex flex-col gap-4'>
+      <Input.Root>
+        <Input.Label>Spec (what is the goal of the project?)</Input.Label>
+        <MarkdownEditor.Root id={spec?.id ?? ''} object={spec}>
+          <MarkdownEditor.Content initialValue={specInitialValue} />
+        </MarkdownEditor.Root>
+      </Input.Root>
+      <ButtonGroup classNames='h-10'>
+        <Button onClick={handleResetHistory}>Reset Chat History</Button>
+      </ButtonGroup>
+      <div>
+        <h2 className='text-lg font-bold'>Subscriptions</h2>
+        {subscribableObjects.length > 0 && (
+          <div>
+            {subscribableObjects.map((object) => (
+              <Input.Root key={object.id}>
+                <Input.Checkbox
+                  checked={existingSubscripts.includes(object)}
+                  onCheckedChange={(checked) => {
+                    Obj.change(project, (project) => {
+                      if (checked) {
+                        project.subscriptions.push(Ref.fromDXN(Obj.getDXN(object)));
+                      } else {
+                        project.subscriptions = project.subscriptions.filter(
+                          (subscription) => !DXN.equals(subscription.dxn, Obj.getDXN(object)),
+                        );
+                      }
+                    });
+                  }}
+                />
+                <Input.Label>{Obj.getLabel(object)}</Input.Label>
+              </Input.Root>
+            ))}
+          </div>
+        )}
+        {subscribableObjects.length === 0 && (
+          <div className='text-sm text-description'>Space has no feeds to subscribe to.</div>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default ProjectSettings;

package/src/containers/Project/index.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type ComponentType, type FunctionComponent, lazy } from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import type { Project } from '@dxos/assistant-toolkit';
+
+import type { ProjectArticleProps } from './ProjectArticle';
+
+export const ProjectArticle: ComponentType<ProjectArticleProps> = lazy(() => import('./ProjectArticle'));
+
+export const ProjectSettings: FunctionComponent<SurfaceComponentProps<Project.Project>> = lazy(
+  () => import('./ProjectSettings'),
+);

package/src/containers/PromptArticle/PromptArticle.tsx

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { AgentFunctions } from '@dxos/assistant-toolkit';
+import { type Prompt } from '@dxos/blueprints';
+import { Obj } from '@dxos/echo';
+import { type FunctionDefinition } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { invokeFunctionWithTracing, useComputeRuntimeCallback } from '@dxos/plugin-automation';
+import { Panel, Toolbar, useTranslation } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TemplateEditor } from '../../components';
+import { meta } from '../../meta';
+
+export type PromptArticleProps = SurfaceComponentProps<Prompt.Prompt>;
+
+export const PromptArticle = ({ role, attendableId, subject }: PromptArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  const { hasAttention } = useAttention(attendableId);
+  const db = Obj.getDatabase(subject);
+
+  const inputData = useMemo<FunctionDefinition.Input<typeof AgentFunctions.Prompt> | undefined>(
+    () =>
+      subject && db
+        ? {
+            prompt: db.makeRef(Obj.getDXN(subject)),
+            input: {},
+          }
+        : undefined,
+    [subject, db],
+  );
+
+  const handleRun = useComputeRuntimeCallback(
+    db?.spaceId,
+    () => {
+      invariant(inputData);
+      return invokeFunctionWithTracing(AgentFunctions.Prompt, inputData);
+    },
+    [inputData],
+  );
+
+  return (
+    <Panel.Root role={role} className='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} onClick={handleRun}>
+          <Toolbar.IconButton iconOnly icon='ph--play--regular' label={t('run prompt label')} onClick={handleRun} />
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <TemplateEditor id={subject.id} template={subject.instructions} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/PromptArticle/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { PromptArticle } from './PromptArticle';
+
+export default PromptArticle;

package/src/containers/TracePanel/TracePanel.tsx

@@ -0,0 +1,260 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import React, { useMemo } from 'react';
+
+import { Filter, Obj, Query } from '@dxos/echo';
+import { InvocationOutcome, InvocationTraceEndEvent, InvocationTraceStartEvent } from '@dxos/functions-runtime';
+import { useTriggerRuntimeControls } from '@dxos/plugin-automation';
+import { useActiveSpace } from '@dxos/plugin-space';
+import { type Space } from '@dxos/react-client/echo';
+import { Input, Panel, Toolbar, useTranslation } from '@dxos/react-ui';
+import { Timeline, type Commit } from '@dxos/react-ui-components';
+import { Message } from '@dxos/types';
+
+import { AtomObj, AtomQuery, AtomRef } from '@dxos/echo-atom';
+import { LogLevel } from '@dxos/log';
+import { Atom } from '@effect-atom/atom';
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Array from 'effect/Array';
+import { pipe } from 'effect/Function';
+import { meta } from '../../meta';
+
+export const TracePanel = () => {
+  const space = useActiveSpace();
+  if (!space) {
+    return null;
+  }
+
+  return <TracePanelMain space={space} />;
+};
+
+const TracePanelMain = ({ space }: { space: Space }) => {
+  const { t } = useTranslation(meta.id);
+  const { state, start, stop } = useTriggerRuntimeControls(space.db);
+  const isRunning = state?.enabled ?? false;
+
+  const { branches, commits } = useAtomValue(useMemo(() => getExecutionGraph(space), [space]));
+
+  return (
+    <Panel.Root>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root>
+          <Input.Root>
+            <Input.Switch checked={isRunning} onCheckedChange={isRunning ? stop : start} />
+          </Input.Root>
+          <span className='text-sm'>{t('trigger runtime label')}</span>
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content>
+        <Timeline branches={branches} commits={commits} compact />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+type InvocationInfo = {
+  startEvent: InvocationTraceStartEvent;
+  endEvent: InvocationTraceEndEvent | null;
+  subevents: Obj.Unknown[];
+};
+
+const getExecutionGraph = (
+  space: Space,
+  {
+    invocationsLimit = 100,
+    subeventsLimit = 20,
+    showSubeventsForLastNInvocations = 4,
+  }: { invocationsLimit?: number; subeventsLimit?: number; showSubeventsForLastNInvocations?: number } = {},
+): Atom.Atom<{
+  branches: string[];
+  commits: Commit[];
+}> => {
+  return pipe(
+    space.properties,
+    (_) => AtomObj.make(_),
+    // space properies => Atom<Atom<InvocationTraceEvent[]>>
+    (_) =>
+      Atom.make((get) => {
+        const queueDxn = get(_).invocationTraceQueue?.dxn;
+        return AtomQuery.make(
+          space.db,
+          !queueDxn
+            ? (Query.select(Filter.nothing()) as Query.Query<never>) // TODO(dmaretskyi): Broken echo types here.
+            : Query.select(
+                Filter.or(Filter.type(InvocationTraceStartEvent), Filter.type(InvocationTraceEndEvent)),
+              ).from({
+                queues: [queueDxn.toString()],
+              }),
+        );
+      }),
+    // Flatten atoms
+    (_) => Atom.make((get) => get(get(_))),
+    // Atom<InvocationTraceEvent[]> => Atom<InvocationInfo[]>
+    (_) =>
+      Atom.make((get) => {
+        const events = get(_);
+        const invocations: InvocationInfo[] = [];
+
+        for (const event of events) {
+          if (Schema.is(InvocationTraceStartEvent)(event)) {
+            const invocationInfo: InvocationInfo = {
+              startEvent: event,
+              endEvent: null,
+              subevents: [],
+            };
+            invocations.push(invocationInfo);
+          } else if (Schema.is(InvocationTraceEndEvent)(event)) {
+            const invocationInfo = invocations.find((i) => i.startEvent.invocationId === event.invocationId);
+            if (invocationInfo) {
+              invocationInfo.endEvent = event;
+            }
+          }
+        }
+
+        let expandedBudget = showSubeventsForLastNInvocations;
+        for (let i = invocations.length - 1; i >= 0; i--) {
+          const invocation = invocations[i];
+          if (!invocation.startEvent.invocationTraceQueue) {
+            continue;
+          }
+          const subevents = get(
+            AtomQuery.make(
+              space.db,
+              Query.select(Filter.everything())
+                .limit(subeventsLimit)
+                .from({ queues: [invocation.startEvent.invocationTraceQueue?.dxn?.toString()] }),
+            ),
+          );
+          invocation.subevents = subevents;
+          if (subevents.length > 0) {
+            expandedBudget--;
+          }
+          if (expandedBudget <= 0) {
+            break;
+          }
+        }
+
+        return invocations;
+      }),
+
+    // Build commit graph from InvocationInfo[]
+    (_) =>
+      Atom.make((get) => {
+        const invocations = get(_);
+        // Two alternating branches for subevents to save horizontal space.
+        const branches: string[] = ['invocations'];
+        const commits: Commit[] = [];
+
+        const sorted = invocations.sort((a, b) => a.startEvent.timestamp - b.startEvent.timestamp);
+        let idx = 0;
+        for (const invocation of sorted.slice(-invocationsLimit)) {
+          const trigger = invocation.startEvent.trigger && AtomRef.make(invocation.startEvent.trigger).pipe(get);
+          const fn =
+            (invocation.startEvent.invocationTarget &&
+              AtomRef.make(invocation.startEvent.invocationTarget).pipe(get)) ??
+            (trigger?.function && AtomRef.make(trigger.function).pipe(get));
+
+          const functionName = fn ? Obj.getLabel(fn) : undefined;
+          const triggerName = trigger?.spec?.kind ?? 'trigger';
+          const label = functionName ? `${functionName} on ${triggerName}` : triggerName;
+
+          const branchName = `invocation-${invocation.startEvent.invocationId.slice(0, 8)}`;
+
+          if (invocation.endEvent && invocation.subevents.length === 0) {
+            commits.push({
+              id: invocation.endEvent.id,
+              branch: 'invocations',
+              parents: commits.length > 0 ? [commits.at(-1)!.id] : [],
+              icon:
+                invocation.endEvent.outcome === InvocationOutcome.SUCCESS
+                  ? 'ph--check-circle--regular'
+                  : 'ph--x-circle--regular',
+              level: invocation.endEvent.outcome === InvocationOutcome.SUCCESS ? LogLevel.INFO : LogLevel.ERROR,
+              message: `${label} - ${invocation.endEvent.outcome}`,
+              timestamp: new Date(invocation.endEvent.timestamp),
+            });
+            continue;
+          }
+
+          commits.push({
+            id: invocation.startEvent.id,
+            branch: 'invocations',
+            parents: commits.length > 0 ? [commits.at(-1)!.id] : [],
+            icon: invocation.endEvent ? 'ph--play--regular' : 'ph--spinner-gap--regular',
+            level: invocation.endEvent ? LogLevel.INFO : LogLevel.VERBOSE,
+            message: label,
+            timestamp: new Date(invocation.startEvent.timestamp),
+          });
+
+          for (const subevent of invocation.subevents.slice(-subeventsLimit)) {
+            if (Obj.instanceOf(Message.Message, subevent)) {
+              for (const block of subevent.blocks) {
+                switch (block._tag) {
+                  case 'text':
+                    commits.push({
+                      id: subevent.id,
+                      branch: branchName,
+                      parents: [commits.at(-1)!.id],
+                      icon: 'ph--robot--regular',
+                      level: LogLevel.VERBOSE,
+                      message: block.text.slice(0, 50),
+                      timestamp: new Date(subevent.created),
+                    });
+                    if (!branches.includes(branchName)) {
+                      branches.push(branchName);
+                    }
+                    break;
+                  case 'toolCall':
+                    commits.push({
+                      id: subevent.id,
+                      branch: branchName,
+                      parents: [commits.at(-1)!.id],
+                      icon: 'ph--wrench--regular',
+                      level: LogLevel.VERBOSE,
+                      message: block.name,
+                      timestamp: new Date(subevent.created),
+                    });
+                    if (!branches.includes(branchName)) {
+                      branches.push(branchName);
+                    }
+                    break;
+                }
+              }
+            }
+          }
+
+          if (!invocation.endEvent && invocation.subevents.length > 0) {
+            commits.push({
+              id: invocation.startEvent.invocationId + 'pending',
+              branch: branchName,
+              parents: [commits.at(-1)!.id],
+              icon: 'ph--dots-three-vertical--regular',
+              level: LogLevel.VERBOSE,
+              message: 'Running...',
+              timestamp: new Date(),
+            });
+          }
+
+          if (invocation.endEvent && invocation.subevents.length > 0) {
+            commits.push({
+              id: invocation.endEvent.id,
+              branch: 'invocations',
+              parents: Array.dedupe([invocation.startEvent.invocationId, commits.at(-1)!.id]),
+              icon:
+                invocation.endEvent.outcome === InvocationOutcome.SUCCESS
+                  ? 'ph--check-circle--regular'
+                  : 'ph--x-circle--regular',
+              level: invocation.endEvent.outcome === InvocationOutcome.SUCCESS ? LogLevel.INFO : LogLevel.ERROR,
+              message: `${label} - ${invocation.endEvent.outcome === InvocationOutcome.SUCCESS ? 'Success' : 'Failure'}`,
+              timestamp: new Date(invocation.endEvent.timestamp),
+            });
+          }
+        }
+
+        return { branches, commits };
+      }),
+  );
+};