@dxos/plugin-assistant 0.8.4-main.7ace549 → 0.8.4-main.8baae0fced

package/dist/lib/neutral/execution-graph/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/execution-graph/execution-graph.ts", "../../../../src/execution-graph/span-tree.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Array from 'effect/Array';\nimport * as Either from 'effect/Either';\nimport { pipe } from 'effect/Function';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Schema from 'effect/Schema';\nimport * as Struct from 'effect/Struct';\n\nimport { AgentRequestBegin, AgentRequestEnd, CompleteBlock } from '@dxos/assistant';\nimport { Process, Trace } from '@dxos/compute';\nimport { AGENT_PROCESS_KEY } from '@dxos/functions-runtime';\nimport { LogLevel, log } from '@dxos/log';\nimport { type Commit } from '@dxos/react-ui-components';\nimport { type ContentBlock } from '@dxos/types';\n\nimport { ROOT_SPAN_ID, type Span, buildSpanTree, isSpanBeginEvent, isSpanEndEvent, walkSpanTree } from './span-tree';\n\n/**\n * Branch name for top-level operation invocations.\n */\nconst MAIN_BRANCH = 'main';\n\nconst ICONS = {\n  agentRequestBegin: {\n    icon: 'ph--atom--regular',\n    level: LogLevel.VERBOSE,\n  },\n  agentRequestEnd: {\n    icon: 'ph--atom--regular',\n    level: LogLevel.INFO,\n  },\n  userMessage: {\n    icon: 'ph--user--regular',\n    level: LogLevel.VERBOSE,\n  },\n  statusMessage: {\n    icon: 'ph--info--regular',\n    level: LogLevel.VERBOSE,\n  },\n  operationStart: {\n    icon: 'ph--function--regular',\n    level: LogLevel.VERBOSE,\n  },\n  operationEndSuccess: {\n    icon: 'ph--function--regular',\n    level: LogLevel.INFO,\n  },\n  operationEndError: {\n    icon: 'ph--function--regular',\n    level: LogLevel.ERROR,\n  },\n  toolCall: {\n    icon: 'ph--wrench--regular',\n    level: LogLevel.VERBOSE,\n  },\n  toolResultSuccess: {\n    icon: 'ph--wrench--regular',\n    level: LogLevel.INFO,\n  },\n  toolResultError: {\n    icon: 'ph--wrench--regular',\n    level: LogLevel.ERROR,\n  },\n  agentRequestRunning: {\n    icon: 'ph--spinner-gap--regular',\n    level: LogLevel.VERBOSE,\n  },\n  processRunning: {\n    icon: 'ph--spinner-gap--regular',\n    level: LogLevel.VERBOSE,\n  },\n} as const;\n\nexport interface BuildExecutionGraphParams {\n  traceMessages: Trace.Message[];\n  activeProcesses?: readonly Process.Info[];\n  eventLimit?: number;\n}\n\n/**\n * Builds a Timeline-compatible execution graph from trace messages and active processes.\n *\n * The conversion runs in two stages:\n *   1. `buildSpanTree` converts the flat list of trace messages into a hierarchical\n *      tree of spans grouped by process id (pid). See `./span-tree.ts`.\n *   2. `spanTreeToCommits` walks the tree and emits one commit per event, using the\n *      tree structure to decide which branch each commit belongs to and how to wire parents.\n *\n * Pure function — no signals or atoms.\n */\nexport type ExecutionGraph = {\n  branches: string[];\n  commits: Commit[];\n  spanTree: Span;\n  /** Commit id -> trace event. */\n  details: ExecutionGraphDetailsMap;\n};\n\nexport type ExecutionGraphDetailsMap = Record<string, Trace.FlatEvent | undefined>;\n\nexport const buildExecutionGraph = ({\n  traceMessages,\n  activeProcesses = [],\n  eventLimit = 500,\n}: BuildExecutionGraphParams): ExecutionGraph => {\n  const spanTree = buildSpanTree(traceMessages, { eventLimit });\n  const toolCallContext = buildToolCallContext(traceMessages);\n  const built = spanTreeToCommits(spanTree, activeProcesses, toolCallContext);\n  log('trace execution graph', {\n    traceMessages: traceMessages.length,\n    commits: built.commits.length,\n    branches: built.branches.length,\n    activeProcesses: activeProcesses.length,\n  });\n  return { ...built, spanTree };\n};\n\n/**\n * Lookup tables that pair `toolCall` blocks with their matching `toolResult` blocks so the\n * renderer can collapse the two events into a single commit (mirroring how begin/end events of\n * an empty operation span collapse). Indexed by the shared `toolCallId`.\n */\ninterface ToolCallContext {\n  callById: Map<string, ContentBlock.ToolCall>;\n  resultByCallId: Map<string, ContentBlock.ToolResult>;\n}\n\nconst buildToolCallContext = (messages: readonly Trace.Message[]): ToolCallContext => {\n  const callById = new Map<string, ContentBlock.ToolCall>();\n  const resultByCallId = new Map<string, ContentBlock.ToolResult>();\n  for (const message of messages) {\n    for (const event of message.events) {\n      if (event.type !== CompleteBlock.key) {\n        continue;\n      }\n      const data = event.data as { block?: ContentBlock.Any } | undefined;\n      const block = data?.block;\n      if (!block) {\n        continue;\n      }\n      if (block._tag === 'toolCall') {\n        callById.set(block.toolCallId, block);\n      } else if (block._tag === 'toolResult') {\n        resultByCallId.set(block.toolCallId, block);\n      }\n    }\n  }\n  return { callById, resultByCallId };\n};\n\n/**\n * Visual representation of a single trace event — icon, log level, message string.\n * `undefined` indicates that the event should not produce a commit.\n */\ninterface EventPresentation {\n  icon: string;\n  level: LogLevel;\n  message: string;\n  idSuffix?: string;\n}\n\nconst presentEvent = (event: Trace.FlatEvent, toolCallContext: ToolCallContext): EventPresentation | undefined => {\n  if (Trace.isOfType(AgentRequestBegin, event)) {\n    if (Either.isLeft(Schema.validateEither(AgentRequestBegin.schema)(event.data))) {\n      log('invalid trace event', { type: event.type });\n      return undefined;\n    }\n    return {\n      icon: ICONS.agentRequestBegin.icon,\n      level: ICONS.agentRequestBegin.level,\n      message: 'Agent processing request...',\n    };\n  }\n  if (Trace.isOfType(AgentRequestEnd, event)) {\n    if (Either.isLeft(Schema.validateEither(AgentRequestEnd.schema)(event.data))) {\n      log('invalid trace event', { type: event.type });\n      return undefined;\n    }\n    return {\n      icon: ICONS.agentRequestEnd.icon,\n      level: ICONS.agentRequestEnd.level,\n      message: 'Agent completed request',\n    };\n  }\n  if (Trace.isOfType(CompleteBlock, event)) {\n    if (Either.isLeft(Schema.validateEither(CompleteBlock.schema)(event.data))) {\n      log('invalid trace event', { type: event.type });\n      return undefined;\n    }\n    switch (event.data.block._tag) {\n      case 'text':\n        return event.data.role === 'user'\n          ? {\n              icon: ICONS.userMessage.icon,\n              level: ICONS.userMessage.level,\n              message: trimText(event.data.block.text),\n            }\n          : undefined;\n      case 'status':\n        return {\n          icon: ICONS.statusMessage.icon,\n          level: ICONS.statusMessage.level,\n          message: trimText(event.data.block.statusText),\n        };\n      case 'toolCall': {\n        // Operation-backed tool calls already have a dedicated routine span (Trace.OperationStart /\n        // Trace.OperationEnd) that produces its own commits — skip the duplicate toolCall commit\n        // to avoid double-rendering.\n        if (event.data.block.operationKey) {\n          return undefined;\n        }\n        // Collapse the toolCall/toolResult pair: when the matching toolResult has arrived, the\n        // result event is the visible commit and carries the success/error state. The toolCall\n        // itself only renders while still pending (i.e. no result yet) — same intent as an\n        // operation span that collapses to a single end commit once both boundaries are present.\n        if (toolCallContext.resultByCallId.has(event.data.block.toolCallId)) {\n          return undefined;\n        }\n        return {\n          icon: ICONS.toolCall.icon,\n          level: ICONS.toolCall.level,\n          message: event.data.block.name,\n          idSuffix: `toolCall:${event.data.block.toolCallId}`,\n        };\n      }\n      case 'toolResult': {\n        // Suppress results for operation-backed calls — those are covered by the routine span.\n        const call = toolCallContext.callById.get(event.data.block.toolCallId);\n        if (call?.operationKey) {\n          return undefined;\n        }\n        const success = event.data.block.error === undefined;\n        const name = call?.name ?? event.data.block.name;\n        return {\n          icon: success ? ICONS.toolResultSuccess.icon : ICONS.toolResultError.icon,\n          level: success ? ICONS.toolResultSuccess.level : ICONS.toolResultError.level,\n          message: `${name} - ${success ? 'Success' : 'Error'}`,\n          idSuffix: `toolResult:${event.data.block.toolCallId}`,\n        };\n      }\n      default:\n        return undefined;\n    }\n  }\n  if (Trace.isOfType(Trace.OperationStart, event)) {\n    if (Either.isLeft(Schema.validateEither(Trace.OperationStart.schema)(event.data))) {\n      log('invalid trace event', { type: event.type });\n      return undefined;\n    }\n    return {\n      icon: ICONS.operationStart.icon,\n      level: ICONS.operationStart.level,\n      message: event.data.name ?? event.data.key,\n      idSuffix: `${event.data.key}:start`,\n    };\n  }\n  if (Trace.isOfType(Trace.OperationEnd, event)) {\n    if (Either.isLeft(Schema.validateEither(Trace.OperationEnd.schema)(event.data))) {\n      log('invalid trace event', { type: event.type });\n      return undefined;\n    }\n    const success = event.data.outcome === 'success';\n    return {\n      icon: success ? ICONS.operationEndSuccess.icon : ICONS.operationEndError.icon,\n      level: success ? ICONS.operationEndSuccess.level : ICONS.operationEndError.level,\n      message: `${event.data.name ?? event.data.key} - ${success ? 'Success' : 'Error'}`,\n      idSuffix: `${event.data.key}:end`,\n    };\n  }\n  return undefined;\n};\n\n/**\n * A span is \"collapsible\" when it would otherwise render as an empty fork-and-merge:\n * exactly two events that form a begin/end pair and no child sub-spans. In that case\n * we emit a single commit for the end event on the parent branch.\n *\n * A *pending* span (one whose end event has not yet been recorded) is never collapsed:\n * its trailing events should keep rendering as middle commits on the span's own branch\n * — never as a fake \"end\" commit on the parent branch.\n *\n * Both nested spans and top-level spans (whose parent is the synthetic root) are eligible\n * once they have completed: a span with no inner activity is collapsed regardless of where\n * it sits in the tree.\n */\nconst isCollapsibleSpan = (span: Span, parent: Span | null): boolean => {\n  if (span.id === ROOT_SPAN_ID) {\n    return false;\n  }\n  if (span.events.length !== 2) {\n    return false;\n  }\n  if (span.children.length > 0) {\n    return false;\n  }\n  const firstEvent = span.events[0];\n  const lastEvent = span.events[span.events.length - 1];\n  if (!isSpanBeginEvent(firstEvent) || !isSpanEndEvent(lastEvent)) {\n    return false;\n  }\n  return parent !== null;\n};\n\n/**\n * Converts a span tree into a flat list of commits + branches suitable for `Timeline` rendering.\n *\n * For every span the algorithm:\n *  - emits the **first** event as a \"begin\" commit on the parent span's branch (fork);\n *  - emits **middle** events as commits on the span's own branch;\n *  - emits the **last** event as an \"end\" commit on the parent span's branch with two parents\n *    (the begin commit and the last commit on the span's own branch — a merge).\n *\n * Collapsible spans (`isCollapsibleSpan`) emit only the end commit on the parent branch with\n * a single parent — a tidier rendering for sub-operations that have no inner detail.\n *\n * Events are processed in global chronological order so that sub-operations of a span interleave\n * naturally with the span's own middle events.\n */\nconst spanTreeToCommits = (\n  root: Span,\n  activeProcesses: readonly Process.Info[],\n  toolCallContext: ToolCallContext,\n): { branches: string[]; commits: Commit[]; details: ExecutionGraphDetailsMap } => {\n  const builder = new GraphBuilder();\n  const details: ExecutionGraphDetailsMap = {};\n  builder.addBranch(MAIN_BRANCH);\n\n  // Build a child → parent lookup using the tree's own structure (already correctly parented\n  // when the tree was constructed, including sequential spans of the same process).\n  const parentBySpan = new Map<Span, Span | null>();\n  parentBySpan.set(root, null);\n  const indexParents = (span: Span): void => {\n    for (const child of span.children) {\n      parentBySpan.set(child, span);\n      indexParents(child);\n    }\n  };\n  indexParents(root);\n\n  const findParentSpan = (span: Span): Span | null => parentBySpan.get(span) ?? null;\n\n  // The branch name for a span is its pid — multiple sequential spans of the same process\n  // (e.g. successive agent requests in one session) share a branch so they reuse a single lane.\n  const branchOf = (span: Span | null): string => {\n    if (!span || span.id === ROOT_SPAN_ID) {\n      return MAIN_BRANCH;\n    }\n    return span.meta.pid ?? span.id;\n  };\n\n  // Selector that returns \"the most recent commit in this span's structural context\".\n  //\n  // The walk is structural (pid/parentPid), not topological: at each ancestor, we prefer\n  //   1) the last commit on that span's own branch, then\n  //   2) that span's begin commit (the fork point on its parent branch),\n  //   3) and only then recurse into the parent span.\n  //\n  // Crucially, we never silently slip onto a *sibling* span's commit on a shared ancestor\n  // branch. E.g. if a sub-span of agent A fires before A has any middle commits, we anchor\n  // to A.begin — not to whatever unrelated commit happens to be the latest on main.\n  // This keeps fork edges visually attached to the correct span even when sibling top-level\n  // spans (different pids) overlap in time on main.\n  const lastInSpanContext = (span: Span | null): CommitSelector => {\n    if (!span || span.id === ROOT_SPAN_ID) {\n      return CommitSelector.branch(MAIN_BRANCH).pipe(CommitSelector.compose(CommitSelector.last()));\n    }\n    const ownBranch = branchOf(span);\n    const beginId = beginCommitIdBySpan.get(span.id);\n    return CommitSelector.firstOf(\n      CommitSelector.branch(ownBranch).pipe(CommitSelector.compose(CommitSelector.last())),\n      beginId ? CommitSelector.id(beginId) : CommitSelector.filter(() => false),\n      lastInSpanContext(findParentSpan(span)),\n    );\n  };\n\n  // Flatten the tree into a chronological stream, recording each event's position within its span\n  // so we can detect begin/end events.\n  interface EventCursor {\n    span: Span;\n    event: Trace.FlatEvent;\n    eventIndex: number;\n    globalIndex: number;\n  }\n  const stream: EventCursor[] = [];\n  walkSpanTree(root, (span) => {\n    span.events.forEach((event, eventIndex) => {\n      stream.push({ span, event, eventIndex, globalIndex: stream.length });\n    });\n  });\n  stream.sort((a, b) => a.event.timestamp - b.event.timestamp || a.globalIndex - b.globalIndex);\n\n  // Track the id of the begin commit for each non-collapsible span so the end commit can merge into it.\n  const beginCommitIdBySpan = new Map<string, string>();\n\n  for (const { span, event, globalIndex } of stream) {\n    const presentation = presentEvent(event, toolCallContext);\n    if (!presentation) {\n      continue;\n    }\n\n    // Classify based on event TYPE, not array index. A pending span's trailing\n    // middle event (e.g. a user message awaiting an agent response) must not be\n    // mistaken for the span's end event — otherwise it would render on the\n    // parent branch instead of the span's own branch.\n    const isBeginEvent = isSpanBeginEvent(event);\n    const isEndEvent = isSpanEndEvent(event);\n    const parentSpan = findParentSpan(span);\n    const collapsible = isCollapsibleSpan(span, parentSpan);\n\n    // Collapsed spans: skip the begin event entirely; only the end event renders.\n    if (collapsible && isBeginEvent) {\n      continue;\n    }\n\n    const parentBranch = branchOf(parentSpan);\n    const ownBranch = branchOf(span);\n\n    let branch: string;\n    let parents: string[];\n\n    if (span.id === ROOT_SPAN_ID) {\n      // Root-level events (no pid) attach sequentially to main.\n      branch = MAIN_BRANCH;\n      parents = builder.computeParents(lastInSpanContext(null));\n    } else if (collapsible) {\n      // Only the end event reaches here for collapsible spans.\n      // Anchor to the parent span's structural context so the fork attaches to the parent\n      // — not to a sibling span's commit that happens to be the latest on the shared ancestor.\n      branch = parentBranch;\n      parents = builder.computeParents(lastInSpanContext(parentSpan));\n    } else if (isBeginEvent) {\n      // Begin commit: fork off the parent branch, attached to the parent's structural context.\n      branch = parentBranch;\n      parents = builder.computeParents(lastInSpanContext(parentSpan));\n    } else if (isEndEvent) {\n      // End commit: continues the parent branch chronologically and merges in own-branch work.\n      //\n      // Parent #1 is the *immediate predecessor* on the parent branch (not the matching begin\n      // commit). Pointing back to the begin commit creates a visual edge that skips over any\n      // sibling span's commits emitted between begin and end — e.g. when two top-level Routine\n      // spans overlap on main, R1.end would otherwise draw an arrow back to R1.begin that\n      // crosses over R2.begin. Anchoring to the previous main commit keeps main linear.\n      branch = parentBranch;\n      parents = builder.computeParents(\n        CommitSelector.unionAll(\n          CommitSelector.branch(parentBranch).pipe(CommitSelector.compose(CommitSelector.last())),\n          CommitSelector.branch(ownBranch).pipe(CommitSelector.compose(CommitSelector.last())),\n        ),\n      );\n    } else {\n      // Middle event: continue the span's own branch; fall back to span's own context so the\n      // first middle event of a span forks from the span's begin commit, not from a sibling's\n      // commit on an ancestor branch.\n      branch = ownBranch;\n      parents = builder.computeParents(lastInSpanContext(span));\n    }\n\n    const commitId = formatCommitId(span, globalIndex, presentation.idSuffix);\n    const commit: Commit = {\n      id: commitId,\n      branch,\n      parents,\n      timestamp: new Date(event.timestamp),\n      icon: presentation.icon,\n      level: presentation.level,\n      message: presentation.message,\n    };\n    builder.addCommit(commit);\n    details[commitId] = event;\n\n    // Record begin commit so a later end event can merge into it.\n    if (isBeginEvent && !collapsible && span.id !== ROOT_SPAN_ID) {\n      beginCommitIdBySpan.set(span.id, commitId);\n    }\n  }\n\n  // Append \"running\" indicators for processes that are still active.\n  for (const process of activeProcesses) {\n    if (\n      process.key === AGENT_PROCESS_KEY &&\n      process.params.target &&\n      (process.state === Process.State.RUNNING || process.state === Process.State.HYBERNATING)\n    ) {\n      builder.addCommit({\n        id: `running:${process.pid}`,\n        branch: process.pid,\n        parents: builder.computeParents(\n          CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last())),\n        ),\n        icon: ICONS.agentRequestRunning.icon,\n        level: ICONS.agentRequestRunning.level,\n        message: 'Generating...',\n        timestamp: new Date(),\n      });\n    } else if (process.state === Process.State.RUNNING && builder.hasBranch(process.pid)) {\n      builder.addCommit({\n        id: `running:${process.pid}`,\n        branch: process.pid,\n        parents: builder.computeParents(\n          CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last())),\n        ),\n        icon: ICONS.processRunning.icon,\n        level: ICONS.processRunning.level,\n        message: 'Running...',\n        timestamp: new Date(),\n      });\n    }\n  }\n\n  const { commits, branches } = builder.build();\n  return { commits, branches, details };\n};\n\nconst formatCommitId = (span: Span, globalIndex: number, suffix?: string): string => {\n  const base = `${span.id}:${globalIndex}`;\n  return suffix ? `${base}:${suffix}` : base;\n};\n\nconst trimText = (text: string) => text.slice(0, 100).trim().split('\\n')[0];\n\ntype Falsy = false | null | undefined;\n\nexport interface CommitSelector extends Pipeable.Pipeable {\n  select: (commits: Commit[]) => Commit[];\n}\n\nexport const CommitSelector = {\n  make: (select: CommitSelector['select']): CommitSelector => ({\n    select,\n    pipe(...args: any) {\n      return Pipeable.pipeArguments(this, args);\n    },\n  }),\n\n  identity: (): CommitSelector => CommitSelector.make((commits) => commits),\n\n  /**\n   * Selects commits that match the given predicate.\n   */\n  filter: (predicate: (commit: Commit) => unknown): CommitSelector =>\n    CommitSelector.make((commits) => commits.filter(predicate)),\n\n  /**\n   * Selects commits by id.\n   */\n  id: (id: string): CommitSelector => CommitSelector.filter((commit) => commit.id === id),\n  /**\n   * Selects commits by tag.\n   */\n  tag: (tag: string | Falsy): CommitSelector => CommitSelector.filter((commit) => tag && commit.tags?.includes(tag)),\n  /**\n   * Selects commits by if any of the given tags are present.\n   */\n  anyTags: (tags: (string | Falsy)[]): CommitSelector =>\n    CommitSelector.filter((commit) => tags.some((tag) => tag && commit.tags?.includes(tag))),\n  /**\n   * Selects commits by branch.\n   */\n  branch: (branch: string | Falsy): CommitSelector =>\n    CommitSelector.filter((commit) => branch && commit.branch === branch),\n\n  /**\n   * Chains two selectors together, applying the second selector to the result of the first.\n   *\n   * Example:\n   *\n   * ```\n   * CommitSelector.tag('tag').pipe(CommitSelector.compose(CommitSelector.branch('main')));\n   * ```\n   */\n  compose:\n    (next: CommitSelector) =>\n    (prev: CommitSelector): CommitSelector =>\n      CommitSelector.make((commits) => next.select(prev.select(commits))),\n\n  /**\n   * If `prev` selector matches no commits, return `next` selector, otherwise return `prev` selector.\n   * Same as `CommitSelector.firstOf(prev, next)`.\n   *\n   * Example:\n   *\n   * ```\n   * CommitSelector.tag('tag').pipe(CommitSelector.orElse(CommitSelector.branch('main')));\n   * ```\n   */\n  orElse:\n    (next: CommitSelector) =>\n    (prev: CommitSelector): CommitSelector =>\n      CommitSelector.make((commits) => {\n        const selected = prev.select(commits);\n        if (selected.length > 0) {\n          return selected;\n        }\n        return next.select(commits);\n      }),\n\n  /**\n   * Selects commits that match either of the given selectors.\n   */\n  andAlso:\n    (next: CommitSelector) =>\n    (prev: CommitSelector): CommitSelector =>\n      CommitSelector.unionAll(prev, next),\n\n  /**\n   * Selects the first n commits.\n   */\n  first: (n: number = 1): CommitSelector => CommitSelector.make((commits) => commits.slice(0, n)),\n  /**\n   * Selects the last n commits (reverses the order of the commits).\n   */\n  last: (n: number = 1): CommitSelector => CommitSelector.make((commits) => commits.toReversed().slice(0, n)),\n  /**\n   * Selects commits that do not match the given selector.\n   */\n  not: (selector: CommitSelector): CommitSelector =>\n    CommitSelector.make((commits) => {\n      const selected = selector.select(commits);\n      return commits.filter((commit) => !selected.includes(commit));\n    }),\n\n  /**\n   * Selects commits that match any of the given selectors.\n   */\n  unionAll: (...selectors: CommitSelector[]): CommitSelector =>\n    CommitSelector.make((commits) => {\n      return Array.dedupeWith(\n        selectors.flatMap((selector) => selector.select(commits)),\n        (a, b) => a.id === b.id,\n      );\n    }),\n\n  /**\n   * Selects commits that match all of the given selectors.\n   */\n  intersectAll: (...selectors: CommitSelector[]): CommitSelector =>\n    CommitSelector.make((commits) => {\n      const selected = selectors.map((selector) => selector.select(commits));\n      if (selected.length === 0) {\n        return [];\n      }\n      return selected[0].filter((commit) => selected.every((selected) => selected.some((c) => c.id === commit.id)));\n    }),\n\n  /**\n   * Returns the result of the first selector that matches any commits.\n   */\n  firstOf: (...selectors: CommitSelector[]): CommitSelector =>\n    CommitSelector.make((commits) => {\n      for (const selector of selectors) {\n        const selected = selector.select(commits);\n        if (selected.length > 0) {\n          return selected;\n        }\n      }\n      return [];\n    }),\n};\n\nclass GraphBuilder {\n  #commits: Commit[] = [];\n  #branches = new Set<string>();\n\n  findCommits(selector: CommitSelector): Commit[] {\n    return selector.select(this.#commits);\n  }\n\n  hasBranch(branch: string): boolean {\n    return this.#branches.has(branch);\n  }\n\n  addCommit(commit: Commit) {\n    this.addBranch(commit.branch);\n    this.#commits.push(commit);\n  }\n\n  /**\n   * Computes parents — picks first matching commit's id.\n   */\n  computeParents(selector: CommitSelector): string[] {\n    return Array.dedupe(selector.select(this.#commits).map((commit) => commit.id));\n  }\n\n  addBranch(branch: string) {\n    this.#branches.add(branch);\n  }\n\n  /**\n   * Removes duplicate commits and dangling parents.\n   */\n  doctor() {\n    this.#commits = pipe(\n      this.#commits,\n      Array.dedupeWith((a, b) => a.id === b.id),\n      Array.map(\n        Struct.evolve({\n          parents: (parents) =>\n            parents ? Array.filter(parents, (id) => this.#commits.some((commit) => commit.id === id)) : undefined,\n        }),\n      ),\n    );\n  }\n\n  build() {\n    this.doctor();\n    return {\n      commits: this.#commits,\n      branches: [...this.#branches],\n    };\n  }\n}\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { AgentRequestBegin, AgentRequestEnd } from '@dxos/assistant';\nimport { Trace } from '@dxos/compute';\n\n/**\n * Synthetic id assigned to the root span.\n * The root is a virtual container for top-level spans (those without a parent in the captured trace).\n */\nexport const ROOT_SPAN_ID = '<main>';\n\n/**\n * Computed metadata for a span.\n * Derived from the meta of the begin event that opened the span.\n */\nexport interface SpanMeta {\n  readonly pid?: string;\n  readonly parentPid?: string;\n  readonly processName?: string;\n  readonly conversationId?: string;\n  readonly triggerId?: string;\n  readonly toolCallId?: string;\n  readonly runtimeName?: string;\n}\n\n/**\n * A span in the trace hierarchy.\n *\n * Each span represents a single bounded unit of work — an operation invocation or an\n * agent request. Spans are opened by `OperationStart` / `AgentRequestBegin` events and\n * closed by their matching `OperationEnd` / `AgentRequestEnd` events. A single process\n * (pid) may produce multiple sequential spans (for example, an agent session that serves\n * three prompts produces three sibling spans sharing the agent's pid).\n *\n * `events` contains the bounded events for this span only — child spans' events are not\n * duplicated here. `children` contains sub-spans that opened while this span was active.\n */\nexport interface Span {\n  readonly id: string;\n  readonly meta: SpanMeta;\n  readonly events: Trace.FlatEvent[];\n  readonly children: Span[];\n}\n\nexport const BEGIN_EVENT_TYPES = new Set<string>([Trace.OperationStart.key, AgentRequestBegin.key]);\nexport const END_EVENT_TYPES = new Set<string>([Trace.OperationEnd.key, AgentRequestEnd.key]);\n\nexport const isSpanBeginEvent = (event: Trace.FlatEvent): boolean => BEGIN_EVENT_TYPES.has(event.type);\nexport const isSpanEndEvent = (event: Trace.FlatEvent): boolean => END_EVENT_TYPES.has(event.type);\n\nconst computeMeta = (rawMeta: Trace.Meta): SpanMeta => ({\n  pid: rawMeta.pid,\n  parentPid: rawMeta.parentPid,\n  processName: rawMeta.processName,\n  conversationId: rawMeta.conversationId,\n  triggerId: rawMeta.triggerId,\n  toolCallId: rawMeta.toolCallId,\n  runtimeName: rawMeta.runtimeName,\n});\n\ninterface MutableSpan {\n  id: string;\n  meta: SpanMeta;\n  events: Trace.FlatEvent[];\n  children: MutableSpan[];\n  firstTimestamp: number;\n}\n\nconst makeMutableSpan = (id: string, meta: SpanMeta): MutableSpan => ({\n  id,\n  meta,\n  events: [],\n  children: [],\n  firstTimestamp: Number.POSITIVE_INFINITY,\n});\n\nconst freezeSpan = (span: MutableSpan): Span => ({\n  id: span.id,\n  meta: span.meta,\n  events: span.events,\n  children: span.children.map(freezeSpan),\n});\n\nexport interface BuildSpanTreeOptions {\n  /**\n   * If provided, caps how many *non-boundary* events (status updates, partial blocks, etc.)\n   * are retained — only the most recent `eventLimit` of them survive. Span boundary events\n   * (`OperationStart` / `OperationEnd` / `AgentRequestBegin` / `AgentRequestEnd`) are *always*\n   * retained regardless of the limit, because dropping them would orphan their child spans\n   * and collapse them onto the root branch.\n   */\n  eventLimit?: number;\n}\n\n/**\n * Builds a hierarchical span tree from a list of trace messages.\n *\n * Algorithm:\n *   1. Flatten messages into events and sort them chronologically.\n *   2. For each event:\n *      - Begin events (`OperationStart`, `AgentRequestBegin`) open a new span whose parent\n *        is the currently-open span of the event's `meta.parentPid`, or the root if there is\n *        none. The begin event itself becomes the first event of the new span.\n *      - End events (`OperationEnd`, `AgentRequestEnd`) close the currently-open span for\n *        the event's `meta.pid` and become its last event.\n *      - Other events attach to the currently-open span for their `meta.pid`, or to the\n *        root span if no span is currently open for that pid (or the event has no pid).\n *   3. Sort each span's children by their earliest event timestamp.\n */\nexport const buildSpanTree = (messages: Trace.Message[], options: BuildSpanTreeOptions = {}): Span => {\n  const allEvents = messages.flatMap((message) => Trace.flatten(message));\n  allEvents.sort((a, b) => a.timestamp - b.timestamp);\n\n  // The limit caps verbose middle events (status/partial-block) only. Span boundary events\n  // are always retained so the parent/child structure of older spans isn't dropped — losing a\n  // begin event detaches every descendant and collapses them onto the root branch.\n  const events = applyEventLimit(allEvents, options.eventLimit);\n\n  const root = makeMutableSpan(ROOT_SPAN_ID, {});\n\n  // Currently-open span for each pid.\n  // A process may host multiple sequential spans (e.g. successive agent requests), so we\n  // track the active one and start a new span on the next begin event.\n  const openSpans = new Map<string, MutableSpan>();\n\n  let spanCounter = 0;\n  const allocSpanId = (pid: string): string => {\n    const id = `${pid}#${spanCounter}`;\n    spanCounter += 1;\n    return id;\n  };\n\n  const noteTimestamp = (span: MutableSpan, timestamp: number): void => {\n    if (timestamp < span.firstTimestamp) {\n      span.firstTimestamp = timestamp;\n    }\n  };\n\n  for (const event of events) {\n    const pid = event.meta.pid;\n\n    if (!pid) {\n      // Events without a pid attach to the root.\n      root.events.push(event);\n      noteTimestamp(root, event.timestamp);\n      continue;\n    }\n\n    if (BEGIN_EVENT_TYPES.has(event.type)) {\n      const parentPid = event.meta.parentPid;\n      const parent = (parentPid && openSpans.get(parentPid)) || root;\n      const span = makeMutableSpan(allocSpanId(pid), computeMeta(event.meta));\n      span.events.push(event);\n      noteTimestamp(span, event.timestamp);\n      parent.children.push(span);\n      // The new span supersedes any previously-open span for this pid.\n      openSpans.set(pid, span);\n      continue;\n    }\n\n    if (END_EVENT_TYPES.has(event.type)) {\n      const span = openSpans.get(pid);\n      if (span) {\n        span.events.push(event);\n        noteTimestamp(span, event.timestamp);\n        openSpans.delete(pid);\n      } else {\n        // End event without a matching begin — attach to root so the event isn't lost.\n        root.events.push(event);\n        noteTimestamp(root, event.timestamp);\n      }\n      continue;\n    }\n\n    // Non-boundary event: attach to the currently-open span for this pid if any.\n    const open = openSpans.get(pid);\n    if (open) {\n      open.events.push(event);\n      noteTimestamp(open, event.timestamp);\n    } else {\n      root.events.push(event);\n      noteTimestamp(root, event.timestamp);\n    }\n  }\n\n  // Sort children chronologically for deterministic output.\n  const sortChildren = (span: MutableSpan): void => {\n    span.children.sort((a, b) => a.firstTimestamp - b.firstTimestamp);\n    for (const child of span.children) {\n      sortChildren(child);\n    }\n  };\n  sortChildren(root);\n\n  return freezeSpan(root);\n};\n\n/**\n * Caps the number of non-boundary events while retaining every span boundary event.\n *\n * Boundary events define the span tree's structure: dropping a begin event detaches every\n * descendant span (its `parentPid` lookup fails, so children fall back to the root), and\n * dropping an end event leaves a span open and corrupts the open-span map for sibling spans\n * that share a pid. Status/partial-block events are the noisy bulk and the only ones the\n * limit needs to control.\n *\n * The returned array stays in chronological order.\n */\nconst applyEventLimit = (events: readonly Trace.FlatEvent[], eventLimit: number | undefined): Trace.FlatEvent[] => {\n  if (eventLimit === undefined) {\n    return [...events];\n  }\n\n  let nonBoundaryCount = 0;\n  for (const event of events) {\n    if (!isBoundary(event)) {\n      nonBoundaryCount += 1;\n    }\n  }\n  if (nonBoundaryCount <= eventLimit) {\n    return [...events];\n  }\n\n  const dropCount = nonBoundaryCount - eventLimit;\n  let dropped = 0;\n  const result: Trace.FlatEvent[] = [];\n  for (const event of events) {\n    if (!isBoundary(event) && dropped < dropCount) {\n      dropped += 1;\n      continue;\n    }\n    result.push(event);\n  }\n  return result;\n};\n\nconst isBoundary = (event: Trace.FlatEvent): boolean =>\n  BEGIN_EVENT_TYPES.has(event.type) || END_EVENT_TYPES.has(event.type);\n\n/**\n * Walks the span tree in depth-first pre-order, invoking `visit` for each span (root included).\n */\nexport const walkSpanTree = (root: Span, visit: (span: Span, depth: number) => void, depth = 0): void => {\n  visit(root, depth);\n  for (const child of root.children) {\n    walkSpanTree(child, visit, depth + 1);\n  }\n};\n\n/**\n * Returns all spans in the tree in depth-first pre-order, root first.\n */\nexport const flattenSpanTree = (root: Span): Span[] => {\n  const result: Span[] = [];\n  walkSpanTree(root, (span) => result.push(span));\n  return result;\n};\n"],
+  "mappings": "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",
+  "names": ["Array", "Either", "pipe", "Pipeable", "Schema", "Struct", "AgentRequestBegin", "AgentRequestEnd", "CompleteBlock", "Process", "Trace", "AGENT_PROCESS_KEY", "LogLevel", "log", "AgentRequestBegin", "AgentRequestEnd", "Trace", "ROOT_SPAN_ID", "BEGIN_EVENT_TYPES", "Set", "OperationStart", "key", "END_EVENT_TYPES", "OperationEnd", "isSpanBeginEvent", "event", "has", "type", "isSpanEndEvent", "computeMeta", "rawMeta", "pid", "parentPid", "processName", "conversationId", "triggerId", "toolCallId", "runtimeName", "makeMutableSpan", "id", "meta", "events", "children", "firstTimestamp", "Number", "POSITIVE_INFINITY", "freezeSpan", "span", "map", "buildSpanTree", "messages", "options", "allEvents", "flatMap", "message", "flatten", "sort", "a", "b", "timestamp", "applyEventLimit", "eventLimit", "root", "openSpans", "Map", "spanCounter", "allocSpanId", "noteTimestamp", "push", "parent", "get", "set", "delete", "open", "sortChildren", "child", "undefined", "nonBoundaryCount", "isBoundary", "dropCount", "dropped", "result", "walkSpanTree", "visit", "depth", "flattenSpanTree", "agentRequestBegin", "LogLevel", "agentRequestEnd", "userMessage", "statusMessage", "operationStart", "operationEndSuccess", "INFO", "operationEndError", "toolCall", "level", "toolResultSuccess", "toolResultError", "agentRequestRunning", "VERBOSE", "processRunning", "eventLimit", "log", "traceMessages", "commits", "length", "branches", "built", "activeProcesses", "spanTree", "Map", "message", "messages", "event", "CompleteBlock", "block", "_tag", "resultByCallId", "toolCallId", "isLeft", "Schema", "AgentRequestBegin", "type", "undefined", "Trace", "AgentRequestEnd", "data", "role", "ICONS", "trimText", "idSuffix", "success", "icon", "name", "key", "span", "events", "children", "firstEvent", "isSpanBeginEvent", "parent", "details", "builder", "addBranch", "MAIN_BRANCH", "indexParents", "child", "set", "CommitSelector", "branch", "ownBranch", "branchOf", "firstOf", "stream", "walkSpanTree", "forEach", "eventIndex", "globalIndex", "beginCommitIdBySpan", "presentEvent", "presentation", "parentSpan", "findParentSpan", "collapsible", "isCollapsibleSpan", "isBeginEvent", "parents", "parentBranch", "isEndEvent", "commitId", "formatCommitId", "id", "timestamp", "addCommit", "commit", "process", "computeParents", "Date", "state", "base", "text", "slice", "make", "select", "args", "identity", "selected", "next", "includes", "GraphBuilder", "findCommits", "selector", "hasBranch", "push", "build"]
+}